PadhaikoAll subjects

The Software Process

Software Engineering (ENCT 352)

Open in the Padhaiko app

2.1 Process framework and umbrella activities

Definition

Software Process

A software process is a structured set of activities, actions, and tasks required to build high-quality software:

A generic process framework establishes the foundation for a complete software engineering process by defining five core framework activities, complemented by umbrella activities applied throughout the entire project:

Generic Software Process Framework and Umbrella ActivitiesText
====================================================================
  UMBRELLA ACTIVITIES (Applied continuously across all activities):
  - Software project tracking and control
  - Risk management
  - Software quality assurance (SQA)
  - Technical reviews
  - Measurement and metrics
  - Software configuration management (SCM)
  - Reusability management
  - Work product preparation and production
====================================================================
  FRAMEWORK ACTIVITIES:
  [1. Communication] -> [2. Planning] -> [3. Modeling] -> [4. Construction] -> [5. Deployment]
       (Flow: linear, iterative, evolutionary, or parallel depending on process model)

Five Generic Framework Activities

  1. Communication: Collaborating with customers and stakeholders to gather requirements, understand objectives, and define software features.
  2. Planning: Creating a software project plan covering technical tasks, risks, resources, work products, and a realistic schedule.
  3. Modeling: Creating abstract models (analysis models and design models) to understand requirements and structure the architecture before coding.
  4. Construction: Combining code generation (manual or automated) and testing (unit, integration, system) to uncover errors.
  5. Deployment: Delivering the software increment or complete product to the customer, gathering feedback, and providing post-release support.

Process Flow Patterns

Framework activities are adapted using different process flows:


2.2 Traditional (Plan-driven) process models

Prescriptive (plan-driven) process models prescribe a structured sequence of framework activities, explicit milestones, formal documentation, and upfront planning to ensure predictability and control.

2.2.1 Waterfall model and its extensions

The Waterfall model (also called the classic life cycle), proposed by Winston Royce (1970), is the oldest paradigm for software engineering. It suggests a systematic, sequential flow where each phase must be completed and signed off before the next begins.

Classic Waterfall ModelText
[ Communication ] ---> [ Planning ] ---> [ Modeling ] ---> [ Construction ] ---> [ Deployment ]
   (Requirements)      (Estimation &      (Analysis &       (Coding &            (Delivery &
                        Scheduling)        Design)           Testing)             Support)

Extensions of the Waterfall Model

  1. Iterative Waterfall Model: Adds feedback paths from every phase back to preceding phases so defects found during design, coding, or testing can correct earlier artifacts immediately.
  2. V-Model (Verification and Validation Model): Maps each left-side definition/design phase directly to a corresponding right-side testing phase, emphasizing early test planning:
The V-Model (Verification vs. Validation)Text
Requirements Modeling  ----------------------------->  Acceptance Testing
    \                                                    /
     Architectural Design  ------------------------>  System Testing
         \                                            /
          Component Design  --------------------->  Integration Testing
              \                                    /
               Code Generation  --->  Unit Testing

2.2.2 Incremental process model

The Incremental process model combines elements of linear and parallel process flows to deliver working software in staged releases called increments:

Incremental Delivery ScheduleText
Increment 1: [Comm] -> [Plan] -> [Model] -> [Construct] -> [Deploy Core Product]
Increment 2:           [Comm] -> [Plan] -> [Model] -> [Construct] -> [Deploy Release 2]
Increment 3:                     [Comm] -> [Plan] -> [Model] -> [Construct] -> [Deploy Release 3]
                                                                                  Time --->

2.2.3 Evolutionary process models (Prototyping, spiral)

Evolutionary models are iterative by design and enable engineers to develop increasingly complete versions of the software as requirements evolve.

1. Prototyping Model

Starts with communication to define broad objectives, followed by quick planning and quick design focusing on visible user-interface behavior, then building a prototype for customer evaluation and feedback:

2. Spiral Model (Barry Boehm)

The Spiral model couples the iterative nature of prototyping with the systematic control of the waterfall model, adding explicit risk analysis in every loop (spiral):

Four Quadrants of Boehm's Spiral Model
QuadrantActivityKey Focus
1. Objective SettingCommunication & PlanningIdentify objectives, alternatives, and constraints for the current cycle
2. Risk Assessment & ReductionRisk Analysis & PrototypingEvaluate technical/schedule risks; build prototypes or simulations to resolve high-risk unknowns
3. Development & ValidationEngineering (Modeling & Construction)Choose appropriate model (e.g., waterfall or incremental) for this cycle; build and verify
4. Planning Next PhaseReview & CommitmentReview results with stakeholders and decide whether to proceed to the next spiral loop

where is the probability of the risk occurring () and is the estimated loss (cost or schedule delay) if it occurs.


2.3 Agile and adaptive process models

Agile software engineering combines a philosophy and a set of development guidelines emphasizing customer satisfaction, early and continuous delivery of working software, small self-organizing teams, and rapid adaptation to change.

2.3.1 Agile manifesto and the 12 principles

In 2001, seventeen software practitioners published the Manifesto for Agile Software Development, stating four core value comparisons:

Definition

The Four Values of the Agile Manifesto

We are uncovering better ways of developing software by doing it and helping others do it. Through this work we have come to value:

  1. Individuals and interactions over processes and tools
  2. Working software over comprehensive documentation
  3. Customer collaboration over contract negotiation
  4. Responding to change over following a plan

That is, while there is value in the items on the right, we value the items on the left more.

The 12 Agile Principles

  1. Highest priority: Satisfy the customer through early and continuous delivery of valuable software.
  2. Welcome changing requirements, even late in development, harnessing change for competitive advantage.
  3. Deliver working software frequently, from a couple of weeks to a couple of months, preferring shorter timescales.
  4. Business people and developers must work together daily throughout the project.
  5. Build projects around motivated individuals, give them the environment and support they need, and trust them to get the job done.
  6. Face-to-face conversation is the most efficient and effective method of conveying information within a development team.
  7. Working software is the primary measure of progress.
  8. Agile processes promote sustainable development—sponsors, developers, and users should maintain a constant pace indefinitely.
  9. Continuous attention to technical excellence and good design enhances agility.
  10. Simplicity—the art of maximizing the amount of work not done—is essential.
  11. Best architectures, requirements, and designs emerge from self-organizing teams.
  12. Regularly, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

2.3.2 Agile versus plan-driven development

AspectAgile DevelopmentPlan-Driven (Traditional) Development
RequirementsEmergent, evolving continuously via prioritized backlogsSpecified completely upfront in a frozen SRS document
Planning HorizonAdaptive, short-cycle iterations (1–4 week sprints)Predictive, upfront master schedule and work breakdown structure
DocumentationLightweight, "just enough" documentation; working code is primaryHeavy, formal documentation and sign-off gates at every phase
Customer RoleContinuous, active daily/sprint-level collaboration (Product Owner)Involved mainly at initial specification and final acceptance
Team StructureSmall, co-located, cross-functional, self-organizing teamsLarger, specialized functional teams with hierarchical management
Change HandlingWelcomes change at low cost via short feedback loopsFormal Change Control Board (CCB) process; expensive late changes
Best Suited ForWeb/mobile apps, evolving products, uncertain requirementsSafety-critical systems (avionics, medical), fixed-bid regulated contracts

2.3.3 Scrum framework (Roles, artifacts, ceremonies)

Scrum is the most widely used agile framework, organizing work into fixed-length iterations called Sprints (typically to weeks), each ending with a potentially shippable Product Increment.

Scrum Roles, Artifacts, and Ceremonies (Events)
CategoryElementResponsibility / Purpose
RolesProduct Owner (PO)Represents stakeholders; defines and prioritizes the Product Backlog to maximize product value
RolesScrum MasterServant-leader who coaches the team on Scrum, facilitates events, and removes organizational impediments
RolesDevelopment TeamCross-functional, self-organizing group ( engineers) that builds, tests, and delivers the increment
ArtifactsProduct BacklogOrdered, evolving list of all desired features, fixes, and technical items (usually written as user stories)
ArtifactsSprint BacklogSubset of Product Backlog items selected for the current Sprint, plus a concrete task plan to deliver them
ArtifactsIncrementSum of all Product Backlog items completed during the Sprint and all previous Sprints, meeting the Definition of Done
CeremoniesSprint PlanningTeam and PO select Sprint Backlog items and define the Sprint Goal at the start of the Sprint
CeremoniesDaily Scrum (Stand-up)Time-boxed -minute daily synchronization: progress since yesterday, plan for today, and blockers
CeremoniesSprint ReviewEnd-of-sprint demonstration of the working Increment to stakeholders to gather feedback and adapt the backlog
CeremoniesSprint RetrospectiveInternal team reflection on process, people, and tools to identify concrete improvements for the next Sprint

2.3.4 Extreme programming (XP) practices

Extreme Programming (XP), formulated by Kent Beck, takes disciplined software engineering practices to "extreme" levels so teams can respond rapidly to changing requirements without sacrificing code quality.

XP rests on five values (Communication, Simplicity, Feedback, Courage, Respect) and twelve core engineering practices:

  1. Planning Game: Business stakeholders determine scope and priority; developers estimate effort and technical risk.
  2. Small Releases: Deploy minimal useful increments frequently to obtain real user feedback early.
  3. Metaphor: Establish a shared system story/naming vocabulary so everyone understands how the system works.
  4. Simple Design: Keep design as simple as passes all current tests—avoid speculative over-engineering (YAGNI: You Aren't Gonna Need It).
  5. Test-Driven Development (TDD) / Testing: Write automated unit tests before production code; customers write acceptance tests.
  6. Refactoring: Continuously restructure internal code to remove duplication and improve clarity without changing external behavior.
  7. Pair Programming: Two programmers share one workstation—the driver writes code while the navigator reviews design, edge cases, and tests in real time.
  8. Collective Ownership: Any developer may improve any part of the codebase at any time.
  9. Continuous Integration (CI): Integrate and run the full automated test suite multiple times per day.
  10. 40-Hour Week (Sustainable Pace): Avoid chronic overtime, which degrades judgment and increases defect rates.
  11. On-Site Customer: A real domain user/customer works alongside the team to answer requirement questions immediately.
  12. Coding Standards: Agree on consistent formatting and naming conventions across the whole codebase.

2.3.5 Lean software development

Adapted from Toyota's Lean Manufacturing system by Mary and Tom Poppendieck, Lean Software Development focuses on maximizing customer value while systematically eliminating waste (muda).

Seven Principles of Lean Software Development

  1. Eliminate Waste: Remove anything that adds no customer value—seven classic software wastes are partially done work, extra features, relearning, handoffs, delays, task switching, and defects.
  2. Amplify Learning: Use short iterations, rapid feedback, and set-based exploration to discover what users truly need.
  3. Decide as Late as Possible: Defer irreversible architectural or feature commitments until the last responsible moment, when facts are clearest.
  4. Deliver as Fast as Possible: Short cycle times get value to users sooner and reduce the window during which requirements go stale.
  5. Empower the Team: Respect technical experts and let the people doing the work make local technical decisions.
  6. Build Integrity In: Maintain conceptual integrity (clean UX/architecture) and perceived integrity (automated testing and refactoring).
  7. Optimize the Whole: Evaluate end-to-end value stream flow from concept to production rather than sub-optimizing one team (e.g., coding faster while QA queues pile up).

2.4 Model selection considerations

No single process model fits every project. Selecting the right model requires analyzing project, product, team, and risk factors:

Process Model Selection Matrix
Project CharacteristicRecommended Process ModelRationale
Requirements are well-understood, stable, and heavily regulatedWaterfall / V-ModelClear upfront contracts, traceability matrices, and formal verification gates
Requirements are known, but core value is needed quicklyIncremental ModelDelivers working core functionality early while deferring secondary features
Requirements are unclear or UI/UX expectations are uncertainPrototypingRapid mockups elicit concrete stakeholder feedback before heavy coding
Large, expensive project with major technical or market risksSpiral ModelExplicit risk assessment and prototyping in every loop control exposure
Dynamic requirements, small/medium co-located team, frequent releasesScrum / AgileShort sprints, continuous customer collaboration, and adaptive backlog
High volatility with strict need for code quality and rapid feedbackExtreme Programming (XP)Pair programming, TDD, CI, and continuous refactoring

Worked Examples

Example 2.1

2.1

During Quadrant 2 of a Spiral Model cycle, a software project identifies two major technical risks:

Calculate the Risk Exposure () for each risk, compute the combined expected risk exposure, and explain how the Spiral Model mitigates the higher-priority risk before Quadrant 3 construction begins.

Compute Risk Exposure for Risk A and Risk B: Using :

Compute Combined Risk Exposure and Prioritize:

Risk A () accounts for nearly three-quarters of total risk exposure and is therefore prioritized first.

Mitigation Strategy in Boehm's Spiral Model: Before committing full construction effort in Quadrant 3, the team builds a throwaway migration prototype on a test snapshot of production data during Quadrant 2 to validate schema conversion scripts and rollback procedures—driving (and thus ) down before full-scale development.

Answer:

, , and combined risk exposure is . Risk A has higher exposure and is mitigated in Quadrant 2 via a migration prototype prior to Quadrant 3 development.

Example 2.2

2.2

A Scrum team adopts -week sprints. Over its last four completed sprints, the team delivered , , , and story points respectively. The remaining Product Backlog is estimated at story points. Calculate:

  1. The team's average velocity (story points per sprint).
  2. The expected number of remaining sprints and calendar weeks required to complete the backlog.
  3. Explain what happens to the Sprint Backlog if the Product Owner asks to add a -point urgent feature mid-sprint.

Part 1 — Average Sprint Velocity:

Part 2 — Remaining Sprints and Calendar Weeks:

Part 3 — Handling Mid-Sprint Scope Changes in Scrum: In Scrum, the Sprint Backlog is protected from scope additions once the Sprint begins so the team can focus on the Sprint Goal. The Product Owner places the new -point feature at the top of the Product Backlog for the next Sprint Planning session (unless the feature is so critical that the PO cancels the current Sprint).

Answer:
  1. Average velocity is story points/sprint.
  2. Remaining work requires sprints ( weeks).
  3. The -point feature is added to the Product Backlog for the next Sprint rather than interrupting the active Sprint Backlog.
Example 2.3

2.3

How to Answer a Past Exam Question: "Compare the Waterfall model and Scrum framework, and recommend a suitable process model for (a) an aircraft flight-control system and (b) a campus e-learning mobile app."

Part 1 — Structured Comparison: Present a crisp table comparing Waterfall and Scrum across five dimensions: Requirements stability, Delivery cadence, Customer involvement, Change handling, and Documentation weight.

Part 2 — Justified Recommendations Using R-T-S-C Criteria:

  • (a) Aircraft Flight-Control System V-Model / Waterfall (with formal verification): Safety-critical avionics have strict regulatory certification (DO-178C), stable hardware-coupled requirements, and demand full traceability between requirements, design, and formal verification tests.
  • (b) Campus E-Learning Mobile App Scrum (Agile): User interface preferences, course workflows, and notification features evolve through student/faculty feedback; -week increments allow rapid testing and course correction.
Answer:

A high-scoring answer contrasts Waterfall and Scrum across requirements, cadence, customer role, change cost, and documentation, then recommends V-Model/Waterfall for the safety-critical flight controller and Scrum for the feedback-driven e-learning app.


Exercises

Practice Exercises — The Software Process

Question 1

Explain the five generic process framework activities and list six umbrella activities that apply across the software process.

Five Generic Process Framework Activities:

  1. Communication: Elicit requirements and project goals from stakeholders.
  2. Planning: Define technical tasks, risks, resources, and schedule.
  3. Modeling: Construct analysis and design models to guide construction.
  4. Construction: Write code and execute testing (unit, integration, system).
  5. Deployment: Deliver the software to end users, collect feedback, and provide support.

Six Umbrella Activities:

  1. Software project tracking and control.
  2. Risk management.
  3. Software quality assurance (SQA).
  4. Technical reviews.
  5. Measurement and metrics.
  6. Software configuration management (SCM) (along with reusability management and work product preparation).
Answer:

The five framework activities are Communication, Planning, Modeling, Construction, and Deployment. Six key umbrella activities are project tracking and control, risk management, SQA, technical reviews, measurement, and SCM.

Question 2

Describe the Waterfall model and explain how the V-Model and Incremental model address its key limitations.

Waterfall Model and Limitations: The Waterfall model executes communication, planning, modeling, construction, and deployment strictly sequentially. Its major limitations are: working software appears only at the end, changing requirements cause expensive rework, and early defects remain hidden until late testing.

How V-Model and Incremental Model Address Them:

  • V-Model: Pairs every specification/design phase on the left leg directly with a corresponding testing phase on the right leg (Requirements Acceptance, Architecture System, Design Integration, Code Unit), ensuring test design happens early.
  • Incremental Model: Delivers a working core product in Increment 1 and adds features in subsequent increments, giving stakeholders early working software and feedback opportunities.
Answer:

The sequential Waterfall model delays working software and struggles with changing requirements. The V-Model links each design stage to early test planning (verification and validation), while the Incremental model delivers usable software early in staged increments.

Question 3

Explain the four quadrants of Boehm's Spiral model. Why is it especially suitable for large, high-risk software projects?

Four Quadrants of Each Spiral Loop:

  1. Objective Setting: Define objectives, alternative implementations, and constraints for the iteration.
  2. Risk Assessment & Reduction: Identify technical/management risks and resolve them using prototypes, benchmarks, or simulations.
  3. Development & Validation: Build and test the next level of product using the best-suited engineering model for that cycle.
  4. Planning the Next Phase: Review deliverables with stakeholders and plan the next spiral iteration.

Suitability for High-Risk Projects: Unlike Waterfall or pure prototyping, every spiral loop forces explicit risk quantification and prototyping before heavy implementation investment, limiting financial and technical exposure while allowing controlled evolution.

Answer:

The Spiral model cycles through (1) Objective Setting, (2) Risk Assessment & Reduction, (3) Development & Validation, and (4) Planning Next Phase. Explicit risk analysis and prototyping in every loop make it ideal for large, high-risk systems.

Question 4

List the four values of the Agile Manifesto, describe the three roles, three artifacts, and four ceremonies of Scrum, and name five core Extreme Programming (XP) practices.

Four Agile Manifesto Values:

  1. Individuals and interactions over processes and tools.
  2. Working software over comprehensive documentation.
  3. Customer collaboration over contract negotiation.
  4. Responding to change over following a plan.

Scrum Roles, Artifacts, and Ceremonies:

  • Roles: Product Owner, Scrum Master, Development Team.
  • Artifacts: Product Backlog, Sprint Backlog, Increment.
  • Ceremonies: Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective.

Five Core XP Practices: Test-Driven Development (TDD), Pair Programming, Continuous Integration (CI), Refactoring, and Small Releases (alongside Simple Design, Planning Game, Collective Ownership, Coding Standards, On-Site Customer, Metaphor, and 40-Hour Week).

Answer:

Agile values individuals/interactions, working software, customer collaboration, and responding to change. Scrum defines three roles (Product Owner, Scrum Master, Dev Team), three artifacts (Product Backlog, Sprint Backlog, Increment), and four ceremonies (Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective). XP reinforces agility with engineering practices such as TDD, Pair Programming, CI, Refactoring, and Small Releases.

Question 5

A startup is building a fintech mobile app using Scrum with -week sprints. The initial Product Backlog contains story points of core features and story points of secondary features. Over its first three sprints, the team completes , , and story points.

  1. Calculate the team's average sprint velocity.
  2. How many total sprints and weeks are needed to complete the entire -point backlog (rounding up to whole sprints)?
  3. Identify two types of Lean waste the team avoids by releasing the -point core first instead of waiting for all points.

Part 1 — Average Velocity:

Part 2 — Total Sprints and Duration:

Since each sprint is weeks long:

Part 3 — Lean Wastes Avoided by Early Core Release:

  1. Extra Features: User feedback on the -point core reveals which secondary features users actually need, preventing effort wasted on unused features.
  2. Partially Done Work / Delays: Delivering usable software early removes idle inventory waiting for release and accelerates customer learning.
Answer:
  1. Average velocity .
  2. Completing all points takes sprints ( weeks) (with sprints / weeks for the -point core).
  3. Early core release eliminates Lean wastes such as extra features and partially done work / delivery delays.
← IntroductionSoftware Requirements Engineering →