Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) [Englisch] [Taschenbuch]

The subtitle of this book might as well be Architecture and Design for the Paranoiac. The book lays out some critical aspects to creating and rolling out stable software systems. It's directed to those working in the enterprise arena and need the utmost from stability, capacity, and overall design. Nygard's definition of "enterprise" is somewhat broad in that he considers "enterprise" to be any system providing mission-critical support to a business. Regardless of how you define your particular software, I'm sure you'll find something useful in this book.

Nygard presents the book from an anti-pattern/pattern approach: he uses case studies to illustrate how critical errors in design or implementation (anti-patterns) have caused disasterous outages. He then moves on to show how application of solid design patterns could have avoided the problems. He also spends some time going in to detail on how some of the outages have happened, including brief discussions on network packet captures and decompiling third party drivers.

There are a lot of solid fundamentals in the book: dealing with exceptions at system integration points, thread synchronization, avoid rolling your own primative feature libraries such as connection pools, and make sure to test third-party libraries which play critical roles. The general approach of discussing anti-patterns followed by patterns is also a nice way of putting forth the material.

There are a lot of more complex bits covered as well, such as thinking ahead on how you'll deal with bots and crawlers, avoiding AJAX overkill, designing ahead for and using session. I also liked that Nygard talks about the importance of involving the customer in decisions on thresholds and other critical boundaries.

Despite the great content, there is a blistering flaw, IMO: A complete lack of solid implementation specifics. Nygard doesn't provide much detail at all on actual implementation of the critical patterns he espouses, nor does he point you in the direction of other sources of information. For example, the Timeout pattern is held up as a vital aspect in many parts of the book; however, there's no practical detail on actual code to implement a Timeout, and there's only one reference to a practical implementation. The Circuit Breaker pattern, central to many of Nygard's architecture assertions, doesn't have any code or a single reference to other material where you can find implementation details.

While I find that a major gap in the book, otherwise I think it's a solid addition to one's bookshelf. The writing style's very nice, his writing voice is light and concise, and the summary bullets in each section ("Remember This") are of great value. Additionally, there are plenty of references to other useful works. (Just not for the patterns I complained about above.)

This book is intended for architects, designers, and developers of software on which a business depends and whose failure costs money. The tone is informal and the style is easily read. Some architects may wish for more rigor and consider it too easily read but they might still benefit because it contains quite a bit of wisdom earned by experience.

The book discusses issues of uptime, failure, and maintainability with examples drawn from the author's experience and from other industries. Making the point from more than one point of view serves to drive it home.

This is not a programming book but the illumination of a problem is often improved by a snippet of code. The code is Java and is easily read by anyone familiar with programming. Having some familiarity with multi-threaded programming in following the explanations and their examples will make them a little easier to read but is not necessary to get the point. (Even if you truly have no knowledge of Java, looking up JDBC, JVM, EJB, JSP, J2EE, log4j, and servelet will not be much effort because not much knowledge of them is required.) The examples emphasize web applications because, I suppose, that's the environment most vulnerable to huge capacity requirements, more complex environments, more numerous causes of failure, and failures that are more visible.

The author's analysis of the problem space has two dimensions --- stability and capacity --- in which a given enterprise system can be located. The analysis also has two categories: general design and operations.

Stability and Capacity

A given coordinate, on the stability axis, for example, implies the presence and absence of features that improve and diminish stability. A feature that contributes to stability is the use of timeouts and one that detracts is the presence of many interfaces to other systems. The author identifies 8 such stability patterns that contribute to stability and 11 antipatterns that detract from it. Capacity has 4 patterns and 10 antipatterns.

General design and Operations

These two categories are less structured than those of stability and capacity.

"General design" contains advice about networking (integration with local and remote servers), security (principle of least privilege and managing passwords), availability (load balancing and clustering), and administration (QA vs production environments, configuration files, anticipating failure in start-up and shut-down, and an administrative interface).

"Operations" contains advice about recovery-oriented computing (surviving failure by restarting components, et al.), transparency (allowing a view of the system's internals), and adaptation (managing change).

The idea of patterns from software development is raised from the level of programming to the level of systems. I might have called them, for example, stability patterns and anti-stability patterns but the author's meaning is clear enough.

At the end of each pattern and antipattern section is a short and effective summary that begins with "Remember this". The design chapter has a summary and the operations chapter has two section summaries. The author clearly has in mind the reader's take-home lesson and the possibility that the book may be skimmed to reread a section. The book is cross-referenced, forward and back -- if an idea of current relevance is explained elsewhere in more detail, the page number is noted. For example, if an antipattern has a countermeasure identified by a pattern, then the relationship is noted with a page number.

Implementing some suggestions may make the QA phase of testing easier by making diagnosis and (white box) testing itself easier. If you want to design your software to be more reliable and easier to maintain after the QA phase of testing, then this book is for you.

It is the decisions that you make during development that will affect the quality of your release. Release It!: Design And Deploy Production-Ready Software was written to help you understand what causes good software to go bad, and to show you how to take control of the situation when it happens.

Release It! was written for architects, designers, and developers of enterprise class software systems. This includes applications, websites, web services, and EAI projects. According to the author, "enterprise class" means if the software stops, the company loses money.

All in all I found Release It! a very easy read. While the author comes from a Java and Unix perspective, the book's focus is generally neutral and grounded toward concepts and techniques that are portable across all platforms and technologies. Each of these case studies is based on real events, only the names (of people, companies, methods, and classes) have been change to protect the innocent. The detail of the information is very helpful, giving insight into the problems and their solutions.

My full review can be found over at Blogcritcs, but if you are looking for a better way to deliver your product, a way to avoid the traps and pitfalls, then Release It! is a good place to begin.