ABSTRACT
The natural question on the minds of most engineers at this point is, How does detailed design differ from architectural design? The quick answer is that not all design concerns are architectural in nature. Architecture design is the place where engineers turn the corner from the requirements space to the design space. Software architectural designs should serve as a springboard for detailed design or implementation activities and should define clear boundaries for downstream designers and implementers. Software-intensive systems built without deliberately designed software architectures will possess emergent properties that will not be well understood because they were not designed into the system. Properties such as performance, availability, modifiability, security, and so forth must be designed into the system to meet the needs of the stakeholders who will utilize, buy, and maintain the system. If not designed into the system, understanding and fixing systemic shortcomings in these properties is often problematic, and in some cases impossible to remedy. In systems of any consequence, properties such as these cannot be achieved through detailed-level
design because they require broad coordination across most or all system elements. In cases where detailed code structures (e.g., objects, classes, functions, etc.) are designed first, the resulting system structure is large and flat, with numerous dependencies between parts of the system that are not well understood. The overall systemic properties that emerge as a result of numerous software engineers designing small pieces of the system without the framework of structure provided by an architecture design will not be well understood until the system is implemented. Architecture provides a means to partition the system into elements that can later be designed in detail. The architecture can be scrutinized and studied to expose weakness before detailed element design and implementation. Finally, the architecture can be used to guide overall construction by serving as a prescription for how the elements can be assembled, resulting in a system with predictable properties and behavior. Architectural design differs from detailed software design in terms of concerns addressed, such as:
Architectural designs address the partitioning of the system into parts or elements and inter-n action among the elements, where as detailed designs address the implementation details of the parts. Architects focus on the external properties of elements, the ensemble of elements, and system structure, whereas detailed designers focus on the internals of elements, data structures, and algorithms utilized within an element. In fact, external interactions may be hidden from the detailed designer. Architecture does not replace detail design but rather complements it by framing the work of downstream designers and implementers and guiding the integration of the elements into a system. Architectural design addresses the overall properties of a system such as performance, n modifiability, security, and others in addition to general functionality. Detailed designs are concerned with specific computational properties and functionality provided by individual elements. Architectural design is declarative. Architects partition, design, and document system ele-n ments based largely on intuition and experience because an all-encompassing, standardized, formal architecture specification language is still an aspiration rather than a reality. Indeed, a primary goal of this text is to temper and guide the hard-earned intuition of architects with design principles. Given the current state of the practice, there are no “architecture compilers” to check the syntax and semantics of architecture designs. Detailed designs are operational in nature in that they are meant to be translated directly into code, while architectural designs are meant to frame the work of detailed designers.
