Software Engineering Notes
Unit 1: The Software Product and Software Process
Software Product and Process Characteristics:
- Software products are developed for a purpose, and their quality depends on functionality, usability,
efficiency, reliability, maintainability, and portability.
- Software processes define the steps to produce software, including activities, methods, practices, and tools.
Software Process Models:
1. Linear Sequential Model (Waterfall):
- Follows a strict sequence: Requirements Design Implementation Testing Deployment Maintenance.
- Suitable for projects with well-defined requirements.
2. Prototyping Model:
- Involves building a prototype to clarify requirements and get user feedback early.
- Helps in refining requirements.
3. RAD (Rapid Application Development):
- Emphasizes quick development using component-based construction.
- Suitable for systems that can be modularized.
4. Evolutionary Process Models:
- Incremental Model: Develops system in increments, each delivering a portion of functionality.
- Spiral Model: Combines iterative development with risk analysis.
- Component Assembly Model: Reuses existing components to build new systems.
- Rational Unified Process (RUP): Iterative software development framework.
- Agile Processes: Emphasizes collaboration, flexibility, working software, and customer feedback.
Software Process Customization and Improvement:
- Tailoring standard processes to fit specific project needs.
- Continuous improvement via feedback, metrics, and reviews.
Capability Maturity Model (CMM):
- A framework to assess and improve software processes.
- Levels: Initial, Repeatable, Defined, Managed, Optimizing.
Software Engineering Notes
Product and Process Metrics:
- Product metrics: Size, complexity, performance.
- Process metrics: Productivity, defect rate, effort, cost, time.
Software Engineering Notes
Unit 2: Requirement Elicitation, Analysis, and Specification
Requirement Elicitation, Analysis, and Specification:
Functional Requirements:
- Define system behavior, functions, and services.
Non-functional Requirements:
- Constraints such as performance, reliability, security, usability.
Requirement Sources:
- Stakeholders, existing systems, standards, documents.
Elicitation Techniques:
- Interviews, questionnaires, observations, workshops, brainstorming, use cases.
Analysis Modeling:
- Function-oriented: DFDs, flowcharts.
- Object-oriented: Class diagrams, interaction diagrams.
Use Case Modeling:
- Describes user-system interaction through use cases and actors.
SRS (System and Software Requirement Specification):
- Structured document that defines all requirements in detail.
Requirement Validation:
- Ensures requirements are complete, consistent, and correct.
Traceability:
- Linking requirements to design, implementation, and testing.
Software Engineering Notes
Unit 3: Software Design
Software Design:
Software Design Process:
- Translating requirements into architecture and design models.
Design Concepts and Principles:
- Abstraction, modularity, information hiding, cohesion, coupling.
Software Modeling and UML:
- UML: Unified Modeling Language used for class diagrams, sequence diagrams, activity diagrams, etc.
Architectural Design:
- Defines high-level structure using components and their interactions.
Architectural Views and Styles:
- Views: Logical, process, development, physical.
- Styles: Layered, client-server, MVC, pipe-and-filter.
User Interface Design:
- Focuses on usability, layout, interaction, and user experience.
Function-oriented Design:
- Structured Analysis and Structured Design (SA/SD) using DFDs.
Component-Based Design:
- Building systems using pre-defined components/modules.
Design Metrics:
- Evaluate design quality through measures like complexity, cohesion, and coupling.
Software Engineering Notes
Unit 4: Software Analysis and Testing
Software Analysis and Testing:
Static and Dynamic Analysis:
- Static: Code analysis without execution (e.g., code review).
- Dynamic: Analyzing behavior by running the software.
Code Inspections:
- Manual code reviews to find defects early.
Software Testing Fundamentals:
- Ensures correctness, completeness, and quality.
Testing Levels:
- Unit, Integration, System, Acceptance.
Test Criteria:
- Conditions that must be met for testing (entry/exit criteria).
Test Case Design:
- Specifies inputs, expected outputs, and execution steps.
Test Oracles:
- Mechanism for determining test results.
Test Techniques:
- Black-box: Based on specifications.
- White-box: Based on internal code logic.
Unit Testing & Frameworks:
- Testing individual modules using JUnit, NUnit, etc.
Integration and System Testing:
- Combines components and tests the whole system.
Software Engineering Notes
Specialized Testing:
- Regression, performance, security, usability.
Test Plan & Metrics:
- Documentation and measurement of testing process.
OOAD vs Structured SE:
- Object-Oriented focuses on encapsulation and reuse.
- Structured SE is function-driven.
Software Engineering Notes
Unit 5: Software Maintenance & Software Project Measurement
Software Maintenance & Project Measurement:
Maintenance:
- Need: Fix defects, improve performance, adapt to changes.
- Types: Corrective, Adaptive, Perfective, Preventive.
Software Configuration Management (SCM):
- Manages changes in software artifacts.
Software Change Management:
- Tracks and controls changes during development.
Version Control, Change Control:
- Systems like Git to manage versions and changes.
Program Comprehension:
- Techniques to understand legacy systems.
Re-engineering and Reverse Engineering:
- Re-engineering: Restructuring or rewriting old software.
- Reverse Engineering: Analyzing software to derive design/requirements.
Project Management Concepts:
- Planning, monitoring, controlling, closing.
Feasibility Analysis:
- Assess viability of a project (technical, economic, legal).
Resource Allocation:
- Assigning people, time, budget.
Estimation:
- Effort, cost, schedule estimation using models like COCOMO.
Software Engineering Notes
Project Scheduling and Tracking:
- Using Gantt charts, PERT, CPM.
Risk Assessment & Mitigation:
- Identify, analyze, and plan for risks.
Software Quality Assurance (SQA):
- Ensures quality via reviews, audits, standards.
Project Plan & Metrics:
- Detailed roadmap and measurement for monitoring progress.
