- You'll save an extra 5% on Books purchased from Amazon.ca, now through July 29th. No code necessary, discount applied at checkout. Here's how (restrictions apply)
Practices of an Agile Developer: Working in the Real World Paperback – Jul 1 2005
Special Offers and Product Promotions
Customers Who Bought This Item Also Bought
No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
Getting the download link through email is temporarily not available. Please check back later.
To get the free app, enter your mobile phone number.
""I was familiar with some of the practices mentioned since I own other books from The Pragmatic Bookshelf, but this book brings a lot of those ideas together and presents them in an clear, concise, organized, format. I would highly recommend this book to a new developer or to a development team that wanted to get 'agile, '.""--Scott Splavec, Senior Software Engineer
""This book helps you understand what you are missing, or what you can do better. Practices of an Agile Developer makes it easy to become agile, or get even better at it.""--Steffen Gemkow, Managing Director, ObjectFab GmbH
About the Author
Venkat Subramaniam, founder of Agile Developer, Inc., has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia. Venkat helps his clients effectively apply and succeed with agile practices on their software projects. He is a frequently invited speaker at international software conferences and user groups.
He's author of ".NET Gotchas" (O'Reilly), coauthor of the 2007 Jolt Productivity award-winning book "Practices of an Agile Developer" (Pragmatic Bookshelf), and author of "Programming Groovy" (Pragmatic Bookshelf).
Andy Hunt is a programmer turned consultant, author and publisher. He co-authored the best-selling book "The Pragmatic Programmer", was one of the 17 founders of the Agile Alliance, and co-founded the Pragmatic Bookshelf, publishing award-winning and critically acclaimed books for software developers.
Most Helpful Customer Reviews on Amazon.com (beta)
The book includes 45 different points that an agile developer should follow. For example, "Criticize Ideas, Not People" and "Keep it Releasable". Each section begins with one of these points, followed by a little demon telling you why you shouldn't follow the agile principle. More often than not, you'll find that the demon's arguments are things you might have heard from your co-workers, managers, or someone else in your work environment. After the authors' explain why the particular agile principle is important, the little angel sums up why the principle is important. Again, it sounds silly, but it's an effective teaching mechanism. It's also a lot of fun when the demon's arguments are ones you've heard before.
In reading the book, I had the sense that the authors were really trying to be unbiased in their discussion of agile. They present some very convincing case studies of how some projects when terribly wrong, and how it could have been prevented with some very simple agile practices. With some books on agile, you have the sense that the authors have never written a line of code in their life. This book was a good reality-check for me. The authors sound like they know what they're talking about, and they talk about real-life problems that all of us experience in our coding. I would highly recommend this book to developers looking to become more agile, but needing something that's actually applicable to the real world.
The longer review...
The book is composed of tips. Most tips are about 2 to 4 pages, which make for a very quick read. This is both good and bad - it seems very overviewy. The structure of every tip, starts out with the title, a description of the tip and then a "what it feels like" little paragraph that gives you the emotional state you should be in when you are doing this and a "keeping your balance" bullet point. To me it feels very touchy feely/self-helpy and turned me off, but that's just a personal issue - others may find this format very novel and helpful. The length of each tip precludes it from going in depth into any particular one.
The first two chapters "Beginning Agility" and "Feeding Agility" read like some kind of self-help manual. To sum them up they mean to say,"Don't be a jerk to your team." It seems to me, anyone who is reading this book who is always assigning blame, looking for scapegoats, sticking fast to unsupportable claims - they are unlikely to change because the author's suggest that maybe that's not the best way. I'd wager that most readers of this book already are focused on working well with the team - at most this should have been a few pages. The second chapter spends nearly 20 pages that saying, you should keep your skills up to date and at least have a broad measure of what's going on in the ever progressive world of technology.
The next 4 chapters (the only ones before the epilogue), either repackage Extreme Programming (with unit testing, group ownership, iterative programming, quick feedback loops, keep the customer in the mix, refactor, keep things simple) with a couple more experiential suggestions. Strangely, they credit XP with stand up meetings, but none of the almost everything else they seem to have cribbed.
One thing they do throughout the book, that I like, is they suggest problems and solutions because of real world experiences they've had. I enjoy books that do that because you can see how people get to where they are and how they develop. Sometimes, their solutions agree with you or give you a new insight in how to deal with something.
The epilogue gives you some ideas on how to move to agile developing.
It's not a bad book. Generally the ideas are valid and work proven and will probably be useful to most people. Personally, I prefer the more in depth XP books from which this seems to repackage most of it's core ideas, it seems more like XP lite, that you can read in one sitting in an afternoon (which I did) and come away with a couple good ideas. So buy this for a quick read, but I'd say, if you're really interested in these ideas, go for the original XP books.
Each chapter starts out with a very sensible overview, pointing out where the practices for that chapter might fit. Each specific practice is nicely done, with short, to-the-point discussions of what the practice is, how you roll in to it, and how you stay in the groove with that practice.
There's a lot of goodness in the bibliography for additional reading, plus the epilogue, "Moving To Agility" is worth pasting on the foreheads of stubborn mangement who are unwilling to listen to rationale for improving the development environment. The specific steps for rescuing a failing project are terrific, as are the other epilogue sections.
Lastly, there's a nice pull-out reference card with one or two sentance blurbs on each practice.
Too many folks have derided agile software development as a `do whatever you want' process that isn't a process. This book does a good job at clearly stating the goals of an agile developer and walking through what the process means to the developer. It paints the true picture of the process and the foundation: treating developers and responsible professionals capable of implementing a solution without enough information. Agile admits that we'll always be imperfect in defining the specification, so it embraces the concept.
Other key points the book covers includes: Daily stand-up meetings. Finding bugs early. Test driven development. Nightly builds. All with the goal of making a schedule by making lots of little milestones. Plus, putting a process in place that hums along with a rhythm. A nice call-out in the book identifies out practical tools required for the agile developer including the wiki (for documentation), continuous integration, automated build and others.
The playful tone of the `devil' and `angels' on the shoulders of the developer is an interesting way to present the problems in software and solutions presented by agile, even if it's a little condescending (as though we're all intent on listening to the worst advice in software development). I understand the intent but could imagine a little less cartoon-ish way of presenting the problem/solution mix.
Overall, an excellent book to walk through what it's like to develop in an agile process and how it will feel once it's done. It provides insight into how to adopt it successfully and gives perspective on the end-product you may not see immediately.
What makes the book only average however is the general way that it defends each practice. In contast to another Pragmatic Programmer title, "Ship It!", there is a lack of explaination of the "why" of each practice. In some cases, they take a shot at explaining why, but it general terms that aren't really compelling. (They certainly won't be compelling if management or your peers are skeptical of agile practices.)
Even if you believe in agile, as I do, you need to understand why you do certain things and how each of those practices fit together to support each other. Software development isn't about blindly following a process - you have to understand what you are doing. For that, you'll have to look elsewhere.
Look for similar items by category
- Books > Computers & Technology > Computer Science > Software Engineering > Methodology
- Books > Computers & Technology > Programming > Languages & Tools
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Development
- Books > Computers & Technology > Software
- Books > Textbooks > Computer Science & Information Systems > Computer Science
- Books > Textbooks > Computer Science & Information Systems > Programming Languages
- Books > Textbooks > Computer Science & Information Systems > Software Design & Engineering