https://henrikwarne.com/2020/04/27/20-5-years-of-xp-and-agile/ Henrik Warne's blog Thoughts on programming... Skip to content * Home * About [cropped-desk1] - Secure by Design Artificial Intelligence - A Guide for Thinking Humans - 20.5 Years of XP and Agile Posted on April 27, 2020 | 4 Comments In the fall of 1999 I got the biggest productivity boost of my entire career as a software developer. In the October issue of IEEE Computer magazine, there was an article by Kent Beck called "Embracing change with extreme programming". In it, he outlined Extreme Programming (XP), which includes much of what we now refer to as agile development. By then, I had been working as a software developer for seven years. The standard development methodology at that time was waterfall: document-heavy year-long projects, frozen requirements, change control boards, manual testing at the end of the project, and so on. Software development succeeded despite the methodology, not because of it. Reading the article was a real eye-opener. I felt it was describing how I naturally worked - in short cycles, with fast feedback, and frequent redesigns. [dsc_0368-e1587491336549] (And yes, I meant to write this last fall for the 20th anniversary, but I didn't get around to it then. But hey, better late than never, even if the title has 20.5 in it now) Waterfall In the 1990s I worked as a software developer for Ericsson, developing software for mobile phone exchanges. The projects for new releases of the software had names like 91B (for Q2 1991) and 92C (for Q3 1992). A typical project at that time lasted for a year or more. The methodology was typical waterfall: requirement documents were written and handed over to developers. We developers implemented the features, and documented them with elaborate flow charts that nobody ever looked at. Testing was mostly manual, and done at the end of the project. If there were changes to the requirements, they had to be approved by a change control board before they were implemented. By the turn of the millennium at Ericsson, we also had Rational Unified Process (RUP) and an awful tool for generating code from UML diagrams called ROSE. Even though I only worked at Ericsson (albeit at several different locations), my feeling is that this type of waterfall methodology was the dominant methodology for most software development at the time. It was certainly how I was taught software development at university. And it seems so reasonable! If you can't get the complete requirements for what to develop, how can you do a good job developing it? And if they requirements are allowed to change, you jeopardize what you have already done. But I struggled getting the waterfall methodology to work for me. It was always too hard for me to come up with a complete design, and then implementing it. Instead I would make a really tiny version of what I needed, and test that. Then I would add the needed functionality little by little, always testing and running the code along the way. As I developed, I would have new insights into the problem I was trying to solve, and about how the solution should be structured. Agile When I read the article about XP, I immediately felt that it aligned really well with what I had discovered worked for me. Instead of following a rigid plan and fighting against changes, the article outlined a whole development methodology based on allowing and encouraging changes. There were of course many other things in the article that I had not discovered for myself, but that sounded like such good ideas when I read about them. For example, I really liked the concept of unit tests. When I wrote my code in tiny increments, I would often test the new code I had written, to gain confidence that it worked. However, these were always one-off tests that I didn't save. The idea of keeping all those little tests in a test suite that could be run again and again was great. Another great idea was to design with testing in mind. I still remember the aha-moment when I changed the code to make it easier to unit-test, and saw how much cleaner the design of the program became. Another great idea was refactoring. This is something I did from time to time, but having a name for it, and arguments for why it is needed, was really good. However, the most important changes XP (and what later became agile) brought were not specific practices like unit testing and refactoring. The most important changes were the themes of iterative development in small steps, with fast feedback and frequent adjustments to what we are developing. These core ideas are almost the opposite of the ideas of waterfall. Today, it seems to me that agile won. Almost all companies try to use agile ways of developing software. Not all succeed perhaps, but the aspiration is there. Conclusion Waterfall is good in theory, but it doesn't work well in practice. 20 years ago I discovered and switched to using agile methodology instead. There the emphasis is on iterative development, frequently delivering small slices of functionality, with fast feedback and many adjustments. Changing to this way of working was the biggest productivity boost of my career, and it is working as well today as it did when I switched. Thank you Kent Beck for your great ideas! Share this: * Twitter * Facebook * LinkedIn * Like Loading... Related This entry was posted in Programming, Work and tagged agile, extreme programming, waterfall, XP. Bookmark the permalink. - Secure by Design Artificial Intelligence - A Guide for Thinking Humans - 4 responses to "20.5 Years of XP and Agile" 1. [c2db5] Henrik Warne | April 27, 2020 at 1:18 pm | Reply Reddit discussion: https://www.reddit.com/r/programming/comments/ g8uiwh/205_years_of_xp_and_agile/ 2. [988dc] Jim | April 28, 2020 at 5:51 pm | Reply Great post 3. Pingback: Java Weekly, Issue 332 | Baeldung 4. [c2db5] Henrik Warne | January 15, 2024 at 4:09 pm | Reply Hacker New discussion: https://news.ycombinator.com/item?id= 38979266 Leave a Reply Cancel reply [ ] [ ] [ ] [ ] [ ] [ ] [ ] D[ ] * MOST POPULAR + Lessons Learned in Software Development + Top 5 Surprises When Starting Out as a Software Developer + Working as a Software Developer + Great Programmers Write Debuggable Code + What Makes a Good Programmer * RECENT POSTS + Tidy First? + What I Have Changed My Mind About in Software Development + Well-maintained Software + Algorithmic Trading: A Practitioner's Guide + There Is No Software Maintenance + Switching to Go - First Impressions + Effective Software Testing - A Developer's Guide + On Code Reviews + Book Review: A Philosophy of Software Design + On Comments in Code + 4 Things I Like About Microservices + Recruiting Software Developers - Coding Tests + More Good Programming Quotes, Part 5 + 6 Small Unit Testing Tips + Mathematical Modelling of Football + Deployed To Production Is Not Enough + Good Logging + Working From Home - Cons and Pros + Artificial Intelligence - A Guide for Thinking Humans + 20.5 Years of XP and Agile + Secure by Design + More Good Programming Quotes, Part 4 + Grokking Deep Learning + EuroSTAR Testing Conference Prague 2019 + Classic Computer Science Problems in Python + When TDD Is Not a Good Fit + Recruiting Software Developers - Checking Out a Company + Book Review: Designing Data-Intensive Applications + Nordic Testing Days Tallinn 2019 + Book review: Accelerate + More Good Programming Quotes, Part 3 + Programming: Math or Writing? + Developer On Call + My Favorite Command-Line Shortcuts + 6 Git Aha Moments + Is Manual Testing Needed? + Exercises in Programming Style + Programming for Grade 8 + 6 Years of Thoughts on Programming + Benefits of Continuous Delivery + More Good Programming Quotes, Part 2 + Developer Testing + Programming Conference - QCon New York 2017 + Developers - Talk To People + Code Rot + Programmer Career Planning + Software Development and the Gig Economy + Book Review: The Effective Engineer + Things Programmers Say + Developer Book Club + Book Review: Release It! + 18 Lessons From 13 Years of Tricky Bugs + Learning From Your Bugs + More Good Programming Quotes + The Wisdom of Programming Quotes + Ph.D. or Professional Programmer? + Social Engineering from Kevin Mitnick + Recruiting Software Developers - Initial Contact + Coursera Course Review: Software Security + Lessons Learned in Software Development + Book Review: Clean Code + Coursera Course Review: Computational Investing Part 1 + Programmer Knowledge + 5 Reasons Why Software Developer is a Great Career Choice + A Response to "Why Most Unit Testing is Waste" + What Makes a Good Programmer? + Switching from Java to Python - First Impressions + Antifragility and Software Development + 5 Unit Testing Mistakes + Unit Testing Private Methods + A Bug, a Trace, a Test, a Twist + Session-based Logging + Finding Bugs: Debugger versus Logging + TDD, Unit Tests and the Passage of Time + Automatically Include Revision in Log Statement + 7 Ways More Methods Can Improve Your Program + LinkedIn - Good or Bad? + Great Programmers Write Debuggable Code + SET Card Game Variation - Complementary Pairs + Programmer Productivity - Interruptions, Meetings and Working Remotely + What Do Programmers Want? + Coursera course review: Algorithms: Design and Analysis, Part 2 + Blog stats for 2012 (by WordPress) + Working as a Software Developer + 4 Reasons Why Bugs Are Good For You + Book Review: How Google Tests Software + Top 5 Surprises When Starting Out as a Software Developer + Programmer Productivity: Emacs versus IntelliJ IDEA + Why I Love Coding + Coursera course review: Design and Analysis of Algorithms I + Mac OS X Break Programs Review + Favorite Programming Quotes + How I Beat Repetitive Stress Injury + Introduction to Databases - On-line Learning Done Well + 10 million SET games simulated using "Random among 'most similar' Sets" + 10 million SET games simulated using "Random among available Sets" + 10 million SET games simulated using "First found Set" + SET(r) Probabilities Revisited * TAG CLOUD algorithms book book review break program bugs career code coding conference coursera creativity databases debugging developer testing DevOps emacs ergonomics face to face Google hiring ide idea integration testing intellij interruption job knowledge learning linkedin logging love machine learning Mac OS X meeting meta methods office on-line course probabilities production software productivity professional software development programmer programming programming course programming job python quotes recruiting refactoring Repetitive Stress Injury review revision RSI security SET game simulation software development statistics stats stretches subversion surprises svn tdd test-driven development testing time trouble-shooting unit-test unit testing university version work working * RSS + RSS - Posts + RSS - Comments * Follow Blog via Email Enter your email address to follow this blog and receive notifications of new posts by email. Email Address: [ ] Follow Join 377 other subscribers Blog at WordPress.com. * Comment * Reblog * Subscribe Subscribed + [wpcom-] Henrik Warne's blog Join 377 other subscribers [ ] Sign me up + Already have a WordPress.com account? Log in now. * + [wpcom-] Henrik Warne's blog + Customize + Subscribe Subscribed + Sign up + Log in + Copy shortlink + Report this content + View post in Reader + Manage subscriptions + Collapse this bar Loading Comments... Write a Comment... [ ] Email (Required) [ ] Name (Required) [ ] Website [ ] [Post Comment] %d [b]