Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Practices of an Agile Developer

Practices of an Agile Developer

Make software projects easier to change, test, and deliver without imposing a rigid process.
by Venkat Subramaniam 2006 204 pages
3.88
1k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Treat software as a changing sea, not a blueprint to execute.

Plans meet reality. Software work is unpredictable because needs, technology, and understanding shift while a system is being built. The book compares development to surfing: each project brings different conditions, and the useful skill is adapting to what is actually happening, not insisting on a route drawn in advance. Agile development favors people collaborating, working software, customer involvement, and responses to change over rigid process, exhaustive documentation, and fixed plans. Those priorities do not make plans or documents worthless. They make them subordinate to whether the product works and serves its users.

Correct course continuously. Testing, integration, requirements, and feedback should happen throughout development, not as end-of-project events. Small problems are easier to handle before they grow into crises. The aim is steady adjustment, not permanent emergency mode.

Analysis

The surfing image captures a crucial distinction: uncertainty is not a temporary defect that better planning can eliminate. It is part of the work. That makes agility less a toolkit than a way to shorten the distance between noticing reality and responding to it. The caveat is that adaptation still needs direction. Without clear goals or accountable decision-makers, flexibility can become drift. The strongest version of the argument pairs a stable purpose with changeable plans, so teams can revise the route without forgetting where they are trying to go.

Show users working software every week or two, before assumptions harden.

Requirements keep moving. Users often understand what they need more clearly after seeing part of the product. The authors compare software planning to calculating a spacecraft’s path: if the calculation checks position only at long intervals, errors accumulate between checks. Frequent demonstrations provide opportunities to correct the course. The book recommends regular demos, often at the end of an iteration lasting a week or two, while recognizing that customers’ schedules may call for a slower pace.

Make feedback usable. A demo is a chance to learn, not a ceremonial presentation of a finished product. Show stable work, explain what is incomplete, and capture reactions in an issue-tracking system rather than scattering them across emails and notes. A shared glossary can also prevent business terms from being interpreted differently by users and developers.

Analysis

A demonstration turns abstract agreement into something people can inspect, challenge, and improve. It also changes the quality of customer participation: users respond to concrete behavior rather than trying to predict every future need from a written specification. The practice works best when feedback has a clear path into priorities and decisions. Otherwise, frequent demos can generate a growing pile of suggestions without changing the product. The authors also correctly treat the customer’s time as a constraint, not as an unlimited source of feedback.

Let business owners decide trade-offs that change how their work gets done.

Separate technical from business choices. Developers should shape technical design, but they should not quietly make decisions that affect users’ work or business outcomes. In one example, a manager selected a faster implementation that limited user options. The customer discovered the restriction during beta testing, and the resulting rework cost more than discussing the trade-off earlier would have.

Present real alternatives. Explain options, benefits, costs, and effects on schedule in language business owners can use. Do not ask them to choose among technical abstractions they cannot evaluate, and do not burden them with details that have no business impact. Record important decisions and their reasoning, since memories diverge and teams change. If a business owner does not yet know what they want, a demonstration can help make the question answerable.

Analysis

This is a practical account of decision rights. Developers possess information about implementation, while business owners are better placed to judge the value and consequences of user-facing choices. Good collaboration does not mean transferring every decision to the customer; it means putting each decision with the people who bear its consequences. That distinction can prevent both technical overreach and endless consultation. It also demands translation: a trade-off becomes actionable only when the options are expressed in terms the decision-maker can understand.

Make testing and integration routine, so defects surface while changes are small.

Turn checks into a habit. Unit tests are small automated checks of a component’s behavior. They give developers quick feedback about whether a change broke something that already worked, and they can support refactoring by making expected behavior explicit. Test Driven Development, or TDD, starts with a failing test before adding the code that makes it pass. In the book’s tic-tac-toe example, writing a test first steers the design toward a simple player marker instead of an unnecessary player class.

Build on every change. Continuous integration means regularly combining shared code and automatically compiling and testing it. The authors recommend integrating several times a day when practical, and running tests on each supported platform. Automation makes failures visible sooner, when the code and the cause are still familiar.

Analysis

Automated tests provide a form of memory: they preserve important expectations even when the people who first established them are busy or gone. TDD adds a design benefit because it makes the programmer experience an interface as a user before committing to its implementation. But a green test suite is not proof that software is correct. Tests reflect the cases people thought to check, so weak or incomplete tests can create false confidence. Their value depends on choosing meaningful behaviors and updating checks as real requirements change.

Write code for the next reader, and let real needs justify complexity.

Prefer clarity to cleverness. The book’s PIE Principle, short for Program Intently and Expressively, asks developers to make code communicate its purpose clearly. For instance, a named cup-size value is easier to understand than a bare number that requires a comment to explain it. Useful names and clear structure usually help more than comments that merely narrate the code.

Keep the design proportional. A client project accumulated thousands of unexplained one-off corrections because developers patched symptoms without understanding the underlying data model. Each shortcut made the system harder to change. The authors recommend small, cohesive components, frequent refactoring, and technology chosen to solve an identified problem. Avoid adding frameworks, patterns, or elaborate abstractions just because they are fashionable or might be useful someday. A design earns its complexity by handling actual needs.

Analysis

Readability is an economic choice as much as a stylistic preference. Code is repeatedly revisited, while the original author’s reasoning is not always available. Clear structure lowers the cost of those future encounters. Simplicity, however, should not be confused with minimal line count or minimal architecture. A compact patch can conceal a costly assumption, and a modest abstraction can prevent repeated errors. The right test is whether the design makes likely changes easier without imposing more machinery than the problem warrants.

Build a team where knowledge, criticism, and responsibility travel freely.

Make work shareable. Collective ownership means that more than one developer can understand and improve each part of the code. Rotating developers through components reduces dependence on a single expert and gives fresh readers a chance to expose confusing designs. Small, regular code reviews provide another set of eyes. The book cites Capers Jones’s estimate that formal inspections can be about twice as efficient as testing at finding defects, and that inspections are the only known method to exceed 80 percent defect removal.

Keep disagreement useful. Discuss the merits of ideas, not the worth of the people proposing them. A short daily stand-up can surface progress and obstacles through three prompts: what was completed, what comes next, and what is blocking the work. When a problem appears, focus first on fixing it rather than assigning blame. Mentoring and well-aimed questions help others develop judgment instead of depending on one person for answers.

Analysis

This section treats collaboration as part of the technical system, not a pleasant extra. Knowledge concentrated in one person creates a bottleneck; criticism delivered as humiliation suppresses the information the team needs. Shared ownership and respectful review counter both risks. Still, collective ownership does not mean everyone should change everything without coordination. The authors acknowledge the need to preserve specialized expertise and limit unnecessary disruption. The useful principle is broader access to understanding, supported by review and responsibility, rather than indiscriminate editing.

Debug by isolating the fault, preserving clues, and reporting what truly failed.

Reduce the search area. A large application contains many interacting parts, which makes a defect difficult to locate. The authors recommend isolating the relevant module or creating a small test bed that reproduces the problem. In one example, developers struggling with database corruption built a small prototype and sent it to the vendor. The reduced case helped clarify the issue and made expert diagnosis possible.

Keep the evidence. Record problems and solutions in a searchable log, including versions, settings, and useful references. Treat compiler warnings seriously because some reveal real defects, such as an assignment mistakenly used where a comparison was intended. Handle exceptions or pass them to code that can. Give users a clear explanation and a way to access diagnostic details, while avoiding disclosure of sensitive information.

Analysis

Isolation is powerful because it converts a vague failure into a question that can be tested. A minimal reproduction also improves communication: another developer or vendor can investigate evidence rather than guess at a sprawling system. The same discipline applies to error reporting. A message should help the user act, while diagnostic detail should help the team find the cause. These audiences need different levels of explanation, so useful reporting separates an understandable surface from the deeper evidence without discarding either.

Estimate from completed work, and sell progress in useful increments.

Measure remaining work. Percent-complete reports can stay at 80 percent for days and conceal the work still ahead. A backlog, a prioritized list of unfinished tasks, makes remaining work visible. Record how long tasks actually take and use that experience to improve future estimates. The point is not to predict perfectly, but to replace confident guesses with evidence from the current team and project.

Reduce contract risk. The authors argue that fixed prices and delivery dates are unreliable when requirements and technical understanding are still changing. They suggest proposing a small, useful first delivery, perhaps one that takes six to eight weeks, then letting the client decide whether to continue. Each iteration should have a fixed timebox, a short period with a firm end date and flexible scope. A usable release can take weeks to months, with shorter development iterations inside it.

Analysis

Incremental delivery changes estimation from a one-time wager into an ongoing learning process. The client sees evidence early, and the team can revise expectations using actual performance rather than an imagined future. This also gives both sides a way to limit exposure when a project is not producing value. The approach does not remove the need for an initial estimate, nor can it guarantee a flexible contract. Its strength is making uncertainty explicit and giving stakeholders meaningful choices as information improves.

Keep learning, and retire habits whose original constraints have vanished.

Update your mental tools. Technologies change, but old assumptions can linger after the conditions that justified them disappear. The authors recall programming with severe memory limits and hand-tuning machine code, practices that once addressed real constraints but could later waste developer time. Their point is not to discard all older knowledge. It is to recognize when a technique no longer fits the environment, and to learn a new tool without forcing it to behave like the old one.

Learn in small doses. Set aside regular time to investigate unfamiliar ideas, read, attend technical groups, and share what proves useful in informal team sessions. When introducing agile practices, begin with one or a few that fit the team’s situation. For a failing project, first stabilize communication and basic delivery rather than changing every practice at once.

Analysis

Technical experience is valuable, but it can become a trap when familiar methods are treated as timeless truths. The book’s distinction between reusing knowledge and carrying old habits forward is especially useful: concepts can survive even when their original implementations do not. Incremental learning makes change manageable, while team discussion tests whether a new idea fits real work. There is also a social dimension: practices imposed all at once may provoke resistance, whereas visible improvements give colleagues a reason to participate.

Analysis

Practices of an Agile Developer is a practical guide to changing the daily conditions of software work. Its argument is cumulative: uncertainty requires short feedback loops; feedback depends on working software, automated checks, and regular contact with users; those loops only function when code remains understandable and a team can share responsibility. The book is not organized around one formal method. Instead, its compact practices cover individual judgment, technical discipline, customer involvement, debugging, and collaboration. The recurring bad-habit and corrective-advice pattern gives these principles a memorable shape without pretending every team needs an identical process.

The most useful contribution is its insistence that agility is operational, not ceremonial. A team is not adaptive merely because it uses iterations or holds stand-ups. It must be able to detect a wrong assumption, expose the problem, and make a change without excessive cost. Frequent demos, automated tests, integration, and code review are presented as ways to make that possible. Equally important, the authors connect technical quality to human behavior: blame discourages disclosure, territorial code ownership hides knowledge, and silent delays prevent timely help.

The book also argues for balance. Design remains necessary, but should guide implementation rather than dictate details that experience may overturn. Tests matter, but effort should target meaningful behavior. Collective ownership matters, but not as permission for chaotic changes. This attention to limits prevents the practices from becoming another rigid process.

Some advice reflects the book’s 2006 technical setting, and its many examples depend more on practitioner experience than systematic evidence. Its strongest claims should therefore be read as durable heuristics, not universal laws. Teams working under strict safety, regulatory, or contractual constraints may need additional documentation and formal controls. The deeper lesson survives those qualifications: shorten the time between assumption, evidence, and correction, while keeping the people doing the work able to communicate honestly.

Summary in 30 Seconds
Changing requirements call for frequent customer feedback, with working demonstrations often scheduled every one or two weeks. Automated tests and regular integration reveal defects while changes are still small. Clear code, focused design, and shared ownership reduce the cost of future changes. Formal inspections can find defects about twice as efficiently as testing and may remove more than 80 percent. Track completed work to improve estimates, and offer useful early deliveries instead of betting on a fixed plan.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.88 out of 5
Average of 1k+ ratings from Goodreads and Amazon.

Practices of an Agile Developer receives mixed reviews, with an average rating of 3.87 out of 5. Many readers find it useful for beginners and those new to Agile practices, praising its practical advice and easy-to-read format. Some appreciate its focus on both technical and interpersonal aspects of development. However, experienced developers find less new information. Critics note that some advice is common sense or debatable. Overall, readers value the book for its concise tips, real-world examples, and potential to improve development practices, despite occasional idealism and outdated technical examples.

Your rating:
4.42
79 ratings
Want to read the full book?

Glossary

PIE Principle

Write expressive code

PIE means Program Intently and Expressively. It is the practice of writing code so its purpose and behavior are apparent to readers. Clear names, explicit intent, and appropriate language features make code easier to understand and can prevent errors that arise when a reader must infer what an opaque expression means.

Test Driven Development

Test before implementation

Test Driven Development, or TDD, is a way of developing in which a programmer first writes a test for the behavior desired, confirms that the test fails, and then writes the code needed to pass it. The book presents this as both a feedback technique and a way to design interfaces from the perspective of their users.

You Aren’t Gonna Need It

Defer unneeded features

You Aren’t Gonna Need It, usually shortened to YAGNI, is the principle of not implementing a feature before there is a demonstrated need for it. In the book’s tic-tac-toe example, a test leads to a simple way to represent the first player rather than adding a player class whose extra capabilities are not yet required.

Continuous integration

Build and test shared code

Continuous integration is the regular combination of developers’ changes into shared project code, supported by automated builds and tests. The book recommends running these checks often and alerting the team when they fail, so incompatible changes and defects are discovered before they accumulate into a difficult integration effort.

Time boxing

Fix the time limit

Time boxing assigns a firm, near-term limit to an activity. The deadline stays fixed while the amount of work completed can vary. The book applies the idea to iterations and meetings: a fixed end forces choices about scope and prevents tasks or discussions from continuing indefinitely.

Collective Ownership

Share code responsibility

Collective Ownership is a team practice in which code is not the exclusive responsibility of the developer who first wrote it. Team members can learn, review, and improve different parts of the system. The aim is to spread knowledge, reduce dependence on individuals, and make maintenance and scheduling more resilient.

Tell, Don’t Ask

Keep behavior with its owner

Tell, Don’t Ask is a design principle that discourages one object from retrieving another object’s internal state, making decisions about it, and then changing it. Instead, the caller requests an action and the object responsible for that behavior handles its own state. This supports encapsulation and reduces fragile dependencies between components.

Liskov Substitution principle

Honor substitutable contracts

The Liskov Substitution principle says that an instance of a derived class should be usable wherever an instance of its base class is expected, without requiring the caller to know the difference. A derived class must preserve the base class’s behavioral promises. When that relationship does not hold, composition or delegation may be a better design.

Information radiators

Make status visible

Information radiators are visible, regularly updated displays that communicate project information to people who pass by or consult them. The book suggests posters, websites, wikis, blogs, and feeds as ways to show progress, designs, or discoveries. Their purpose is to make useful information easy to find without requiring people to repeatedly ask for it.

About the Author

Venkat Subramaniam is an accomplished author, speaker, and software developer known for his expertise in Agile methodologies and programming languages. He has written multiple books on software development practices and technologies, focusing on practical approaches to improving coding skills and team collaboration. Subramaniam is recognized for his ability to convey complex concepts in an accessible manner, making him a popular presenter at conferences and workshops worldwide. His work often emphasizes the importance of continuous learning and adapting to new technologies in the ever-evolving field of software development. Subramaniam's contributions have significantly influenced the Agile development community and helped shape modern programming practices.

Download PDF

To save this Practices of an Agile Developer summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.30 MB     Pages: 16

Download EPUB

To read this Practices of an Agile Developer summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.35 MB     Pages: 19
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 25,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...