- Essential Activities Overview
- Architectural Decisions
- Quality Attributes
- Technical Debt
- Feedback Loops: Evolving an Architecture
- Common Themes in Today's Software Architecture Practice
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
Common Themes in Today’s Software Architecture Practice
We end this chapter with views on key trends that we see in software architectural practice. We provide only a brief overview of each topic and highlight relevant points. A detailed overview of these topics is out of the scope of this book.
Principles as Architecture Guidelines
Principles are one of the most widely used type of guidelines by architecture practitioners. We define a principle as
A declarative statement made with the intention of guiding architectural design decisions in order to achieve one or more qualities of a system.30
A small set of key principles is extremely valuable if the principles are fully embraced by a team and influence the decisions they make. Principles are very valuable in communicating and negotiating decisions with key stakeholders. They allow us to have an effective dialogue highlighting future problems that can occur if the principles are violated.
For example, a team might decide to build a user interface (UI) quickly by direct access to the backend database to meet a deadline. In doing so, the team has violated the principle of “integration through APIs.” Bypassing the API will tightly couple the UI to the backend database and make future challenges in both components more difficult. Common awareness of such a principle up front will make the conversations with stakeholders much easier. They can still make the decision to go forward with the direct access route but with the understanding that they are building technical debt for their software product.
A common bad practice in the industry is to create a complete set of principles that cover all eventualities. This usually results in a long list of principles written in excruciating detail—and usually requiring lengthy editorial efforts. However, quite often, these principles end up not being embedded in the thought process of the teams that actually make the decisions.
Another challenge we have seen is how principles are written. At times, they are truisms—for example, “all software should be written in a scalable manner.” It is highly unlikely that a team would set out to develop software that is not scalable. The principles should be written in a manner that enable teams to make decisions.
As stated earlier, the most valuable principles are those that a team live and breathe while they develop a software system and make architectural decisions. They are normally a handful of basic statements.
A simple but good example for such an architectural principle is “Buy before build.” It has the following characteristics that make a good principle:
Clear: Principles should be like marketing slogans—easy to understand and remember.
Provides guidance for decisions: When making a decision, you can easily look to the principle for guidance. In this instance, it means that if you have a viable software product to buy, you should do that before building a solution.
Atomic: The principle does not require any other context or knowledge to be understood.
Team-Owned Architecture
A key benefit of agile practices has been the focus on cross-functional and empowered teams. Effective teams can create tremendous value to an organization. It can be said that, while organizations used to look for the star developers who were multiple times more effective than an average developer, they now recognize the need for building and maintaining effective teams. This does not mean that star developers and engineers should not be acknowledged but that they are hard to find, and building effective teams in the long run is a more achievable model.
In that context, architecture activities become a team responsibility. Architecture is increasingly becoming a discipline (or skill) rather than a role. We can highlight the key skills required for conducting architectural activities as follows:31
Ability to design. Architecture is a design-oriented activity. An architect might design something quite concrete, such as a network, or something less tangible, such as a process, but design is core to the activity.
Leadership. Architects are not just technical experts in their areas of specialization: they’re technical leaders who shape and direct the technical work in their spheres of influence.
Stakeholder focus. Architecture is inherently about serving a wide constituency of stakeholders, balancing their needs, communicating clearly, clarifying poorly defined problems, and identifying risks and opportunities.
Ability to conceptualize and address systemwide concerns. Architects are concerned about an entire system (or system of systems), not just one part of it, so they tend to focus on systemic qualities rather than on detailed functions.
Life cycle involvement. An architect might be involved in all phases of a system’s life cycle, not just building it. Architectural involvement often spans a system’s entire life cycle, from establishing the need for the system to its eventual decommissioning and replacement.
Ability to balance concerns. Finally, across all these aspects of the job, there is rarely one right answer in architecture work.
Although we state that architecture is becoming more of a skill than a role, it is still good to have a definition of the role. As mentioned earlier, in The Mythical Man-Month,32 Brooks talks about the conceptual integrity of a software product. This is a good place to start for defining the role of architects—basically, they are accountable for the conceptual integrity of the entity that is being architected or designed.
Continuous Architecture states that an architect is responsible for enabling the implementation of a software system by driving architectural decisions in a manner that protects the conceptual integrity of the software system.
In our first book, Continuous Architecture,33 we provide a detailed overview of the personality traits, skills, and communication mechanisms required for the role of an architect (or to be able to do architectural work).
Models and Notations
Communication is key to the success of architectural activities. Unfortunately, in the IT world, we spend a long time discussing the exact meaning of different terms (e.g., use case vs. user story), notation, and architectural artifacts (e.g., conceptual vs. logical vs. physical architectures).
One of the most successful attempts at creating a common notation in the software industry was the Unified Modeling Language (UML), which became an OMG standard in 1997.34 In the late 1990s and 2000s, it felt as though UML was going to become the default standard for visualizing software. However, it has been waning in popularity in recent years. We are not exactly sure why this is, but one factor is that software engineering is a rapidly expanding and very young profession. As a result, most formalisms are overpowered by new technologies, fads, and ways of working. You can say that the only relevant artifact for developers is code. Any other representation requires extra effort to maintain and therefore becomes quickly outdated as a development team evolves the system.
Another attempt at creating a visual language for software is ArchiMate, which was originally developed in Netherlands and became an Open Group standard in 2008.35 Unlike UML, which is system focused, ArchiMate attempts to model enterprise architecture artifacts.
Although UML has gained much larger traction, there is still not an agreed-upon notation to communicate software and architecture artifacts in the industry. Paradoxically, UML and ArchiMate can make communication harder because few developers and stakeholders understand them well. Most technologists and teams normally end up drawing freeform diagrams to depict the architecture. This is a major challenge because communication is key to the success of developing and maintaining a system or enterprise architecture.
A more recent attempt at addressing this gap is the C4 model that was created by Simon Brown.36 This is an interesting approach that addresses some of the challenges with more formal notations. As a philosophy, it tries to create an approach whereby the representation of the architecture is close to the code and can be used by developers.
From a Continuous Architecture perspective, we can make the following observations. As stated at the beginning of the chapter, the core elements required to drive a sustainable architecture are focus on quality attributes, architectural decisions, technical debt, and feedback loops. However, effective communication is critical: We cannot overcommunicate! As a result, utilizing a common language to define and communicate architectural artifacts just makes common sense. That the industry has still not found its way does not mean you should not strive for this in your area, be it a system, division, or enterprise.
Although we do not recommend a certain notation, that does not mean graphical communication and effective modeling are unimportant. Following are a few key characteristics that should be considered in determining your approach:37
Simplicity: Diagrams and models should be easy to understand and should convey the key messages. A common technique is to use separate diagrams to depict different concerns (logical, security, deployment, etc.).
Accessibility to target audience: Each diagram has a target audience and should be able to convey the key message to them.
Consistency: Shapes and connections used should have the same meaning. Having a key that identifies the meaning of each shape and color promotes consistency and enables clearer communication among teams and stakeholders.
Finally, note that for the purpose of this book, we used the UML-like notation to reflect our case study.
Patterns and Styles
In 1994, the Gang of Four—Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides—published their seminal book, Design Patterns.38 In this book, they identified 23 patterns that address well-known challenges in object-oriented software development. Almost as important as the solutions they provided is that they introduced the concept of the design pattern and defined a manner to explain the patterns consistently.
Several subsequent publications have expanded the pattern concept to different areas, from analysis to enterprise applications. More important, software designers were able to communicate with each other by referring to design patterns.
The challenge we see in the industry is that most technologists do not understand patterns or choose not to use any rigor when using them. This is particularly true when looking at tradeoffs as a result of using a pattern. Nonetheless, there is significant value in having a common pattern library within the organization. The more the patterns can be demonstrated in code or running software, the better.
Architecture as a Flow of Decisions
As mentioned, the key unit of work of architecture is an architectural decision. The topic of architectural decisions collectively defining the architecture has been prevalent in the industry for some time39 and is becoming even more prominent in today’s world. If you use a Kanban board to combine the view of architectural decisions as a unit of work with common software development practices focused on managing tasks, you can easily say that architecture is just a flow of decisions. Figure 2.12 depicts a simple Kanban board setup that can be used to track the architectural decisions.
)
Figure 2.12 Architectural decision Kanban board
This example is helpful to manage architectural decisions as a flow from an execution perspective. We recommend not only documenting architectural decisions but defining the architectural decisions you need to make up front and identifying the dependencies among them.