How to use these notes: section numbers (§1.1, §1.2 ...) match the question bank. "Slide L03-S07" means slide 7 of this lecture. Difficult words are explained in "Word help" boxes and in the word bank at the end.
Learning outcomes
By the end of this lecture you should be able to:
SLO | Learning outcome | CLO | Bloom | Slides |
|---|---|---|---|---|
SLO 3.1 | Explain why agile methods appeared in the 1990s. | CLO1 | C2 Understand | L03-S05 |
SLO 3.2 | State the four values of the Agile Manifesto and explain each with an example. | CLO1 | C2 Understand | L03-S06, S07 |
SLO 3.3 | Explain the twelve agile principles in simple words. | CLO1 | C2 Understand | L03-S08, S09 |
SLO 3.4 | Explain what agility is and how it changes the cost of change. | CLO1 | C2 Understand | L03-S10, S11 |
SLO 3.5 | Describe what an agile process is and the human factors that make it work. | CLO1 | C2 Understand | L03-S12, S13 |
SLO 3.6 | Decide whether agile, plan-driven or a mix fits a given project, and give reasons. | CLO1 | C3 Apply | L03-S14 to S17 |
In Lecture 2 we placed process models on a line from plan-driven to agile. Today we stand at the agile end of that line. We will learn what agile really means, where the idea came from, and when it is the right choice. The next three lectures look at agile methods in detail: XP (Lecture 4), Scrum (Lecture 5) and other agile models such as Kanban (Lecture 6).
§1 From plan-driven to agile
Slides L03-S02, L03-S05
§1.1 Recap: the range of process models
Slide L03-S02
Model | Main idea | Change is... |
|---|---|---|
Waterfall (and V-model) | Plan everything, then follow the plan step by step | Expensive |
Incremental | Build and deliver in small pieces | Cheap |
Integration and configuration | Reuse existing software | Limited by what exists |
Spiral | Deal with the biggest risk first | Planned for in each loop |
On the line from plan-driven to agile: Waterfall, V-model, Spiral, Incremental, Scrum/XP. Agile methods are built on incremental development, but they add a set of values about people, customers and change.
§1.2 Why agile was born
Slide L03-S05
In the 1980s and 1990s many companies used heavyweight processes: long requirement documents, detailed designs, and formal approval at every step. These worked for large, stable, long-life systems such as aircraft and defence software.
But business software changed quickly. Teams found that:
- Requirements changed before the requirements document was even signed.
- Months were spent writing documents that were out of date by the time coding started.
- Customers saw working software only at the end, and then said "this is not what we wanted".
Developers began trying lighter methods: XP, Scrum, DSDM, Crystal and others. In February 2001, seventeen software developers met at a ski resort in Snowbird, Utah (USA). They agreed on what these methods had in common and wrote it down as the Manifesto for Agile Software Development.
Real-world example: a school management system A software house in Lahore spends four months writing a 200-page requirements document for a school's management system. By the time the school signs it, the school has changed its fee policy and wants a mobile app for parents as well. Half the document is now wrong. This is the problem agile methods try to solve: plan less up front, deliver often, and learn from real use. |
Word help heavyweight = having many rules, steps and documents manifesto = a public written statement of what a group believes |
§2 The Agile Manifesto
Slides L03-S06 to L03-S07
§2.1 The four values
Slide L03-S06
The manifesto is one short page. Its heart is four values. Each value compares two things that are both useful, and says which one agile teams care about more:
We value this more ... | ... over this |
|---|---|
Individuals and interactions | processes and tools |
Working software | comprehensive documentation |
Customer collaboration | contract negotiation |
Responding to change | following a plan |
The last line of the manifesto is the most misunderstood: "while there is value in the items on the right, we value the items on the left more." Agile does not say "no documents, no plans, no tools, no contracts". It says: when you must choose, choose the left side.
Exam tip Write the four values exactly in this order, with the word "over" in the middle. Many students lose marks by writing "instead of" or by dropping the right-hand side. |
Word help value = something you believe is important comprehensive = complete; covering everything |
§2.2 The four values in practice
Slide L03-S07
Value | What it means in simple words | Example |
|---|---|---|
Individuals and interactions over processes and tools | Good people who talk to each other solve problems faster than any tool or rulebook. | Two developers sit together for 10 minutes to fix a confusing API instead of filing a ticket and waiting three days. |
Working software over comprehensive documentation | Progress is shown by software that runs, not by pages written. | Show the school principal a working fee-voucher screen in week 2, instead of a 40-page design document. |
Customer collaboration over contract negotiation | Treat the customer as a partner who helps shape the product, not an opponent across a table. | The client's accountant joins a short meeting every two weeks to check the payroll screens. |
Responding to change over following a plan | When the world changes, change the plan. The plan serves the product, not the other way round. | The State Bank issues a new rule for digital payments; the wallet team moves this work to the top of the next two weeks. |
Notice a pattern: each value moves the focus from paperwork and control to people, feedback and results.
§3 The twelve agile principles
Slides L03-S08 to L03-S09
§3.1 The principles in four groups
Slide L03-S08
Behind the four values, the manifesto lists twelve principles. They are easier to remember in four groups:
Group | Principles (in simple words) |
|---|---|
A. Customer and change | 1. Our top priority is to satisfy the customer by delivering valuable software early and continuously. 2. Welcome changing requirements, even late in development; change can give the customer an advantage. 4. Business people and developers work together daily. |
B. Delivery | 3. Deliver working software frequently, every few weeks to a couple of months, and prefer the shorter time. 7. Working software is the main measure of progress. 8. Keep a sustainable pace: sponsors, developers and users should be able to keep going at the same speed for ever. |
C. People | 5. Build projects around motivated people; give them the support they need and trust them. 6. Face-to-face conversation is the best way to share information in a team. 11. The best designs come from self-organizing teams. |
D. Quality and improvement | 9. Continuous attention to technical excellence and good design makes the team faster. 10. Simplicity, the art of maximizing the amount of work not done, is essential. 12. At regular intervals the team reflects on how to become more effective, then changes its behaviour. |
Principle 10 surprises students. "Maximizing the work not done" means: do not build features nobody asked for, and do not write documents nobody will read. Every line of code you do not write is a line you never have to test or maintain.
Principle 8 is about health: a team that works until 3 a.m. every night makes more mistakes and eventually leaves. Agile teams should not live in permanent "deadline mode".
Word help sustainable = can continue for a long time without breaking down self-organizing = the team decides for itself how to do the work, instead of being told every step |
§3.2 Worked quick check: name the principle
Slide L03-S09
Situation | Principle | Why |
|---|---|---|
The team shows the client a working login and dashboard after only two weeks. | 1 / 3: deliver early and frequently | Valuable software reaches the customer early. |
In month 4 the client asks for Urdu language support. The team says, "Good idea, let's plan it for the next cycle." | 2: welcome changing requirements | A late change is accepted, not fought. |
After every two weeks the team meets for 30 minutes to ask, "What should we do differently?" | 12: reflect and adjust | Regular reflection to improve. |
A developer removes a "print to fax" feature that no user has ever asked for. | 10: simplicity | Maximizing the work not done. |
§4 Agility and the cost of change
Slides L03-S10 to L03-S11
§4.1 What is agility?
Slide L03-S10
In everyday English, agile means able to move quickly and change direction easily, like a good fielder in cricket. In software engineering, agility means a team can respond effectively to change.
Change comes from everywhere: the software being built, the team members, new technology, and the people paying for the project. Pressman says agility is more than reacting to change. An agile approach also:
- Builds teams that communicate easily (sitting together, short meetings, shared boards).
- Delivers working software quickly and puts less weight on in-between documents.
- Treats the customer as part of the team, not as "them" on the other side.
- Accepts that planning has limits: in an uncertain world the plan must be flexible.
Real-world example: cricket fielding A captain sets a field before the over, but moves fielders after every ball depending on what the batsman does. That is agility: a plan exists, but it changes as soon as new information arrives. |
Word help agility = the ability to respond quickly and effectively to change |
§4.2 Agility and the cost of change
Slide L03-S11
In a traditional (plan-driven) project, the cost of a change grows very fast as the project moves forward. A change during requirements means editing a document. The same change after testing means changing the design, the code, the tests and the user manual, and perhaps fixing data already in the database.
Real-world example: making a field compulsory A student admission form has an optional "CNIC / B-Form number" field. The university now wants it compulsory. During requirements: change one line in the document. Cost: minutes. After the system is live with 20,000 records: change the database, write a script for old records with no number, change the form, re-test, re-deploy, and inform the admissions office. Cost: days. |
Agile supporters argue that a well-run agile process flattens the cost-of-change curve. Because the software is built and delivered in small increments, with automated tests and continuous integration, a late change usually touches only a small part of the system.
Be careful: the flat curve is not free The curve is flatter only if the team uses good practices: small increments, automated tests, refactoring and frequent integration. Some changes are still expensive in any process, for example changing the main architecture or the database design late in a large system. This is a debated point in the textbooks. |
Word help cost of change = how much time, effort and money a change needs continuous integration = joining every developer's work into the main code many times a day and testing it automatically |
§5 The agile process and the people in it
Slides L03-S12 to L03-S13
§5.1 What is an agile process?
Slide L03-S12
Pressman says any agile process is built on three assumptions about most software projects:
1. It is hard to predict in advance which requirements will stay and which will change, and how customer priorities will change.
2. For many systems, design and construction are interleaved: it is hard to know how much design is needed before you start building and testing it.
3. Analysis, design, construction and testing are not as predictable (from a planning point of view) as we would like.
So how do we manage something we cannot predict? We make the process adaptable. And because a process cannot adapt by itself, it adapts in small steps using customer feedback. In practice an agile process:
- Delivers software increments (working pieces) in short cycles of one to four weeks.
- Gets customer feedback on each increment and uses it to plan the next one.
- Keeps specification, design, coding and testing going together in every cycle, instead of in separate long phases.
- Keeps documents light: enough to communicate, not more.
Sommerville adds that in agile methods the specification, design and implementation are interleaved, the system is developed as a series of versions, and user interfaces are often built with tools so users can react quickly.
Word help assumption = something accepted as true without proof, as a starting point interleaved = mixed together, one after another, again and again increment = a small working piece added to the software |
§5.2 Human factors: the team makes agile work
Slide L03-S13
Agile development puts people first, so the team must have the right qualities. Pressman lists seven:
Human factor | Meaning |
|---|---|
Competence | Skill in programming and software engineering, and knowledge of the process the team uses. |
Common focus | Everyone works toward one goal: delivering a working increment to the customer on time. |
Collaboration | Team members talk and work with each other and with the customer all the time. |
Decision-making ability | The team is trusted to make its own technical and project decisions. |
Fuzzy problem-solving ability | The team can deal with unclear problems that keep changing, and learns from each one. |
Mutual trust and respect | Members trust each other, so the team becomes stronger than its individual people (a "jelled" team). |
Self-organization | The team organizes itself, plans its own work and chooses how to do it. |
Real-world example: a good cricket team The captain does not tell the bowler where to put every ball. The bowler, wicket-keeper and fielders talk, adjust and decide together. They trust each other's skill (competence, trust), share one goal (winning the match: common focus) and change plans quickly (fuzzy problem solving). |
Word help competence = having the skill and knowledge to do a job well fuzzy = not clear; with no exact answer mutual = shared by both sides |
§6 Choosing agile wisely
Slides L03-S14 to L03-S16
§6.1 Plan-driven and agile side by side
Slide L03-S14
Plan-driven | Agile | |
|---|---|---|
Requirements | Fixed and approved at the start | Discovered and changed during the project |
Planning | Detailed plan for the whole project | Rough overall plan; detailed plan for the next few weeks only |
Delivery | One big delivery near the end | Small working increments every 1-4 weeks |
Documentation | Heavy; documents are the main output of each phase | Light; working software is the main output |
Customer role | Signs the contract and the requirements; sees the result at the end | Works with the team throughout and gives feedback on each increment |
Change | Controlled through formal change requests; costly | Expected and welcomed; cheaper if practices are good |
Progress measured by | Phases and documents completed | Working software delivered |
Best for | Stable, safety-critical, regulated or very large systems | Business, web and mobile systems with changing needs |
Copy this table into your notes. It is likely exam material, together with the comparison table from Lecture 2.
§6.2 When agile fits, and when it does not
Slide L03-S15
Sommerville suggests asking questions about the system, the team and the organization before choosing:
Agile usually fits when ... | Plan-driven (or a mix) is safer when ... |
|---|---|
Requirements are unclear or likely to change | A detailed specification is needed before building (for example for a fixed-price contract) |
The system is small or medium sized, built by one co-located team | The system is very large, built by many teams in different places or companies |
The customer can give time and feedback regularly | The customer cannot be involved regularly |
Software can be released in small pieces (web, mobile apps) | Incremental delivery is not realistic (for example software inside hardware) |
Team members are skilled and trusted to decide | The team is new or inexperienced and needs more structure |
The system is not safety-critical | The system is safety-critical or a regulator must approve detailed documents |
Many real projects use a mix: a planned contract, architecture and deadline at the top, with short agile cycles inside. Many Pakistani software houses that build products for foreign clients work in short agile cycles, while government projects bought through fixed tenders usually start plan-driven.
Word help co-located = working in the same place regulator = an official body that checks and approves, such as an aviation or health authority |
§6.3 Four myths about agile
Slide L03-S16
Myth | Reality |
|---|---|
"Agile means no documentation." | Agile teams write less documentation, and only what is useful. Code comments, user stories, test cases and a short architecture note are still documentation. |
"Agile means no planning." | Agile teams plan all the time, in small pieces: a release plan, a plan for each short cycle, and a daily plan. |
"Agile is always faster." | Agile delivers useful software earlier. The whole project is not always shorter, and without discipline it can be slower and messier. |
"Agile is just Scrum." | Scrum is one agile method. Others include XP, Kanban, Lean, DSDM and the Agile Unified Process. We study them in Lectures 4-6. |
§7 Worked activity: agile or not?
Slides L03-S17
§7.1 The task
Slide L03-S17
For each project, decide: agile, plan-driven or a mix? Name one manifesto value or principle that supports your answer, and one risk of your choice.
§7.2 Model answers
Slide L03-S17
Project | Choice | Supporting value or principle | Risk to watch |
|---|---|---|---|
A. Savings-goal feature in a mobile wallet (company unsure users will like it) | Agile | Working software over documentation; deliver early and frequently. Release a small version to some users and learn. | Feature grows without a clear goal; security must still be tested carefully. |
B. Railway signalling software (safety rules; independent safety approval) | Plan-driven (agile only inside small parts) | Agile values fit poorly: the regulator needs complete documents and planned tests. | Requirement mistakes found late; slow response to change. |
C. UAF online admission portal (live in 3 months; admission rules fixed) | A mix | Fixed deadline and rules are planned; screens are built in 2-week cycles and shown to the admission office (customer collaboration). | Deadline pressure breaks the sustainable pace; late rule changes. |
D. Urdu/Punjabi voice helpline app for farmers (startup; unsure what farmers will ask) | Agile | Responding to change; customer collaboration. Test with 50 farmers in Burewala and adjust. | Hard to get regular feedback from farmers; team needs discipline to keep code clean. |
Other answers can be correct if the reasons are good, just as in Lecture 2.
Summary
- Agile methods appeared because heavyweight processes could not keep up with change in business software. The Agile Manifesto was written in 2001.
- Four 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.
- The right-hand items still have value; agile teams value the left-hand items more.
- Twelve principles in four groups: customer and change, delivery, people, quality and improvement.
- Agility = responding effectively to change. Good agile practice tries to flatten the cost-of-change curve.
- An agile process is adaptable and moves in small increments with customer feedback. It depends on people: competence, common focus, collaboration, decision-making, fuzzy problem solving, trust, self-organization.
- Agile is not right for every project. Many projects mix plan-driven and agile.
- Before Lecture 4: read Pressman Ch. 5.1-5.3 (or Sommerville 3.1); look ahead to XP (Pressman 5.4 / Sommerville 3.2); write 8 features of your team project as one-sentence user needs for Practical 2.
Word bank
Word | Simple meaning | Example |
|---|---|---|
agile | able to move quickly and change direction easily | a fielder who reacts to every ball |
agility | the ability to respond effectively to change | a wallet app updated within two weeks of a new rule |
manifesto | a public statement of beliefs | the Agile Manifesto (2001) |
heavyweight process | a process with many rules, steps and documents | a 200-page specification signed before coding |
value | something you believe is important | "working software over comprehensive documentation" |
comprehensive | complete; covering everything | a full design document for every module |
collaboration | working together | the client's accountant checking screens every two weeks |
sustainable pace | a speed of work the team can keep for a long time | no permanent all-night coding |
self-organizing team | a team that decides for itself how to do its work | developers split the tasks themselves |
simplicity | doing only what is needed | not building a feature nobody asked for |
cost of change | the time and money a change needs | making a form field compulsory after go-live |
continuous integration | joining and testing everyone's code many times a day | automatic tests run on every GitHub push |
increment | a small working piece added each cycle | the fee-voucher screen delivered in week 2 |
interleaved | mixed together, again and again | design, code and test in every two-week cycle |
assumption | something accepted as true as a starting point | "requirements will change" |
competence | skill and knowledge to do a job well | a developer who writes clean, tested code |
fuzzy | unclear; without an exact answer | "make the app easy for farmers" |
co-located | working in the same place | the whole team in one office in Faisalabad |
regulator | an official body that checks and approves | an aviation or railway safety authority |
Self-check questions
Try each question without looking. Then check your answer in the section shown.
# | Question | See |
|---|---|---|
1 | Why did agile methods appear? Give two problems with heavyweight processes. | §1.2 |
2 | When and where was the Agile Manifesto written, and by how many people? | §1.2 |
3 | Write the four values of the Agile Manifesto in the correct form. | §2.1 |
4 | "Agile means no documentation." Use the last line of the manifesto to correct this statement. | §2.1, §6.3 |
5 | Give one real-world example for each of the four values. | §2.2 |
6 | Name the four groups of agile principles and one principle from each group. | §3.1 |
7 | What does "simplicity: maximizing the amount of work not done" mean? | §3.1 |
8 | Define agility. Name two things, other than responding to change, that agility includes. | §4.1 |
9 | Draw the cost-of-change curves for plan-driven and agile development and explain the difference. | §4.2 |
10 | State Pressman's three assumptions behind an agile process. | §5.1 |
11 | List the seven human factors of an agile team. | §5.2 |
12 | Give three situations in which a plan-driven approach is safer than agile. | §6.2 |
13 | Would you choose agile for railway signalling software? Give reasons. | §7.2 |
Further reading
- Pressman & Maxim, *Software Engineering: A Practitioner's Approach*, 8th ed., Chapter 5, sections 5.1-5.3.
- Sommerville, *Software Engineering*, 10th ed., Chapter 3, section 3.1 (and section 3.4 on agile and plan-driven methods).
- The Agile Manifesto and its twelve principles: agilemanifesto.org (two short pages).