SOFTWARE ENGINEERING - PART B & PART C ANSWERS (15 MARKS EACH)

-------------------------------------------------------------- Q14. Agile Software Development Model and its

Principles -------------------------------------------------------------- Definition: Agile Software Development is
an iterative and incremental approach that focuses on delivering working software quickly while
adapting to change. It emphasizes individuals and interactions, working software, customer
collaboration, and responding to change. Principles: 1. Customer satisfaction through continuous
delivery. 2. Welcome changing requirements. 3. Deliver working software frequently. 4.
Collaboration between business and developers. 5. Motivated individuals and face-to-face
communication. 6. Working software is the measure of progress. 7. Sustainable development and
technical excellence. 8. Simplicity and self-organizing teams. Conclusion: Agile helps teams deliver
quality software faster and adapt quickly to changing requirements.
-------------------------------------------------------------- Q15. COCOMO Model for Software Cost Estimation
-------------------------------------------------------------- Definition: COCOMO (Constructive Cost Model) by
Barry Boehm estimates software effort, time, and cost based on project size. Types of COCOMO:
1. Basic COCOMO – uses size (KLOC) only. 2. Intermediate COCOMO – includes cost drivers. 3.
Detailed COCOMO – considers project phases. Formula: Effort = a × (KLOC)^b Development Time
= c × (Effort)^d Parameters: Organic (2.4,1.05,2.5,0.38) Semi-detached (3.0,1.12,2.5,0.35)
Embedded (3.6,1.20,2.5,0.32) Example (400 KLOC): Organic: Effort=1202.4 PM, Time=24.9
months Semi-detached: Effort=1748.8 PM, Time=26.5 months Embedded: Effort=2488 PM,
Time=28.6 months Conclusion: COCOMO provides a structured way to estimate cost and
schedule. -------------------------------------------------------------- Q16. Software Requirements
Specification (SRS) -------------------------------------------------------------- Definition: SRS defines what
the system should do, describing both functional and non-functional requirements. Components: 1.
Introduction (Purpose, Scope) 2. Overall Description (Constraints, Assumptions) 3. System
Features 4. External Interfaces 5. Non-functional Requirements 6. System Attributes 7. Appendices
Conclusion: SRS ensures all stakeholders clearly understand the system before development.
-------------------------------------------------------------- Q17. Real-Time and Distributed System Design
-------------------------------------------------------------- Real-Time System: Responds within fixed time;
e.g., Flight control. Principles: Predictability, Concurrency, Fault tolerance. Distributed System:
Multiple computers connected as one system. Principles: Transparency, Scalability, Fault
tolerance, Security. Conclusion: Real-time focuses on timing, distributed focuses on resource
sharing. -------------------------------------------------------------- Q18. Programming Standards and
Documentation Guidelines -------------------------------------------------------------- Programming
Standards: - Naming conventions, indentation, commenting. - Error handling, version control, code
reviews. Documentation Guidelines: 1. User Documentation 2. System Documentation 3. Technical
Documentation 4. Inline Comments 5. Change Logs Conclusion: Standards improve readability,
consistency, and maintenance. -------------------------------------------------------------- Q19. Software
Maintenance and its Types -------------------------------------------------------------- Definition: Software
Maintenance modifies and updates software after delivery. Types: 1. Corrective – Fixing errors. 2.
Adaptive – Adjusting to new environments. 3. Perfective – Enhancing features. 4. Preventive –
Preventing future problems. Conclusion: Ensures long-term efficiency and reliability of software.
-------------------------------------------------------------- PART – C
-------------------------------------------------------------- Q20. Planning the Software Development Process
-------------------------------------------------------------- Steps: 1. Project Initiation 2. Feasibility Study 3.
Requirement Analysis 4. Project Scheduling 5. Resource Planning 6. Risk Management 7.
Communication Plan 8. Monitoring and Control 9. Project Closure Importance: Reduces
uncertainty, ensures timely delivery. Conclusion: Planning provides direction and resource
efficiency. -------------------------------------------------------------- Q21. Software Cost Estimation
Techniques -------------------------------------------------------------- 1. Expert Judgment 2. Delphi
Technique 3. Algorithmic Models (COCOMO) 4. Top-Down 5. Bottom-Up 6. Analogy 7. Parkinson’s
Law 8. Price-to-Win Conclusion: Combining expert judgment and models gives accurate estimates.
-------------------------------------------------------------- Q22. Software Configuration Management (SCM)
-------------------------------------------------------------- Tasks: 1. Configuration Identification 2.
Configuration Control 3. Status Accounting 4. Configuration Auditing 5. Version Control 6. Build
Management 7. Release Management Conclusion: SCM ensures consistency, control, and product
integrity. -------------------------------------------------------------- Q23. Characteristics of a Good Design
-------------------------------------------------------------- Good Design: Simple, modular, efficient, reusable.
Coupling: - Degree of interdependence between modules. Types: Content, Common, Control,
Stamp, Data (best). Cohesion: - Degree to which module elements belong together. Types:
Coincidental to Functional (best). Design Evaluation: By reviews, walkthroughs, and metrics.
Conclusion: Good design = High cohesion + Low coupling.
-------------------------------------------------------------- Q24. Black Box and White Box Testing Techniques
-------------------------------------------------------------- Black Box Testing: - Focus on functionality.
Techniques: Equivalence Partitioning, BVA, Decision Table, State Transition, Use Case. White Box
Testing: - Focus on internal code. Techniques: Statement, Branch, Path, Loop, Condition
Coverage. Differences: Black Box – Functionality (testers) White Box – Logic (developers)
Conclusion: Both together ensure correctness and reliability.