"Sustainable Software Development" brings together principles and practices for building software that is technically superior, delivers exceptional business value, and can evolve rapidly to reflect any change to your business or technical environment.
Kevin Tate shows how to eliminate practices that make development unsustainable, replacing them with a sustainable approach that draws on the best ideas from both agile and conventional development. Tate demonstrates how to manage the paradox of rapid releases versus long-term sustainability, achieving both rich functionality and superior quality. You'll learn how to build a development organization that is more productive, more programmer-friendly, and can continually improve its ability to handle complexity and change.
Writing for developers, architects, project leaders, and other software team members, Tate shows how to:
Understand today's software "ecosystem" and its implications for development teams
Take control of your development environment, so you can outship your competitors, leveraging new technologies and responding to new business opportunities
Maintain a consistent pace that optimally balances short- versus long-term requirements
Keep your code base in a "near-shippable" state between releases
Prevent defects, rather than just recognizing and fixing them
Invest continually and cost-effectively in software design improvements
Leverage the fundamentals of the craft of software development
Drive essential cultural change throughout your organization
Integrating sustainable processes with Agile and CMM methodologies
Review By: Ronald R. Goodwin, PMP 07/08/2010Based on the viewpoint he expresses in "Sustainable Software Development: An Agile Perspective," author Kevin Tate is a programmer, not a developer. From his introduction calling JCL an "antiquated . . . programming language" (tell that to the mainframe gurus!) to stating that "usability testing is humbug," he makes it clear that programmers understand their programs better than the end-users. Unfortunately for the end-user, this is a serious oversight by the programmer, as the programmer is seldom there to help the end-user figure out which of the navigation bars on the left side of the screen takes you to an actual, usable feature.
The author uses iterative development, as do most good programmers or developers today. The waterfall has dried up, and he repeatedly tells us why. “Iterative development,” Kevin states, “is the most effective when there is a broad participation in iteration planning.” After reading this and thinking of the developers I have seen in action, I wonder, does having one other person working with you make the iterative process a “broad participation?”
Iterative development, as explained, is the heartbeat of the development effort. It is what makes the effort sustainable, workable, and good for the team, as it breaks the effort into manageable pieces. This is the same thing that project managers have been trying to do for about a decade--break the project (in this case application development) into bite-sized pieces. Unfortunately, too many developers and programmers want to eat the elephant all at once.
Kevin does one thing very well in this book: he provides a lot of practice sessions. After a three-chapter introduction, each of the next four chapters provides 30 practice sessions, covering documentation to using tools.
Overall, it is a good treatise on iterative development processes, but it isn't what I call a real “Ah-Ha!” type of book. This is a programmer’s book, written by a programmer and aimed at a programming audience.