This is a FANTASTIC book. But it doesn't seem that way when you first start reading it. The beginning conceptual chapters are rather basic, though I suspect that many of the blase reviews are written by people with many years in the field who don't get maximum value out of them. The first 2 sections are actually optimal for developers just out of school/just beginning to write "enterprise grade systems" within their first 6-18 months. For people with more experience, it will be mostly review...though the sections on stateful versus stateless interface design are interesting.

Where this book really shines, however, is the "Interfaces in the Real World" section. The systems built have been described by some reviewers as "toys"...and yet I've found myself implementing some version of a "WebConglomerator" or "Link analyzer" in company settings since 2006. I'm actually implementing a glorified Service Registry right now that has absolutely stymied some of my colleagues to design...and this book makes it look ridiculously easy.

What makes these examples truly compelling, however, is that they are CLEAN. These designs are FANTASTIC. If you really know how to think in interfaces, it becomes obvious to you how you can design these systems using TDD/BDD and implement in such ways that it's easy to switch from a Gson-based parser to Jackson, XML to YAML, etc etc. These are actually fantastic case studies in how to build frameworks masquerading as toy problems.

The last chapter on Design Patterns is succinct, but far more interesting than superficially thought. Encapsulating native collections with your own types is something developers everywhere just don't do enough of, and the benefits become fantastically clear with the BUILDER-esque chaining implementing AND and "merge" implementing OR criteria. I had never even thought of something like that. The treatment of FACTORY METHOD and discussion of PROXY vs. DECORATOR does a nice job of showing different options, and reinforcing the differences between the intents in the patterns.

...basically, anyone trying to be a Real Software Architect should read this short book on a Saturday morning, then think hard about it. It's got a lot of great content, in a very digestible and well-written format.

The book explores different ideas on how to structure your code. While some chapters are interesting, the information provided is repetitive and there are parts that are irrelevant. I'll definitely go back to some parts of this book that provide good advice but i won't read it again or recommend to anyone.

The book didn't really teach me anything I didn't already know. In fact, I'm not sure how well it would have taught me had I not already understood all the concepts beforehand.

A little dated, in terms of specific implementation technologies (CORBA, anyone?), which should be expected for a tech book published back in 2007, but the principles are still perfectly applicable to the development challenges of 2021.

In fact, instead of being a distraction, I would say that seeing the mapping of these principles to earlier technology implementations is actually helpful, in the sense that it really points out that the high-level concepts can outlive the implementation choices of a given time period.