Big software has lots of moving pieces. In enterprise software, this complexity is compounded due to the diversity and number of stakeholders, and the corresponding diversity and quantity of functionality.
This diversity can be a source of strength. After all, solving complex problems requires complete perspective, and collectively the stakeholders can provide it. However, success depends on the strength of the underlying structure of the system. If a system is well organized, diversity is sustainable, and complex solutions can be digitized. If not, disorganization will increase, accelerating end of life.
Patterns are one of the most important tools addressing this critical area. Patterns are recurring, mainstream solutions to common enterprise software problems, that have evolved over the history of the industry to become very powerful recommended approaches for enterprise software development. Patterns form the “frame” of enterprise software, providing a strong base to sustain growth while supporting maintainability and manageability.
Patterns make complex software products understandable. And understandability is the key to creating a strong structure. Understandability creates a common language that stakeholders can use to talk about the product without requiring a low level understanding of structures and other aspects of the coding domain.
This includes business stakeholders. Consider the integration of systems in a small company into the much larger systems of an acquiring enterprise. Technical language about low level details including protocol, object hierarchies, schemas, namespaces, networks, etc., is ineffective. But if we describe the overall approach as a Delegate Pattern, we then provide a clear description and characterization leading to a very powerful picture and roadmap for the integration going forward.
Another essential benefit is that software developers and those involved as direct contributors have the ability to discuss very complex concepts in an organic, highly visual style. Context Object, Intercepting Filter, and Factory provide clear indication of function and purpose. In other words, strong encapsulation, a primary design goal of every project and a key to sustainability.
Because the patterns result in code structures that are well encapsulated and isolated, technical teams don’t need to describe individual code components and relationships during communication. The identification of the pattern provides context to the domain problem space, to the component relationships, and to the dynamic behavior of the system.
Software patterns convey meaning between the development environment and the business domain. Patterns convey meaning to business stakeholders just as they convey meaning to code contributors. For example, the Delegate pattern conveys meaning that classes in one project have an awareness of classes in another project via a specific area of code that shields other areas from direct dependency. From a business perspective, Delegate implies a demarcation of ownership of systems, a distribution of responsibilities, and a way that one group can quickly integrate to the services provided by another. Delegate implies an organizational relationship. The same is true of many other patterns, such as Presentation Tier, Business Object, and Web Service Broker.
Principal references for enterprise software patterns include:
Design Patterns: Elements of Reusable Object-Oriented Software (Gamma, Helm, Johnson, Vlissides, 1995): This book is a standard reference and is the basis of modern practice. The authors are known collectively as the Gang of Four (GoF). The patterns identified in this work are building blocks of many more complex patterns.
Core J2EE Patterns: Best Practices and Design Strategies (Alur, Crupi, Malks, 2003) This book extends the work of the GoF. It is the standard reference for those developing software using Sun and Oracle, and other enterprise java technologies.
Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions (Hohpe, Woolf, 2004) This book outlines new, highly complex patterns that are largely the result of applying software patterns to the new, larger patterns that are possible using enterprise solutions. Despite the message oriented reference, the book applies well to all general business software theory.
Agile Principles, Patterns, and Practices in C# (Martin, Martin, 2007) Demonstrating implementations patterns specific to C#, this book extends important work in describing the generalized importance of patterns to enterprise software systems development.