Software Engineering Notes
Unit 1
1. SDLC Life Cycle (Software Development Life Cycle)
SDLC is a process followed for a software project to ensure quality and correctness. It defines the
phases involved in software development, including planning, analysis, design, implementation,
testing, deployment, and maintenance. Each phase has its own deliverables and objectives, helping
manage time, cost, and quality.
Phases:
1. Requirement Gathering: Collecting needs from stakeholders.
2. Feasibility Study: Technical, operational, and financial analysis.
3. Design: System and software design based on requirements.
4. Implementation: Writing the actual code.
5. Testing: Verifying and validating the software.
6. Deployment: Delivering the software to users.
7. Maintenance: Fixing issues, updating features.
2. Software Development Process Models
These models define how to carry out the software development process.
- Waterfall Model: Sequential approach. Each phase must be completed before the next begins.
- Iterative Model: Develops system in small sections. Feedback helps refine each iteration.
- Incremental Model: Each increment adds functionality. Combines elements of waterfall and
iterative.
- RAD (Rapid Application Development): Emphasizes quick development using components and
prototypes.
- V-Model (Verification and Validation Model): Extension of waterfall. Testing phases are planned
parallel to development phases.
3. Umbrella Activities
These are supporting tasks that occur throughout the software process.
- Project tracking
- Risk management
- Software quality assurance
- Formal technical reviews
- Configuration management
- Documentation
- Reusability management
4. Agile Methodologies and Principles
Agile is an iterative and incremental model that emphasizes flexibility and customer satisfaction.
Key Principles:
- Individuals and interactions over tools.
- Working software over documentation.
- Customer collaboration over contracts.
- Responding to change over following a plan.
Popular Agile Methods:
- Scrum
- XP (Extreme Programming)
- Kanban
Unit 2
1. SRS (Software Requirement Specification)
SRS is a document that describes what the software will do and how it will perform.
Key Elements:
- Functional requirements
- Non-functional requirements
- Interface requirements
- Constraints
Importance:
- Acts as a reference for developers and testers
- Helps in cost and time estimation
- Reduces misunderstandings
2. Software Estimation
It is the process of predicting effort, time, and cost for a software project.
Techniques:
- Expert Judgment
- Analogy-based estimation
- Algorithmic models (e.g., COCOMO)
3. Software Scheduling
Scheduling is planning the timeline of project tasks.
Steps:
- Identify activities
- Estimate time for each
- Determine dependencies
- Create timelines (Gantt/PERT charts)
4. Risk Management
It involves identifying, analyzing, and responding to risks.
Steps:
1. Risk Identification
2. Risk Analysis (probability and impact)
3. Risk Planning (mitigation, avoidance)
4. Risk Monitoring
Unit 3
1. UML Diagrams and Notations
UML (Unified Modeling Language) is used for designing and visualizing object-oriented systems.
Types of UML Diagrams:
- Structural: Class, Object, Component, Deployment
- Behavioral: Use case, Sequence, Activity, State
Notations:
- Rectangle for class
- Oval for use case
- Arrow for association or message
2. Behavioral Modelling
Describes system behavior over time.
Examples:
- Use Case Diagram: Shows user interactions
- Sequence Diagram: Shows object interactions in time order
- State Diagram: Shows state changes
3. Structural Analysis
Focuses on static structure of the system.
Tools:
- Data Flow Diagrams (DFD)
- Entity Relationship Diagrams (ERD)
- Structure Charts
Unit 4
1. Design Concepts
Basic principles for good software design:
- Abstraction
- Refinement
- Modularity
- Information Hiding
- Functional Independence
- Refinement
- Architecture
2. Coupling and Cohesion
- Cohesion: Degree to which elements of a module belong together.
- High cohesion is preferred (e.g., a module with related functions).
- Coupling: Degree of dependency between modules.
- Low coupling is better (modules should be independent).
3. Transform and Transaction Mapping
These are design techniques used in structured design.
- Transform Mapping: Applied when input is transformed through a series of functions.
- Transaction Mapping: Applied when user commands trigger different paths.
Unit 5
1. Top-down and Bottom-up Approaches
- Top-down: Starts from the main system and breaks it into sub-systems.
- Easy to understand.
- Bottom-up: Starts from basic modules and integrates upward.
- Promotes reusability.
2. Black Box Testing and Its Types
Testing without knowledge of internal code.
Types:
- Equivalence Partitioning
- Boundary Value Analysis
- Decision Table Testing
- State Transition Testing
- Use Case Testing
3. White Box Testing and Its Types
Testing with knowledge of internal structure.
Types:
- Unit Testing
- Branch Coverage
- Statement Coverage
- Path Coverage
- Loop Testing
4. Cyclomatic Complexity
It measures the complexity of a program using control flow graph.
Formula:
V(G) = E - N + 2P
Where:
- E = Number of edges
- N = Number of nodes
- P = Number of exit points (usually 1)
Example:
If a program has 10 edges, 8 nodes, and 1 exit point, then:
V(G) = 10 - 8 + 2 = 4
Higher complexity means more test cases are needed.
