(formerly known as Information System Architecture)
Last Significant Update: June 2002One of the recurring themes of my career is how to structure sophisticated enterprise applications, particularly those that operate across multiple processing tiers. It's a subject I discussed briefly in a chapter in Analysis Patterns, and one that I looked at in more depth in many consulting engagements. In the last few years I've been doing a lot of work with Enterprise Java: but there's no surprise that many of the ideas and patterns involved are exactly the same as those that I've run into earlier with CORBA, DCE, and Smalltalk based systems.
This notion of common lessons has been amplified by my collaborations with developers at ThoughtWorks. A lot of old time developers at ThoughtWorks did a lot of work with Forte - which was a sophisticated distributed environment. Others have background in CORBA and DCOM.Again we see common lessons and patterns that are relevant whatever the technological platform.
So I decided to take advantage of this knowledge to capture and write down some of these ideas. Most of the writing here is mine, but the ideas come from many ThoughtWorkers, although Dave Rice and Matt Foemmel have contributed a particularly large amount of information. This material is the content of my next book: Patterns of Enterprise Application Architecture, which is due to appear at OOPSLA 2002.
As I've been writing this book, I've been putting information on these web pages, both to give readers an idea of what I'm working on, and to solicit feedback on the evolving book. In June 2002 I sent my final draft to Addison-Wesley and it was "released to production". That means the hard intellectual work is done, we are now in the process of copy editing, book design, indexing, and the other tasks of production - most of which is handled by Addison-Wesley.
AW have graciously allowed me to keep these pages up until the book is released in November. Most of the text here corresponds to the second draft that was sent out for review in April, not the final draft for the book. (It seems that if you write a book and make it available on the web, people complain that the book is only a copy of the free web pages!) So the final pages will be much neater in the book itself. However we decided to include in this version some of the newer material on offline concurrency - most of which was contributed by my colleague David Rice. The book will include code examples for the offline concurrency patterns. David has played a big part in putting together this section and he has turned into a significant contributor - contributing about 10% of the book.
The final book will also include two further guest pattern descriptions:
When the book appears in print I'll bring up a new site with abbreviated versions of the patterns, similar to the way I did for the refactoring book. I haven't yet decided how that will be done, but I will certainly change the URLs at that point.
Thanks to the many of you that have given me comments on the book as it was in the works. Keep your eyes open for my next writing projects, whatever they turn out to be.
The book is organized in two parts. The first part is a set of narrative chapters that can be read from start to finish. In the preliminary book designs these come to around 100 pages. The second part is a reference section of the patterns themselves. The idea is that the chapters discuss the general issues and summarize the patterns that are relevant - then the patterns chapters capture the detail.
As I've been working on this during 2001 I was doing it under the title of "Information Systems Architecture". As we were working on the book proposal for Addison-Wesley, the marketing folks there said that "information systems" was a rather old fashioned term, so instead we chose the term "enterprise application". (I have no qualms about selling out, providing the price is right.)
Here's a list of the major updates to this paper