On the cover of this book is a picture of the Øresund Bridge that connects Sweden and Denmark. It seems that all software architecture books must have a bridge on the cover, but there are some additional reasons the bridge is appropriate for this book.
This bridge replaced a ferry that I took many times as a child. I enjoy very much driving over it even after dozens of times.
On a personal note, my father was on the team that built the highest parts of the bridge.
But beyond these, the main reason is that this book is very much about bridging gaps; bridging gaps between users and developers; bridging gaps between business and software; bridging gaps between logic and storage. Bridging gaps between "DB-guys" and "OO-guys"...
I will refrain from making a joke about the Bridge pattern [GoF Design Patterns]. Hey, how geeky can a preface be?
Focus of This Book
The main focus of the book is how a Domain Model could be constructed to be clean, yet still be persistence-friendly. It shows what the persistence solution could look like for such a Domain Model and especially how to bridge that gap between the Domain Model and the database.
Put another way, my vision has been to provide a book that will put Eric Evans' Domain-Driven Design [Evans DDD] and Martin Fowler's Patterns of Enterprise Application Architecture [Fowler PoEAA] in context.
DDD might be perceived as a bit abstract. Therefore, more concrete examples are helpful regarding persistence, for example. Mine may be fairly basic, but it is a platform to start from. This book not only explains how to use the patterns, but also how the patterns are used in O/R Mappers, for example.
It has become very clear to me that "one size does not fit all" when it comes to architecture. Having said that, patterns have proven to be general enough to use and reuse in context after context.
The focus isn't on the patterns themselves, but this book uses patterns in every chapter as a tool and language for discussing different design aspects. A nice side effect is that patterns-ignorant readers will also gain some insight and interest into patterns along the way.
That also goes for TDD. Not all developers have become interested in this yet. I think it's especially common in the .NET community that TDD (just as patterns) is considered a niche technique at best, or it might even be totally unknown. Readers will learn how to apply TDD.
Why This Book?
Writing my first book [Nilsson NED] was a really tough project on top of all my other ordinary projects and obligations. I was pretty sure I wouldn't write another, but the time came when I thought I had something to say that I couldn't leave unsaid.
My change of heart started when I read two recent books that inspired me and changed my thinking. First, there was Martin Fowler's Patterns of Enterprise Application Architecture [Fowler PoEAA]. This book inspired me to give the Domain Model pattern another try after having failed with several earlier attempts.
Then I read Eric Evans' book Domain-Driven Design [Evans DDD]. This book provided me with insights about how to think and act regarding development with a strong domain focus and with a certain style of how to apply the Domain Model pattern.
Another important influence was all that I learned from teaching my patterns course over a couple of years. As I interacted with students and the material evolved, I had insights myself.
My views of DDD transformed as I worked on an ambitious (though unfortunately unfinished) open source project called Valhalla, which I developed in collaboration with Christoffer Skjoldborg. (Christoffer did by far the most work.)
To summarize all this, I felt that a book that dealt more with application than theory was needed, but one that was based on solid ground, such as the DDD and PoEAA books. "Applying" feels close to my heart because I consider myself a developer above anything else.
This book is aimed at a wide target audience. It will help if you have some knowledge of
However, interest and enthusiasm will compensate for any lack of prior experience.
I'd like to elaborate on my statement that the target audience is wide. First, we can think about the way we put people into platform boxes. The book should serve .NET people who want a more core-based approach than drag-till-you-drop (if I may use some weak generalizations). Java people should get something out of the discussions and examples of how to combine DDD and O/R Mapping.
I think the chosen language/platform is less and less important, so it feels a little strange to talk about .NET people and Java people. Let's try to describe the target audience by using another dimension. Then I think that the book is for developers, team leaders, and architects.
Choosing yet another dimension, I think there might be something in this book both for intermediate and advanced readers. There's probably also something for beginners.
Organization of This Book
The book is arranged in four parts: "Background," "Applying DDD," "Applying PoEAA," and "What's Next?"
Part I: Background
In this part, we discuss architecture and processes in general terms. There is a lot of emphasis on Domain Models and DDD [Evans DDD]. We also introduce patterns and TDD. The chapters include the following:
Part II: Applying DDD
In this part, it's time to apply DDD. We also prepare the Domain Model for the infrastructure, and focus quite a lot on rules aspects.
Part III: Applying PoEAA
In this part, we put several of the patterns in Fowler's Patterns of Enterprise Application Architecture [Fowler PoEAA] into context by discussing what we need from the infrastructure for providing persistence support to our Domain Model. We will take a look at how those requirements are fulfilled by an example tool.
Part IV: What's Next?
In this part, there is a focus on other design techniques to keep an eye on and start using. The other focus is on how you can deal with the presentation layer when it comes to bridging that gap to the Domain Model, but also how to deal with developer testing of the UI. This part is almost exclusively written by guest authors.
There are two appendices providing further examples of Domain Model styles and an overview-type patterns catalog.
Why C# for the Examples?
In no way is this a book for teaching C#. But I still need a language (or possibly several, but I have chosen one) for the examples, and that's where C# comes in.
The reasons for the choice are mainly that C# is my current main language and that most VB.NET and Java developers can read C# code pretty easily.
Regarding the version, most of the code examples work in both C# 1.1 and 2.0, but there are some rare sections that are focused on 2.0.
Topics That Aren't Covered
There are loads of topics that aren't covered in the book, but I think there are two missing topics that spring to mind. They are distribution and advanced modeling.
It was in my early plans of the book to include thorough coverage of the distribution aspects, but later on I came to the conclusion that the book would become too unfocused. Still, there is some coverage here and there.
The title of the book might suggest that you find advanced and interesting examples of modeling of certain problem areas. That's not exactly the case. Instead, the application focus is more about applying TDD and adding infrastructure to DDD.
As you can appreciate, a book project like this is hardly ever the work of only one person. On the contrary, it's a joint effort. See the list of people in the Acknowledgments section, and also remember that even more people have been involved, especially during production. That said, any errors we didn't catch before the book went to print are mine and mine alone.
I will post information of interest to readers of the book at www.jnsk.se/adddp.
Getting back to bridging gaps, the photo of the Øresund Bridge was taken by my friend Magnus von Schenck on one of his sailing trips.
Even though this book has not been as tough to write as the first one, there has been a fair amount of blood, sweat, and tears. I hope the book might save you some of that. Have fun and good luck!