Task: Refine the Architecture
Refine the architecture to an appropriate level of detail to support development.
Disciplines: Architecture
Relationships
RolesPrimary Performer: Additional Performers:
InputsMandatory: Optional:
  • None
Outputs
Main Description

This task builds on the work performed during Task: Outline the Architecture. The objective is to make the architectural decisions necessary to support the objectives for the current iteration of the project. The decisions taken as part of this task are concrete and unambiguous. They are captured in the Architecture Notebook and communicated across the team.

This task is applied iteratively; iterations after the first will need to take account of the Design and Build products that have been developed so far.

Steps
Identify architecturally significant design elements

Refine the key abstractions into concrete design elements (such as classes and subsystems) and provide at least a name and brief description for each. Add them to the Design.

Refine architectural mechanisms

Refine each prioritized architectural mechanism into a design state (see Concept: Architectural Mechanism). 

Review the objectives of the current iteration to identify which mechanisms actually need to be delivered in software. Work with the Developer to those refine mechanisms into an implementation state.

Map the software to the hardware
Map the architecturally significant design elements to the target deployment environment. Work with hardware and network specialists to ensure that the hardware is sufficient to meet the needs of the system; and that any new hardware is available in time.
Define development architecture and test architecture

Ensure that the development and test architectures are defined. Note any architecturally significant differences between these environments and work with the team to devise strategies to mitigate any risks these may introduce.

Update the architecture

Update the Architecture Notebook to reflect any changes made during development.

Validate the architecture

Make sure that the architecture supports the requirements and the needs of the team.

Development work should be performed to produce a Build that shows that the software architecture is viable. This should provide the definitive basis for validating the suitability of the architecture. As the software should be developed iteratively, more than one increment of the build may be required to prove the architecture. During the early stages of the project it may be acceptable for the software to have a incomplete or prototypical feel, as it will be primarily concerned with baselining the architecture to provide a stable foundation for the remaining development work.

Communicate decisions

Ensure that those who need to act upon the architectural work understand it and are able to work with it. Make sure that the description of the architecture clearly conveys not only the solution but also the motivation and objectives related to the decisions that have been made in shaping the architecture. This will make it easier for others to understand the architecture and to adapt it over time.

Key Considerations

The architect should perform this task through collaboration with the whole team to promote consensus and a common understanding of the overall solution. The architect should be working to coordinate and guide the technical activities of the team, rather than seeking to do all the work alone. The architect should place emphasis on involving the developer(s) throughout this task.

More Information