The Software Process
Open in the Padhaiko app2.1 Process framework and umbrella activities
Software Process
A software process is a structured set of activities, actions, and tasks required to build high-quality software:
- Activity: Strives to achieve a broad objective (e.g., communication with stakeholders).
- Action: Encompasses a set of tasks that produce a major work product (e.g., architectural design model).
- Task: Focuses on a small, well-defined objective producing a tangible outcome (e.g., conducting a unit test).
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:
====================================================================
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
- Communication: Collaborating with customers and stakeholders to gather requirements, understand objectives, and define software features.
- Planning: Creating a software project plan covering technical tasks, risks, resources, work products, and a realistic schedule.
- Modeling: Creating abstract models (analysis models and design models) to understand requirements and structure the architecture before coding.
- Construction: Combining code generation (manual or automated) and testing (unit, integration, system) to uncover errors.
- 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:
- Linear Process Flow: Executes the five activities sequentially from communication to deployment.
- Iterative Process Flow: Repeats one or more activities before proceeding to the next.
- Evolutionary Process Flow: Executes the activities in a circular manner, producing a more complete version of the software in each pass.
- Parallel Process Flow: Executes one or more activities concurrently with other activities (e.g., modeling one subsystem while constructing another).
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.
[ Communication ] ---> [ Planning ] ---> [ Modeling ] ---> [ Construction ] ---> [ Deployment ]
(Requirements) (Estimation & (Analysis & (Coding & (Delivery &
Scheduling) Design) Testing) Support)- Strengths: Simple to understand and manage; clear milestones and deliverables; well-suited when requirements are well-understood, stable, and unlikely to change (e.g., safety-critical embedded or government contract systems).
- Limitations:
- Real projects rarely follow a purely sequential flow; iterations create confusion in a strict waterfall.
- Customers often cannot state all requirements explicitly upfront.
- A working version of the program is unavailable until late in the project—a major design flaw may go undetected until testing or deployment.
- Leads to blocking states where some team members wait idly while upstream phases finish.
Extensions of the Waterfall Model
- 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.
- 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:
Requirements Modeling -----------------------------> Acceptance Testing
\ /
Architectural Design ------------------------> System Testing
\ /
Component Design ---------------------> Integration Testing
\ /
Code Generation ---> Unit Testing2.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:
- Increment 1 delivers a usable core product addressing basic requirements.
- Subsequent increments add supplementary features, refine interfaces, and incorporate user feedback until the full product is delivered.
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 --->- When to Use: Tight deadlines where early partial functionality brings immediate business value, or when staffing is initially limited and grows over 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:
- Throwaway (Rapid) Prototyping: Built solely to clarify misunderstood requirements and then discarded before building the production system cleanly.
- Evolutionary Prototyping: Refined repeatedly into the final production system.
- Pitfall: Customers may mistake a fragile prototype for a finished product and pressure developers to ship poor-quality code without proper re-engineering.
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):
| Quadrant | Activity | Key Focus |
|---|---|---|
| 1. Objective Setting | Communication & Planning | Identify objectives, alternatives, and constraints for the current cycle |
| 2. Risk Assessment & Reduction | Risk Analysis & Prototyping | Evaluate technical/schedule risks; build prototypes or simulations to resolve high-risk unknowns |
| 3. Development & Validation | Engineering (Modeling & Construction) | Choose appropriate model (e.g., waterfall or incremental) for this cycle; build and verify |
| 4. Planning Next Phase | Review & Commitment | Review results with stakeholders and decide whether to proceed to the next spiral loop |
- Risk Exposure Formula: During Quadrant 2, quantitative risk analysis evaluates Risk Exposure () for each identified risk :
where is the probability of the risk occurring () and is the estimated loss (cost or schedule delay) if it occurs.
- Strengths: Ideal for large-scale, high-risk, mission-critical systems; adapts to changing requirements while controlling risk at every pass.
- Weaknesses: Requires specialized risk-assessment expertise; complex contractual management; rarely economical for small, low-risk projects.
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:
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:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- 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
- Highest priority: Satisfy the customer through early and continuous delivery of valuable software.
- Welcome changing requirements, even late in development, harnessing change for competitive advantage.
- Deliver working software frequently, from a couple of weeks to a couple of months, preferring shorter timescales.
- Business people and developers must work together daily throughout the project.
- Build projects around motivated individuals, give them the environment and support they need, and trust them to get the job done.
- Face-to-face conversation is the most efficient and effective method of conveying information within a development team.
- Working software is the primary measure of progress.
- Agile processes promote sustainable development—sponsors, developers, and users should maintain a constant pace indefinitely.
- Continuous attention to technical excellence and good design enhances agility.
- Simplicity—the art of maximizing the amount of work not done—is essential.
- Best architectures, requirements, and designs emerge from self-organizing teams.
- 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
| Aspect | Agile Development | Plan-Driven (Traditional) Development |
|---|---|---|
| Requirements | Emergent, evolving continuously via prioritized backlogs | Specified completely upfront in a frozen SRS document |
| Planning Horizon | Adaptive, short-cycle iterations (1–4 week sprints) | Predictive, upfront master schedule and work breakdown structure |
| Documentation | Lightweight, "just enough" documentation; working code is primary | Heavy, formal documentation and sign-off gates at every phase |
| Customer Role | Continuous, active daily/sprint-level collaboration (Product Owner) | Involved mainly at initial specification and final acceptance |
| Team Structure | Small, co-located, cross-functional, self-organizing teams | Larger, specialized functional teams with hierarchical management |
| Change Handling | Welcomes change at low cost via short feedback loops | Formal Change Control Board (CCB) process; expensive late changes |
| Best Suited For | Web/mobile apps, evolving products, uncertain requirements | Safety-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.
| Category | Element | Responsibility / Purpose |
|---|---|---|
| Roles | Product Owner (PO) | Represents stakeholders; defines and prioritizes the Product Backlog to maximize product value |
| Roles | Scrum Master | Servant-leader who coaches the team on Scrum, facilitates events, and removes organizational impediments |
| Roles | Development Team | Cross-functional, self-organizing group ( engineers) that builds, tests, and delivers the increment |
| Artifacts | Product Backlog | Ordered, evolving list of all desired features, fixes, and technical items (usually written as user stories) |
| Artifacts | Sprint Backlog | Subset of Product Backlog items selected for the current Sprint, plus a concrete task plan to deliver them |
| Artifacts | Increment | Sum of all Product Backlog items completed during the Sprint and all previous Sprints, meeting the Definition of Done |
| Ceremonies | Sprint Planning | Team and PO select Sprint Backlog items and define the Sprint Goal at the start of the Sprint |
| Ceremonies | Daily Scrum (Stand-up) | Time-boxed -minute daily synchronization: progress since yesterday, plan for today, and blockers |
| Ceremonies | Sprint Review | End-of-sprint demonstration of the working Increment to stakeholders to gather feedback and adapt the backlog |
| Ceremonies | Sprint Retrospective | Internal 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:
- Planning Game: Business stakeholders determine scope and priority; developers estimate effort and technical risk.
- Small Releases: Deploy minimal useful increments frequently to obtain real user feedback early.
- Metaphor: Establish a shared system story/naming vocabulary so everyone understands how the system works.
- Simple Design: Keep design as simple as passes all current tests—avoid speculative over-engineering (YAGNI: You Aren't Gonna Need It).
- Test-Driven Development (TDD) / Testing: Write automated unit tests before production code; customers write acceptance tests.
- Refactoring: Continuously restructure internal code to remove duplication and improve clarity without changing external behavior.
- Pair Programming: Two programmers share one workstation—the driver writes code while the navigator reviews design, edge cases, and tests in real time.
- Collective Ownership: Any developer may improve any part of the codebase at any time.
- Continuous Integration (CI): Integrate and run the full automated test suite multiple times per day.
- 40-Hour Week (Sustainable Pace): Avoid chronic overtime, which degrades judgment and increases defect rates.
- On-Site Customer: A real domain user/customer works alongside the team to answer requirement questions immediately.
- 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
- 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.
- Amplify Learning: Use short iterations, rapid feedback, and set-based exploration to discover what users truly need.
- Decide as Late as Possible: Defer irreversible architectural or feature commitments until the last responsible moment, when facts are clearest.
- Deliver as Fast as Possible: Short cycle times get value to users sooner and reduce the window during which requirements go stale.
- Empower the Team: Respect technical experts and let the people doing the work make local technical decisions.
- Build Integrity In: Maintain conceptual integrity (clean UX/architecture) and perceived integrity (automated testing and refactoring).
- 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:
| Project Characteristic | Recommended Process Model | Rationale |
|---|---|---|
| Requirements are well-understood, stable, and heavily regulated | Waterfall / V-Model | Clear upfront contracts, traceability matrices, and formal verification gates |
| Requirements are known, but core value is needed quickly | Incremental Model | Delivers working core functionality early while deferring secondary features |
| Requirements are unclear or UI/UX expectations are uncertain | Prototyping | Rapid mockups elicit concrete stakeholder feedback before heavy coding |
| Large, expensive project with major technical or market risks | Spiral Model | Explicit risk assessment and prototyping in every loop control exposure |
| Dynamic requirements, small/medium co-located team, frequent releases | Scrum / Agile | Short sprints, continuous customer collaboration, and adaptive backlog |
| High volatility with strict need for code quality and rapid feedback | Extreme Programming (XP) | Pair programming, TDD, CI, and continuous refactoring |
Worked Examples
2.1
During Quadrant 2 of a Spiral Model cycle, a software project identifies two major technical risks:
- Risk A (Database Migration Failure): Probability , estimated loss .
- Risk B (Third-Party API Latency): Probability , estimated loss .
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.
, , 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.
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:
- The team's average velocity (story points per sprint).
- The expected number of remaining sprints and calendar weeks required to complete the backlog.
- 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).
- Average velocity is story points/sprint.
- Remaining work requires sprints ( weeks).
- The -point feature is added to the Product Backlog for the next Sprint rather than interrupting the active Sprint Backlog.
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.
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
Explain the five generic process framework activities and list six umbrella activities that apply across the software process.
Five Generic Process Framework Activities:
- Communication: Elicit requirements and project goals from stakeholders.
- Planning: Define technical tasks, risks, resources, and schedule.
- Modeling: Construct analysis and design models to guide construction.
- Construction: Write code and execute testing (unit, integration, system).
- Deployment: Deliver the software to end users, collect feedback, and provide support.
Six Umbrella Activities:
- Software project tracking and control.
- Risk management.
- Software quality assurance (SQA).
- Technical reviews.
- Measurement and metrics.
- Software configuration management (SCM) (along with reusability management and work product preparation).
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.
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.
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.
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:
- Objective Setting: Define objectives, alternative implementations, and constraints for the iteration.
- Risk Assessment & Reduction: Identify technical/management risks and resolve them using prototypes, benchmarks, or simulations.
- Development & Validation: Build and test the next level of product using the best-suited engineering model for that cycle.
- 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.
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.
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:
- Individuals and interactions over processes and tools.
- Working software over comprehensive documentation.
- Customer collaboration over contract negotiation.
- 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).
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.
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.
- Calculate the team's average sprint velocity.
- How many total sprints and weeks are needed to complete the entire -point backlog (rounding up to whole sprints)?
- 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:
- Extra Features: User feedback on the -point core reveals which secondary features users actually need, preventing effort wasted on unused features.
- Partially Done Work / Delays: Delivering usable software early removes idle inventory waiting for release and accelerates customer learning.
- Average velocity .
- Completing all points takes sprints ( weeks) (with sprints / weeks for the -point core).
- Early core release eliminates Lean wastes such as extra features and partially done work / delivery delays.