Book Review: Agile Principles, Patterns and Practices in C#
I already had this book lying around on my desk for about 2 years now. Boy, am I a douche bag for no reading it sooner. I welcome this book into my personal hall of fame.
The first section contains some basic introductions to Agile, XP, Agile planning, Testing and Refactoring. Mostly basic stuff if you are already familiar with these concepts, but very nicely written and definitely worth a read.
The second section goes into Agile design. It starts of with a discussion about design smells continuing with the most important concepts of OOP:
- The Single Responsibility Principle
- The Open/Closed Principle
- The Liskov Substitution Principle
- The Dependency Inversion Principle
- The Interface Segregation Principle
Do I need to mention again that these are essential principles?
Then its time for a couple of short chapters about UML. Don’t worry. The authors just want to point out the parts of UML that they believe are essential and when to apply it. See it as a light version of UML without the waste. The authors also make it very clear that creating detailed diagrams in a CASE tool is probably a waste of time, which I certainly agree with. The only scenario when it useful to create UML diagrams in a CASE tool is when I’m sure if the diagram is actually going to be read by someone else besides me. Otherwise, a drawing on a whiteboard or a cocktail napkin will do just fine, which is encouraged by the authors.
The third section is a nice refresher to some design patterns like Command, Template Method, Strategy, Facade, Mediator, Null Object, etc. … . All these patterns are applied in the final chapter of the section where the authors are designing and implementing a Payroll system using TDD.
The fourth and final section starts off with a chapter about the principles of package and component design:
- The Reuse Release Equivalence Principle
- The Common Closure Principle Principle
- The Common Reuse Principle
- The Acyclic Dependencies Principle
- The Stable Dependencies Principle
- The Stable Abstractions Principle
Really neat stuff and I learned a ton. These are the basic principles that can be measured by NDepend. This section goes on with discussing some design patterns like Composite, Observer, Adapter, Bridge, Proxy, Gateway, Visitor, etc. …
I also want to mention appendix B which is an article written by Jack Reeves for the C++ Journal in 1992 named What is Software?. You can also find a a copy of this article here. The article is 16 years old and contains a lot of wisdom about software engineering that is still sooooo relevant today. I wish our industry would learn more from this. There is still a long way ahead of us.
Again, I really enjoyed reading this book. Don’t let its size scare you. Its very well written and an easy read. In fact, at times I really had a hard time putting it away. I’m already looking forward to Clean Code, which is on my order list.
I want to round off this post with some remarkable quotes from the book:
"Continuous attention to technical excellence and good design enhances agility. High quality is the key to high speed. The way to go fast is to keep the software as clean and robust as possible. Thus, all agile team members are committed to producing only the highest quality code they can. They do not make messes and then tell themselves that they’ll clean up when they have more time. They clean any messes as they are made."
"Databases are implementation details! Consideration of the database should be deferred as long as possible. Far too many applications were designed with the database in mind from the beginning and so are inextricably tied to those databases. Remember the definition of abstraction: "the amplification of the essential and the elimination of the irrelevant." At this stage of the project, the database is irrelevant; it is merely a technique used for storing and accessing data, nothing more."
"Interfaces belong to the client, not the derivative. The logical binding between the client and the interface is stronger than that between the interface and its derivatives."
"All instances of the STATE pattern are also instances of the STRATEGY pattern, but not all instances of STRATEGY are STATE".
Now I’m going to start reading Release It!. Ayende has nice things to say about it, so it has to be good. I’m also reading Beautiful Code which I received from my fellow Elegant Coders, but the progress is slow.
Till next time,
Jan, the bookworm
3 thoughts on “Book Review: Agile Principles, Patterns and Practices in C#”
Comments are closed.