Foreword by Uncle Bob
I’m dancing! By god I’m dancing on the walls. I’m dancing on the ceiling. I’m ecstatic. I’m overjoyed. I’m really, really pleased.
“Why?” you ask. Well, I’ll tell you why — since you asked. I’m happy because somebody finally read John Lakos’ book!
Way back in the ‘90s, John Lakos wrote a book entitled Large Scale C++ Software Design. The book was brilliant. The book was groundbreaking. The book made the case for large scale application architecture and made it well.
There was just one problem with John’s book. The book had “C++” in the title; and it was published just as the software community was leaping to Java. And so the people who really needed to read that book — didn’t read it.
Ah, but then the people doing Java back then weren’t reading any books on software design, because they were all 22 years old, sitting in Herman-Miller office chairs, hacking Java, day trading, and dreaming of being billionaires by the time they were 23. Oh god, they were such hot stuff!
So here we are, over a decade later. We’ve matured a bit. And we’ve failed a bit. And our failures have winnowed and seasoned us. We now look back at the wasteland of Java architectures we created and grimace. How could we have been so naïve? How could we have lost sight of the principles of Jacobson, Booch, Rumbaugh, Fowler, and Lakos. Where did we go wrong?
I’ll tell you where we went wrong. The web bamboozled us. We all got twitterpated. We thought the web was revolutionary. We thought the web changed everything. We thought the web made all the old rules irrelevant. We thought the web was so new, so revolutionary, so game changing, that we ignored the rules of the game.
And we paid. Oh God how we paid. We paid with huge unmanageable designs. We paid with tangled messy code. We paid with misguided directionless architectures. We paid with failed projects, bankrupt companies, and broken dreams. We paid, and we paid, and we paid.
It took 15 years; and we’ve just begun to realize why. We’ve just begun to see that the game hasn’t changed at all. We’ve begun to see that the web is just another delivery mechanism, no different from all the others — a reincarnation of the old IBM green-screen request/response technology. It was just plain old software after all, and we should never have abandoned the rules of the game.
Now we can see that we should have stuck to the wisdom of Parnas, Weinberg, Page-Jones, and DeMarco all along. We should never have walked away from the teachings of Jacobson and Booch. And we should have read that damned book by Lakos!
Well, somebody did read that book. And he must have read a few others too because he’s written a book that states the rules of the Java Architecture game better than I’ve seen them stated before. You’re holding that book in your hands right now. The man who wrote it is named Kirk Knoernschild.
In this book Kirk has gone beyond Lakos, beyond Jacobson, beyond Booch. He’s taken the principles of those past masters and created a brilliant new synthesis of principles, rules, guidelines and patterns. This is how you build a Java application people.
Go ahead and flip through the pages. Notice something? Yeah: No fluff! It’s all hard-core. It’s all right to the point. It’s all pragmatic, useful, necessary! It’s all about the nuts and bolts architecture of java applications – the way it should be: Modular, decoupled, level-ized, independently deployable, and smart.
If you are a java programmer; if you are a tech-lead or a team-lead; if you are an architect, if you are someone who wants and needs to make a difference on your software development team; read this book. If you want to avoid repeating the tragedy of the last 15 years, read this book. If you want to learn what software architecture is really all about: read this book!
35,000 feet over the Atlantic.
1 October, 2011.