Short Answer Questions:

1. Define software engineering.

 Systematic Approach: A structured, organized method for

developing software.
 Multidisciplinary Field: Combines principles from computer
science, project management, and engineering.
 Lifecycle Management: Covers development, deployment,
maintenance, and retirement of software.

2. What are the key attributes of good software?

 Maintainability: Easy to update and adapt.

 Dependability: Reliable and secure.
 Efficiency: Uses resources optimally.
 Acceptability: Meets user needs and is easy to use.

3. Explain the difference between generic and bespoke software.

 Generic Software: Built for a general market (e.g., Microsoft

Word).
 Bespoke Software: Tailored to a specific client's requirements.

4. List the four fundamental software process activities.

 Specification: Defining software requirements.

 Development: Designing and coding the software.
 Validation: Testing to ensure correctness.
 Evolution: Updating and maintaining software over time.

5. What is the difference between software engineering and

computer science?

 Software Engineering: Practical application, building real-world

systems.
 Computer Science: Focuses on algorithms, theory, and
computation principles.

6. What are the main costs in software development?

  Development Costs: ~60% of total cost.
 Testing Costs: ~40% of total cost.
 Maintenance Costs: Often exceed initial development costs.

7. Define software maintainability.

 Flexibility: Easy to modify or enhance.

 Debuggability: Easy to find and fix defects.
 Adaptability: Can evolve with changing requirements.

8. What is defect density?

 Definition: Number of defects per thousand lines of code (KLOC).

 Purpose: Measures software quality.
 Industry Standard: Less than 1 defect/KLOC in high-quality
systems.

9. Explain the concept of software evolution.

 Continuous Improvement: Software adapts to changing needs.

 Bug Fixes: Ongoing correction of issues.
 Feature Updates: Adding new functionality as requirements
evolve.

10. List any three challenges in software engineering.

 Scalability: Handling large, complex systems.

 Managing Change: Adapting to evolving requirements.
 Balancing Quality & Cost: Delivering reliable software within
budget constraints.

Descriptive Questions:

1. Describe the software development lifecycle (SDLC).

 Requirements Gathering: Understanding what the software needs

to do.
 Design: Planning the system architecture.
  Implementation: Writing and compiling the code.
 Testing: Verifying that the software works as intended.
 Deployment: Releasing the software to users.
 Maintenance: Fixing bugs and adding features after release.

2. Explain the key differences between student software and

industrial-strength software.

 Student Software:
o Minimal documentation and testing.
o Tolerates bugs.
o Limited scalability.
 Industrial Software:
o Extensive documentation and rigorous testing.
o Bugs are not tolerated.
o Designed for scalability and reliability.

3. Discuss the importance of software engineering ethics with

examples.

 Public Interest: Prioritizing user safety (e.g., medical software

accuracy).
 Confidentiality: Protecting client data.
 Integrity: Being honest about limitations and realistic about
timelines.

Case Study-Based Questions (with Process):

1. Insulin Pump System: What safety measures should be prioritized

when developing software for medical devices?

 Process:
o Requirement Analysis: Gather precise medical requirements
(e.g., insulin dosage calculation logic).
o Design: Design a fault-tolerant, modular system with
redundancy.
 o Implementation: Write error-handling code and implement
real-time monitoring.
o Testing: Perform unit, integration, and stress testing under
various scenarios.
o Deployment: Gradual rollout with constant monitoring.
o Maintenance: Regular updates, bug fixes, and adaptation to
evolving medical standards.
 Key Measures:
o Real-Time Error Detection: Prevent incorrect doses.
o Redundancy: Backup systems in case of failure.
o Thorough Testing: Simulate real-world scenarios.

2. Mental Health Care System: How should privacy and security be

handled in patient information systems?

 Process:
o Requirement Analysis: Identify security and privacy
regulations (e.g., HIPAA).
o Design: Design a secure architecture with encryption and
access control.
o Implementation: Code secure login systems, encryption
mechanisms, and logging.
o Testing: Perform security audits, penetration testing, and
vulnerability scans.
o Deployment: Roll out the system with ongoing monitoring.
o Maintenance: Regular updates to patch vulnerabilities.
 Key Measures:
o Data Encryption: Protects sensitive records.
o Access Control: Limits data access to authorized personnel.
o Regular Audits: Ensures ongoing compliance.

3. Wilderness Weather Station: What software design considerations

are important for systems deployed in remote locations?

 Process:
o Requirement Analysis: Define environmental factors and
sensor requirements.
o Design: Design a distributed, energy-efficient system.
o Implementation: Write lightweight, power-aware code.
 o Testing: Simulate extreme weather conditions and network
disruptions.
o Deployment: Deploy in stages, starting with pilot stations.
o Maintenance: Enable remote monitoring and automatic
updates.
 Key Considerations:
o Fault Tolerance: Handle unexpected failures.
o Power Management: Optimize energy usage.
o Offline Capability: Collect data even when disconnected.

Software Engineering Practice Questions with Point-Wise Model

Answers

Additional Important Topics:

Software Process Models:

 Waterfall Model: Sequential, structured, each phase completed

before the next.
 Agile Model: Iterative, flexible, emphasizes collaboration and
responsiveness to change.
 Spiral Model: Combines iterative development with risk analysis.
 V-Model: Verification and validation happen in parallel to
development.

Software Quality Factors (ISO 9126):

 Functionality: Does the software meet requirements?

 Reliability: Can the system perform under specific conditions?
 Usability: Is the system easy to use and understand?
 Efficiency: Is the system resource-friendly?
 Maintainability: Can the software be modified easily?
 Portability: Can the system run on different environments?

Metrics and Measurement:

 Lines of Code (LOC): Measures the size of a software system.

 Function Points: Measures functionality provided to users.
  Cyclomatic Complexity: Measures the complexity of decision
paths.
 Defect Density: Defects per KLOC, measures software quality.

Software Tools & Methodologies:

 IDEs: (e.g., Visual Studio, Eclipse) help with coding and

debugging.
 Version Control: (e.g., Git) tracks changes and enables team
collaboration.
 Testing Frameworks: (e.g., JUnit, Selenium) automate testing.
 CI/CD Pipelines: Automate build, test, and deployment processes.

Real-World Software Failures & Lessons:

 Ariane 5 Rocket Failure (1996): Integer overflow due to lack of

testing.
 Therac-25 Radiation Machine: Race condition caused fatal
overdoses.
 Knight Capital Trading Disaster (2012): Deployment error caused
$440M loss.
 Takeaway: Rigorous testing, proper error handling, and phased
rollouts prevent catastrophic failures.

Comprehensive Software Engineering Exam Notes

Core Definitions:
 Software Engineering: The systematic application of engineering
approaches to software development to build reliable, efficient,
and maintainable systems.
 Software Process Model: A structured sequence of stages in
software development, like Waterfall, Agile, or Spiral.
 Software Quality: The degree to which software meets
requirements and user expectations, measured through attributes
like functionality, reliability, and maintainability.
  Defect Density: The number of defects found per thousand lines of
code, used to assess software quality.
 Cyclomatic Complexity: A metric that measures the number of
linearly independent paths in code, indicating its complexity.

Software Process Models:

 Waterfall Model: Linear, sequential development process with
distinct phases.
 Agile Model: Iterative, flexible, with continuous feedback and
adaptability.
 Spiral Model: Combines iterative development with risk
management.
 V-Model: Emphasizes testing at every development stage.
Additional Notes:
 Each model has trade-offs — Waterfall is simple but inflexible;
Agile adapts but may lack structure.

Software Quality Factors (ISO 9126):

 Functionality: The system’s ability to perform required tasks.
 Reliability: Consistent performance under specified conditions.
 Usability: Ease of use and learnability.
 Efficiency: Optimal use of resources.
 Maintainability: Ease of modifications and updates.
 Portability: Ability to run across different environments.
Example: A web app with frequent crashes has low reliability, even if it
meets functional requirements.
Metrics and Measurement:
 Lines of Code (LOC): Measures software size.
 Function Points: Quantifies software functionality.
 Defect Density: Defects per KLOC.
 Cyclomatic Complexity: Measures code complexity — higher
values indicate higher testing effort.

Software Tools & Methodologies:

 IDEs (e.g., Visual Studio, Eclipse): Provide a development
environment with features like debugging and code completion.
 Version Control (e.g., Git): Tracks and manages code changes.
 Testing Frameworks (e.g., JUnit, Selenium): Automate testing
processes.
 CI/CD Pipelines: Automate build, test, and deployment stages.

Real-World Software Failures & Lessons:

 Ariane 5 Rocket Failure: Integer overflow from reused code caused
a $370 million explosion.
 Therac-25 Incident: Race condition in radiation therapy machine
led to fatal overdoses.
 Knight Capital Disaster: Faulty deployment process caused a
$440 million loss in 45 minutes.
Key Takeaways:
 Test thoroughly for edge cases.
 Use version control and staged deployments.
 Prioritize safety in critical systems.
Case Study-Based Processes:
1. Insulin Pump System:
 Process: Requirement analysis → Design → Implementation →
Testing → Deployment → Maintenance.
 Key Considerations: Real-time error detection, fault tolerance,
rigorous validation.
2. Mental Health Care System:
 Process: Requirement analysis → Security design →
Implementation → Security testing → Ongoing monitoring.
 Key Considerations: Encryption, access control, privacy
compliance.
3. Wilderness Weather Station:
 Process: Environmental analysis → Power-efficient design →
Lightweight implementation → Stress testing → Deployment with
remote monitoring.
 Key Considerations: Fault tolerance, offline capability, automatic
updates.

With all this, you’ve got a solid foundation for short definitions, in-depth
descriptions, and case study insights! Let me know if you’d like to add
more examples or refine anything further!