Summary

Attribute-Driven Design (ADD) is a methodology for creating software architectures that emphasizes the importance of quality attributes in the design process.

Abstract

Attribute-Driven Design (ADD) is a systematic approach for designing software architectures, particularly for greenfield projects. It involves a thorough review of inputs such as quality attributes, system scope, interfaces, design goals, functional requirements, constraints, and concerns. The process is iterative and incremental, with each iteration focusing on refining specific architectural elements and applying design concepts to achieve desired quality scenarios. The steps include establishing iteration goals, selecting elements for refinement, choosing design concepts, instantiating architectural elements, sketching views, and performing analysis to ensure the design meets the necessary criteria. The methodology is detailed in the fourth edition of "Software Architecture in Practice," which provides theoretical background and case studies to guide software architects.

Opinions

The author suggests that ADD is particularly suitable for greenfield projects, implying its effectiveness in new developments rather than existing systems.
The importance of quality attributes is emphasized, indicating that they are critical drivers in the architectural design process.
The iterative nature of ADD is highlighted, with the understanding that new inputs may lead to additional iterations, suggesting a flexible and adaptive design approach.
The author implies that the decisions made in step 4, choosing design concepts, are crucial and have a significant impact on the architecture's outcome.
Documenting decisions and sketching views (step 6) is presented as a vital step for maintaining a record of architectural choices and facilitating communication among stakeholders.
The author recommends "Software Architecture in Practice" as a valuable resource for software architects, indicating its relevance and utility in the field.
The author invites readers to connect on social platforms, suggesting a willingness to engage with the community and discuss Software Engineering topics further.

Designing Software Architecture: Attribute-Driven Design

Designing specific Architecture for a software system, especially for greenfield projects, requires solid planning and preparation. There are plenty of methodologies that are used by experienced Software Architects for designing greenfield projects, one of which is Attribute-Driven Design.

Attribute-driven design is a methodology to create software architectures that takes into account the quality attributes of the software.

Prior to starting architecture sketch, the one should evaluate the quality attributes such as: the scope of the system, internal/external interfaces, the design purpose, functional requirements, quality scenarios, constraints and concerns. These are all driving forces for further steps of ADD. Architectural Decisions in ADD are made in iterative and incremental manner.

Step 1: Review Inputs

Before starting an implementation, above mentioned driving forces should be analyzed and prioritized. According to these drivers further steps 2 to 7 should be done on iterative manner. So with each iteration there might new review inputs which would lead to a new iteration.

Step 2: Establish Iteration Goal

First implementation step of ADD is defining a goal of iteration. So based on Review inputs, Software Architect should define short-term target such as: achieving particular quality scenario of a specific use case.

Step 3: Choose One or More Elements to Refine

According to the previously defined short-term target Software Architect might choose specific building block/interface and do a refactoring/refinement process on it. This might later be potentially divided into more fine-granular blocks.

Step 4: Choose One or More Design Concepts

This step is the most difficult one, because decisions that Software Architect will make here is of enormous importance. There are plenty of design patterns, design tactics/techniques, especially in cloud native environments. Software Architect might also decide to create a prototype as a proof of concept before applying it fully to the system.

Step 5: Instantiate Architectural Elements

Once the one chooses which Design Concepts to apply, next step is starting to instantiate this design manner on a chosen refined building block.

Step 6: Sketch Views

This is the step where the Architect documents, sketches the decisions that were made in current iteration round. This also archiving obsolete, dissolved systems/building blocks.

Step 7: Perform Analysis

With this step you analyze the work that was done in order to avoid rework and unhappy stakeholders. In case of rework, Software Architect might need to go back to step 2 and start over. If everything is fine, the next driver force will be chosen and new iteration from step 1 will be started.

For more information please refer to the fourth edition of Software Architecture in Practice that recently just came out. This is a perfect match especially for Software Architects with lot us of theoretical background and cases studies to master the art of architecture in software systems.

If you are interested in more Software Engineering topics take a look at my other articles.

Relevant Articles:

P.S. You can connect with me on twitter or linkedin.