Architecture Governance 101

What is Architecture Governance?

Enterprise Architecture Governance is the structure by which an enterprise defines appropriate strategies and ensures development alignment
with those strategies.

Why is it needed?

Architecture Governance is required because of either one or multiple factors listed below

1. Avoiding structural erosion of Architecture with time- When there are more than 2 people working on a system, the architecture tends to
erode since all the developers can rarely be brought on the same page. This is also true when new people start working on an existing
system.
2. Controlling Technical Quality of the Software – Bad architectural design and code can introduce architectural smells. Controlling the
architecture ensures that logical architecture is implemented as planned, a tab can be kept on quality aspects like cyclic dependencies,
code complexity etc.
3. Keeping a tab on all -ilities – Measure the quality of a design in terms of its extensibility, reusability, and maintainability to manage
package dependencies effectively.
4. Validating compliance to set rules – Every project defines a set of rules that all developers should adhere to.These rules can be coding
conventions, naming conventions or at a higher level architecture decisions or best practices.

Driving Factors for your organization to enforce Governance

1. All developers are on the same page with respect to Architectural Guidelines
2. Product Quality is optimal with

a. No cyclic dependencies
b. Separation of concerns is honoured
c. Changes do not impact unrelated components – The system should not be fragile, we should be able to ensure that the caller
and callee relationship can be controlled and validated so that changes in one part of the system do not affect other parts.
d. Independent lifecycle for different projects – It should be possible to release a project independent of unrelated projects.

How to enforce Architecture?

For enforcing architecture, we would recommend the use of automated tools along with manual verification. Automatically validating the
architecture with every build would help ensure the compliance and taking corrective action at very early stages.

The following tools provide a capability to be integrated with the build process.

• Architecture Rules -Build time architectural checking. External configuration of rules. Maven multi project compliant.
• SonarJ – Helps to check structural erosion and provides code metrics (Commercial)
• Macker – Build time architectural code checking. Rules externally configurable.
• Japan – Provides architectural checks as an IDE plugin. Rule files can be externally configured.
• JDepend – Quality metrics for each Java package. Maven plugin available.
• Classycle – Similar to JDepend. Analysis at package level and class level.
• Lattix – Shows the relationship between packages using the Dependency Structure Matrix (DSM) for a highly scalable representation.
• (Commercial)
• Structure 101 – Solution for understanding, controlling and tracking evolving software architecture.

In the next post we will look at the Architecture Governance Lifecycle.