Robert C. Martin, with contributions by J. W. Newkirk and R. S. Koss
AGILE SOFTWARE DEVELOPMENT: Principles, Patterns, and Practices
Hardcover, pp. 529, $ 50.99
Prentice-Hall Inc., Upper Saddle River, NJ 07458, 2003
ISBN 0-13-597444-5
http://www.pearsoneduc.com

In general about the book

Agile Software Development is the ability to develop software quickly in the face of the rapidly changing requirements. In order to achieve this agility, there is a need to employ practices that provide the necessary discipline and feedback. The purpose of the Agile Modeling methodology is to define effective modeling and documentation practices that should be incorporated into another more comprehensive process such as Extreme Programming. Developers need to employ design principles that keep software flexible and maintainable. Also, developers need to know the design patterns that have been shown to balance those principles for specific problems. This book is an attempt to knit all three of these concepts together into a functioning whole. The authors of this book provide a practical approach to modeling that allows you to successfully deploy best practices on your agile software development project. The book describes those principles, patterns, and practices and then demonstrates how they are applied by walking through a dozen of different studies.

The book begins with a discussion of development practices and processes. It starts with the Manifesto of the Agile Alliance and agile practices and provides an overview of Extreme Programming. That discussion is punctuated by a number of small case studies and examples. From there, the book moves on to the topic of object-oriented software design and object-oriented design principles, and the to some design patterns. All these topics are accompanied by case studies of varying sizes. Some are very small, and some require several chapters to describe. Each case study is preceded by material that is meant to prepare you for it. For example, the Payroll case study is preceded by chapters describing the object-oriented design principles and patterns used in the case study. The case studies are not presented as completed work. Rather, they are design in progress. The reader will see the designer make mistakes, and will observe how they identify the mistakes and eventually correct them.

This book contains a lot of UML diagrams, Java and C++ code, which is one of the good points of the book. The code is the actualization of what this book has to say. Also, appendices and some chapters in section 3 provide a good grounding in both the syntax and use of UML. It will also help reader translate between UML and a programming language like Java or C++. But, this book is not an entry-level UML book.

A companion Web site is available. All the source code in this book can be downloaded from www.objectmentor.com/PPP.

Chapter content

This book is organized into six major sections followed by several appendices:

The section 1 describes the concept of Agile Development. It starts with the Manifesto of the Agile Alliance and agile practices (Chapter 1), provides an overview of Extreme Programming (XP) (Chapter 2), and asurvey of many small case studies that illuminate some of the individual XP practices, especially those that have an impact on design and code writing (Planning in Chapter 3, Testing in Chapter 4, Refactoring in Chapter 5, and an Programming Episode for the Bowling game in Chapter 6).

The chapters in Section 2 talk about object-oriented software design. The first chapter in this Section (Chapter 7) asks the question, what is agile design? It discusses the problem of, and techniques for managing complexity. Finally, the section culminates with the principles of object-oriented class design: the Single-Responsibility Principle, described in Chapter 8, the Open-Closed Principle, in Chapter 9, the Liskov Substitution Principle in Chapter 10, the Dependency-Inversion Principle in Chapter 11, and the Interface-Segregation Principle in Chapter 12.

Section 3 describes the object-oriented design and a C++ implementation of a simple batch payroll system. This Section begins with rudimentary specification of the Payroll System. The first few chapters in this section describe the design patterns that the case study encounters (Chapters 13 to 17). The final two chapters contain the full case study. Chapter 18 describes iteration one, with analysis by Use-Cases, and finding underlying abstractions. Chapter 19 describes the implementation process of Payroll system.

Section 4 begins by describing the principles of object-oriented package design (Chapter 20). It then goes on to illustrate those principles by incrementally packaging the classes from the previous section (Chapters 20 and 21).

The next two sections include very valuable case studies of real systems. These are Weather Station study (Section 5, Chapters 23 to 27) and Education Testing Service (ETS) Case Study (Section 6, Chapters 28 to 30). The Weather Station study describes a company that has made a significant business decision and explains how the Java development team responds to it. The section begins with a description of the corresponding design patterns (Chapters 23 to 26) and culminates in the description of the design and implementation (Chapter 27). ETS is the project that the authors participated in. It is the automated test system used to deliver and score the registry examination for the National Council of Architectural Registration Boards. Chapters 28 and 29 describe corresponding design patterns ("Visitor" in Chapter 28, and "State" in Chapter 29)

The first two appendices (A and B) contain several small case studies that are used to describe the UML notation. The next two (C and D) contain miscellaneous appendices ("A satire of Two Companies", and "The Source Code is the Design"). Of the end of the book includes an index.

Useful book

This book was written primarily for developers, and it contains the information you need to develop software in the agile manner. Reading the book cover to cover introduces practices, then principles, then patterns, and then it provides case studies that tie them together. Integrating all this knowledge will help you get your project done. Reader of this book can learn about design patterns in general, and find a particular pattern you are interested in. Also, appendixes and some chapters in section 3 are a good grounding in both the syntax and use of UML. It will also help reader translate between UML and a programming language like Java or C++.

Also, the book is useful for a Manager or Business Analyst. The chapters in Section 1 provide an in-depth discussion of agile principles and practices. They will take readers from requirements to planning to testing, refactoring, and programming. It provides guidance on how to build teams and manage projects. Finally, I recommend this book to all readers who are interested in new approaches in software engineering and I encourage everyone who uses and teaches the mentioned aspects of software processes to get a copy of the book.