Chapters
Part 1 – The Case for Modularity
Chapter 1 – Introduction
Chapter 2 – Module Defined
Chapter 3 – Two Facets of Modularity
Chapter 4 – Architecture and Modularity
Chapter 5 – Taming the Beast
Chapter 6 – Realizing Reuse
Chapter 7 – Reference Implementation
Part 2 – Modularity Patterns
Base Patterns
ManageRelationships – Design module relationships. (Draft 1 complete)
ModuleReuse – Emphasize reusability at the module level. (Draft 1 complete)
CohesiveModules – Create cohesive modules. (Draft 1 complete)
ClassReuse – Classes not reused together belong in separate modules.
Dependency Patterns
AcyclicRelationships – Module relationships must be acyclic. (Draft 1 complete)
LevelizeModules – Module relationships should be levelized. (Implementation, Consequences, Sample code, and Wrapping Up needed)
PhysicalLayers – Module relationships should not violate the conceptual layers. (Draft 1 complete)
ContainerIndependence – Modules should be independent of the runtime container. (Consequences, Sample code, and Wrapping Up needed)
IndependentDeployment – Modules should be independently deployable units. (Draft 1 complete)
CollocateExceptions – Exceptions should be close to the classes that throw them. (Implementation, Consequence, Sample code, and Wrapping Up needed)
Usability Patterns
PublishedInterface – Make a modules published interface well known. (Draft 1 complete)
ExternalConfiguration – Modules should be externally configurable. (Consequences, Sample code, and Wrapping Up needed)
ModuleFacade – Create a facade serving as a coarse-grained entry point to the modules underlying implementation. (Implementation, Consequence, Sample code, and Wrapping Up needed)
Extensibility Patterns
StableModules – Modules heavily depended upon should be stable.
AbstractModules – Depend upon the abstract elements of a module. (Sample code needed)
ImplementationFactory – Use factories to create a modules implementation classes. (Implementation, Consequences, Sample code, and Wrapping Up needed)
SeparateAbstractions – Separate abstractions from the classes that realize them. (Sample code, Wrapping Up needed)
Utility Patterns
LevelizedBuild – Execute the build in accordance with module levelization. (Draft 1 complete)
TestModule – For each module, create a corresponding test module that validates it’s behavior and illustrates it’s usage. (Draft 1 complete)
Appendices
Appendix A – The SOLID Principles of Class Design
Appendix B – OSGi Reference Implementation
Appendix C – The Future of Modularity: OSGi
Appendix D – Modularity in Other Languages: Ruby, Python, C#, Groovy