CS8494

Software Engineering

7 Files
•
Updated Jan 2026
Download Progress0/7 files
Unit 1
NotesNot downloaded1.4 MB
Unit 2
NotesNot downloaded558 KB
Unit 3
NotesNot downloaded1 MB
Unit 4
NotesNot downloaded790 KB
Unit 5
NotesNot downloaded566 KB
Important Questions
StudyNot downloaded147 KB
Question Paper
ExamNot downloaded12.4 MB
Academic Study Guide

Software Engineering & Agile Methodologies Academic Curriculum Guide

Software Engineering applies systematic, disciplined, and quantifiable engineering methodologies to the design, development, testing, and lifecycle maintenance of high-reliability software. This comprehensive study guide covers Software Development Life Cycle (SDLC) models, Requirements Engineering, Architectural Design Patterns, Verification & Validation (V&V), and Software Quality Assurance aligned with AICTE, Anna University, and VTU standards.

Unit-by-Unit Theoretical Revision

Unit 1: Software Process Models & SDLC

A software process model is an abstract framework specifying the sequence of activities, actions, and milestones involved in building software systems.

  • Waterfall Model: Linear sequential model (Requirements → Design → Implementation → Verification → Maintenance). Simple and disciplined, but inflexible; defects identified late incur prohibitive rework costs.
  • Incremental & Evolutionary Models: Builds working increments progressively. Prototyping model builds throw-away or evolutionary prototypes to elicit ambiguous customer requirements.
  • Spiral Model (Boehm): Risk-driven iterative model organized in four quadrants: Objective Setting, Risk Assessment & Reduction, Development & Validation, and Review/Planning. Ideal for large, high-risk mission-critical systems.
  • Agile Methodologies & Scrum: Iterative development prioritizing individuals, working software, customer collaboration, and responsiveness to change. Scrum framework utilizes Sprints (1-4 weeks), daily standup meetings, Product Backlog, Sprint Backlog, Burndown charts, and defined roles (Product Owner, Scrum Master, Developers).

Unit 2: Requirements Engineering & Modeling

  • Requirements Process: Inception → Elicitation (interviews, surveys, JAD) → Elaboration → Negotiation → Specification → Validation.
  • Functional vs Non-Functional Requirements (NFR): Functional requirements describe system services and outputs for specific inputs. Non-functional requirements specify behavioral constraints, performance metrics, scalability, security, and reliability (FURPS model).
  • Software Requirements Specification (SRS): Formal document governed by IEEE 830 standard. Key attributes: Correct, Unambiguous, Complete, Consistent, Ranked for importance/stability, Verifiable, Modifiable, and Traceable.
  • UML Behavioral Modeling: Use Case Diagrams (actors, system boundaries, <<include>>, <<extend>>), Activity Diagrams, and State Machine Diagrams.

Unit 3: Architectural Design & Design Patterns

  • Design Concepts: Abstraction, Modularity, Information Hiding, Cohesion, and Coupling.
    • Cohesion: Degree to which elements within a single module belong together. Target: High functional cohesion. (Order from weak to strong: Coincidental < Logical < Temporal < Procedural < Communicational < Sequential < Functional).
    • Coupling: Degree of direct interdependence between software modules. Target: Low/loose coupling. (Order from strong to loose: Content > Common > Control > Stamp > Data coupling).
  • Architectural Patterns: Layered Architecture (n-tier), Client-Server, Microservices (loosely coupled distributed services), Model-View-Controller (MVC separating business logic, UI, and controller routing), and Event-Driven architecture.

Unit 4: Software Testing Strategies & V&V

Verification asks: "Are we building the product right?" (reviews, inspections, static analysis). Validation asks: "Are we building the right product?" (executing software against requirements).

  • Black-Box Testing (Functional): Tests software without internal code structure knowledge.
    • Equivalence Partitioning: Divides input domain into valid and invalid equivalence classes, selecting representative test cases.
    • Boundary Value Analysis (BVA): Tests boundaries between equivalence classes (min, min+, nominal, max-, max). Catches boundary condition bugs.
  • White-Box Testing (Structural): Tests internal logic, code paths, and conditions.
    • Basis Path Testing (McCabe’s Cyclomatic Complexity): Computes independent execution paths through control flow graph: V(G) = E - N + 2P = P_regions + 1.
    • Code Coverage: Statement coverage, Branch/Decision coverage, and Condition coverage.
  • Testing Levels: Unit Testing → Integration Testing (Top-down with stubs, Bottom-up with drivers) → System Testing (Stress, Load, Performance) → Acceptance Testing (Alpha/Beta testing).

Unit 5: Software Estimation, Quality Assurance & Maintenance

  • Cost Estimation Models: Function Point Analysis (FPA) and COCOMO II (Constructive Cost Model) estimating effort E = a · (KLOC)^b · EAF person-months across Organic, Semidetached, and Embedded modes.
  • Software Quality Models: ISO 9126 / ISO 25010 quality characteristics: Functionality, Reliability, Usability, Efficiency, Maintainability, Portability. Capability Maturity Model Integration (CMMI) levels 1 to 5 (Initial, Managed, Defined, Quantitatively Managed, Optimizing).
  • Software Maintenance Types: Corrective (fixing bugs), Adaptive (adapting to environment changes), Perfective (enhancing performance or adding features), and Preventive (refactoring to prevent future failures).

SDLC Process Models Comparison

Model Requirement Flexibility Risk Handling User Involvement Best Suited For
WaterfallVery RigidPoorInitial and final onlyStable, well-understood requirements
PrototypingHighModerateContinuousUnclear user requirements, UI design
SpiralModerate to HighExceptional (Core focus)At every milestone iterationLarge-scale, expensive, high-risk systems
Agile (Scrum)Extremely DynamicHigh (Sprint retrospectives)Continuous (Daily / Sprint review)Rapidly evolving commercial products

High-Frequency University Exam Questions

Q1: Differentiate between Functional Cohesion and Content Coupling. Why is high cohesion and low coupling desired?

Functional Cohesion is the strongest and most desirable form of cohesion, occurring when all elements within a module perform a single, well-defined task (e.g., computing a sine function). Content Coupling is the worst and tightest form of coupling, occurring when one module directly modifies or accesses the internal data or code of another module. High cohesion ensures that modules are focused, understandable, and easily maintainable. Low coupling ensures that changes in one module do not ripple unpredictably through the rest of the application.

Q2: Explain McCabe’s Cyclomatic Complexity and how it is computed from a Control Flow Graph (CFG).

Cyclomatic complexity is a quantitative software metric providing an upper bound on the number of linearly independent paths through the source code. It represents the minimum number of test cases required to achieve complete branch coverage. For a control flow graph with E edges, N nodes, and P connected components, cyclomatic complexity is calculated using three equivalent formulas: (1) V(G) = E - N + 2P, (2) V(G) = P_predicate_nodes + 1, or (3) V(G) = Number of enclosed bounded regions + 1.

Q3: Explain the difference between Black-Box and White-Box testing techniques with examples.

Black-Box Testing evaluates the functional behavior of software purely against its specifications without examining internal source code logic; methods include Boundary Value Analysis and Equivalence Partitioning. White-Box Testing analyzes the internal structural paths, branches, and code conditions; methods include Basis Path Testing, Statement Coverage, and Condition Coverage. Black-box testing finds missing features and usability errors; white-box testing finds logic errors, dead code, and hidden computational faults.