will almost certainly improve the quality of your work and save development time.
A quick browse through C Vu and Overload shows that programmers are using some very advanced features of their languages in a vast range of application types. However, if we are honest, many of us spend a large proportion of our working hours building applications based around relational database systems. This may not be the most fashionable kind of programming, but it is not without its challenges. Although many books detail a particular database system or explain how to get started with SQL, this book is a comparative rarity, being concerned with how to write real (not toy) code in enterprise complexity systems that elegantly bridges the gaps between databases, forms, reports and proper object-oriented coding techniques.
The book takes the pattern perspective, popularised by the seminal Design Patterns book by Gamma et al. (often referred to as the Gang of Four or GOF), where the common features of real code are abstracted into prose, UML diagrams and examples, and named as a pattern. The book's examples are written in either Java or C#, but are straightforward enough that intermediate to advanced C++ programmers should have little problem making sense of it. Most of the advice given in the book translates equally well into C++, although there are some areas that are platform specific.
In terms of scope the book does not cover replicated or distributed systems, opting to give more thorough coverage to the areas of user interface design, domain modelling and interfacing with backend databases. Perhaps the most taxing area addressed is concurrency, but primarily this is looking at the concurrency management systems that database systems tend to provide, such as transactions.
Anyone who has read the GOF work will find the layout of the majority of this book very familiar: the inside front cover summarises the patterns covered, the patterns are grouped into convenient categories, and each pattern is described over the course of several pages, together with copious examples. The inside back cover provides a helpful "cheat sheet" which boils down the mechanics of choosing an appropriate pattern to the answering of a small number of simple questions. The biggest difference between Fowler's book and its spiritual predecessor is that here you will find more discussion of how the patterns fit together to form a complete application. I found this a welcome change of emphasis: this practical slant makes the application of the detailed patterns more straightforward.
My only real criticism is the level that some parts of the book are pitched at. Relatively simple ideas are explained in overlong detail. This complaint has a positive flipside of course: this book is very clear and explanations are never rushed. Those who are veterans of a lot of well-structured database-oriented work, and are therefore already familiar with many of the ideas expressed, may well wish for an abridged version.
There is no abridged version of course, nor have I ever read any other book on this subject that does the job better. It's a solid read, I could not find any technical faults and it has good index and further reading sections. Although there is no "wow!" factor to this book, it would be unrealistic to expect one given the subject matter. If you are in the intended audience, reading and understanding Patterns of Enterprise Application Architecture will almost certainly improve the quality of your work and save development time. Therefore this book is recommended.