Finally someone has put the most important software architecture practices into words. Within this book lies the concepts that are the heart of true agility. Without a modularized architecture, any decent size project can not achieve agility. I have seen so many agile projects flop because they ignored architecture, in particular they ignored modularization.
This book also provides the keys concepts needed to ensure modifiability, the number one quality attribute for any architecture. It drives home the importance of physical design. An often overlooked aspect of designing modularity, yet it is the most important. Good logical design does not really matter if you have a poor physical design.
The book is broken down into 3 parts and includes an appendix that gives an overview of the SOLID Principles.
Part 1 The Case for Modularity introduces modularity and how it relates to complexity, architecture, SOA, Reuse, Design Rot, and Technical Debt. Part 1 chapters include Module Defined, Two Facets of Modularity, Architecture and Modularity, Taming the Beast, Realizing Reuse, Modularity and SOA, and Reference Implementation. The last chapter Reference Implementation shows how to apply several of the patterns through a series of refactorings applied to a sample architecture.
The sample did not include OSGi. The reason the author left OSGi out of the picture is that you do not need it to design proper modularized architecture. It is a tool to enhance the runtime experience, not the design experience. I was glad the author took this approach.
Part 2 of the book is the pattern's catalog. I have listed the chapter and the patterns included below.
-Base Patterns: Manage Relationships, Module Reuse, and Cohesive Modules
-Dependency Patterns: Acyclic Relationships, Levelize Modules. Physical Layers, Container Independence , and Independent Deployment
-Usability Patterns: Published Interface, External Configuration, Default Implementation, and Module Facade
-Extensibility Patterns: Abstract Modules, Implementation Factory, and Separate Abstractions
-Utility Patterns: Collocate Exceptions, Levelize Build, and Test Module
The pattern form (sections of the patterns) are Pattern Name, Pattern Statement, a Sketch, Description, Implementation Variations, Consequences, a Sample, and a Wrapping Up section.
Part 3 of the book provides a introduction to OSGi within several contexts. Part 3 chapters include Introducing OSGi, The Loan Sample and OSGi, OSGi and Scala, OSGi and Groovy, and the Future of OSGi.
The author has put up a site that includes a pattern catalog on his site Java Application Architecture: Modularity Patterns.
The author has all the source code available on github. It is organized by sample/pattern name. The code is very well organized and usable.
This book is not only for Java developers. It is a great book for anyone developing object oriented systems. It easily translates to .NET. I was constantly drawing parallels with my experience using PRISM to develop modular .NET applications.
This is a must read for every architect and developer interested in doing architecture right. The concepts in this book will take you to a new level of quality with your architectural designs. |
 
Java Application Architecture: Modularity Patterns with Examples Using OSGi |
Subscribe to JAVA Developer's Journal Email News Alerts
Subscribe via RSS
