Validating Enterprise Architectures

Abstract

Enterprise system architectures are the corner stone of major IT investments and as such have a long term impact on a corporation’s bottom line. Acceptance of the enterprise system architectures by all stake holders is vital to the successful implementation of the architecture. Validation of system architectures with stakeholder expectations is a best practice often followed by good enterprise architects.

This white paper outlines the essential aspects of the validation process and provides a justification for why enterprise architects should form the habit of validating the architectures they build or define. This white paper also suggests some specific techniques for conducting validations of the essential aspects of enterprise system architectures.

A side objective of this white paper is to stimulate discussions and sharing of real world experiences of initiating, conducting, and the overall impact of presenting the validation results. Each of these major tasks of the validation process is an uphill battle requiring technical knowledge and depth, political awareness and people management skills.

As most practicing architects eventually realize, doing the right thing is never easy, and neither is this process of validating enterprise system architectures. Hopefully this white paper will trigger feedback that will help all enterprise architects deal with this issue and begin the process of validating (stake holder approval, acceptance, and adoption) enterprise system architectures.

The Need to Validate Enterprise System Architectures

This may sound very familiar to most enterprise architects but validating enterprise system architectures is not an activity found in most project plans. Yes, the validation process is not necessarily quick nor is it of short duration. However, it is of utmost importance that the foundation of enterprise systems, namely the system architecture upon which major investment of time, money, and resources is committed, is properly validated before it’s too late.

System architectures are artifacts shaped with all the personal biases of the enterprise architect responsible for developing the architecture. Past experiences, current knowledge, and a very personal understanding of the objectives of the enterprise system to be built play a big role in shaping the architects mind and hence the system architecture. Not validating system architectures would mean adopting the view point of the architect or the architecture team which put together the system architecture in question.

Validating system architectures is also hugely beneficial to the enterprise architect as it helps bring all stake holders and leaders together and facilitate a meeting of minds ensuring long term investment and support for the project. No project goes as planned and having this kind of all round support is critical to any enterprise project especially when things don’t go as planned.

An asset oriented view of systems and architectures

Enterprise architects, who view the systems they develop as software assets, tend to include validations into their plans. Assets are built with a long term vision in mind and are expected to have a long lifecycle. Hence it is natural for enterprise software asset architects to understand the importance of being assured that the long term direction set by the system architecture has backing from all stake holders, is affordable from the corporation’s perspective, and will actually deliver on everyone expectations.

It is not possible to define perfect system architecture as many of the parameters involved in forming that architecture will change over the lifecycle of the system. However validated system architectures have the capability to quickly make the necessary midstream adjustments without losing focus of the end goals.

Hence, enterprise architects should cultivate the habit of treating every system they architect as a long term software asset and take validation of their architectures seriously. The next few pages of this white paper discuss the process of validating enterprise system architects, and how to validate specific strategic aspects of the system architecture.

The Process of Validating Enterprise System Architectures

Defining the correct process for validating enterprise system architectures does not need a lot of advanced thinking or process engineering. The process is essentially simple, consisting of common sense tasks. However, planning and executing on these common sense tasks can be surprisingly challenging for an enterprise architect as it depends on the maturing of the corporation’s understanding of the role of enterprise system architectures.

Figure 1.0 presents one such common sense approach that involves three major tasks.

o Initiating an architecture validation

o Conducting the actual validation of the architecture

o Assessing the results of the validation

Figure 1: A common sense approach to validation process

Each of these seemingly easy and straight forward tasks can get complicated due to corporate politics. The biggest stumbling block becomes the acceptance of the results and the eventual sign-off of the enterprise system architecture. This is especially difficult for stakeholders who do not share the same level of understanding of architectures as the enterprise architect. Often, enterprise architects have a tough time convincing stakeholders about the need for validating system architecture prior to commitment of major IT investments.

Stakeholder awareness of the validation process and especially of the results of the processes is extremely important. Successful enterprise architects are routinely able to get stakeholder support to include architecture validations as part of the overall master project plans. The objective of the rest of this white paper is to help enterprise architects create the necessary awareness of what needs to be validated, how the validation will be performed and the expected benefits of the overall effort.

What Essential Aspects of Enterprise System Architectures Should We Validate?

There are many aspects to a system architecture including technical and business oriented and also some management oriented aspects such as implementation roadmaps. However validating each of these aspects is neither practical nor necessary for ensuring the system architecture is valid and will set the correct long term direction for the enterprise system. There are few strategic aspects of the architecture which when validated have a cascading impact on the remainder of the architecture aspects and development of the software asset. The top three strategic and essential aspects of enterprise system architecture that warrant validation are outlined below.
1. Probability and Level of “Adoption Risk”

Most forward looking and long term enterprise architects depends on adoption of new technologies, development techniques, and serious long term involvement of end users. These dependencies on adopting something new, reengineering existing processes etc. come with a higher probability of risk to the project. Understanding this “Adoption Risk” is critical to secure long term support from all stakeholders. Needless to say not having a complete picture of the risks involved will surprise stakeholders and the project will be at risk. It is the job of each enterprise architect to first identify these risks and then validate the architecture’s exposure to these risks by defining appropriate mitigation strategies.

2. Affordability

How much is this architecture going to cost throughout its lifecycle? This is a question most architects hope no one will ask as it’s very difficult or rather next to impossible for estimating accurately the cost of a long term project. Yes, enterprise architects need to have the skills for providing sensible cost estimates that will be acceptable to all stakeholders. These estimates need to be closer to reality than fiction and hence understanding aspects that can potentially influence the cost of the project in the long term need to be validated as part of the architecture.

3. Stakeholder Participation

Do all the stake holders understand, agree and accept the system architecture? Well this rarely happens and most architects will say that trying to get all stakeholders to agree on one architecture is not realistic. However, participation from all stakeholders is paramount to the long term success of enterprise projects and enterprise architects should spend time to understand the major drivers and scope of each stakeholder involved in the enterprise project.

Validating “Adoption Risk”

As discussed earlier, enterprise system architecture is a composition of many different aspects. Each of these aspects has its own lifecycle and the proposed system architecture will consist of aspects that are each in a different state of their individual lifecycle. Figure 2.0 presents a simplified view consisting of two aspects, the overall cost of selecting specific system architecture and the general adoption rate of new technologies

The risk measurement chart shows two key aspects that can influence the system architecture one way or the other. The first aspect is related to the technologies included in the system architecture. Usually there is a mixture of technologies ranging from some in the infancy stage of their lifecycles to other technologies that tend toward becoming obsolete over the lifecycle of the architecture. Generally speaking early adoption of new technologies has slightly less risk as there is room for adjustments as the technology matures. Late adoption of technologies poses a higher risk as technologies are becoming obsolete at a much faster rate.

Another aspect that enterprise architects should factor in their validation is the cost of supporting obsolete or near obsolete technologies. Any good enterprise system architecture has factored in the cost of replacing obsolete technologies with emerging or mature technologies over the lifetime of the software asset.

The goal of enterprise architects should be to keep a healthy balance of technologies with most of them falling in the center of the graph representing mature state technologies.

Validating Affordability

Ensuring a healthy mix of mature technologies is a sign of good architecture, however even the best of architectures do not get approved if the costs are prohibitive. The bigger danger however is when architects do not understand the lifetime cost of specific system architectures. It is much more painful to all stakeholders including enterprise architects when enterprise projects are aborted due to investments not generating expected results or to put it in correct jargon, no return on investment (ROI). A significant factor in ensuring ROI is setting the right perspective and correct expectations. Figure 3.0 presents a multi dimensional view of what enterprise architects should consider when calculating the costs associated with adopting system architectures.

Most architects look as far as acquisition and maintenance phase for calculating the overall costs of developing the enterprise system, acquiring the required licenses and maintaining the system. However, a more far reaching view of calculating costs will also include the replacement phase of the software asset. After all, all technologies eventually become obsolete and are replaced by entirely new technologies or enhanced versions of the same technology.

Most enterprise architects will agree that many times the replacement cost of a software asset is much higher than the acquisition and maintenance costs. The overall cost (time, money, resources) required to develop, maintain, and replace the software asset should be projected during the system architecture validation phase. The focus is not to lower the costs necessarily but trying to achieve more clarity on the costs through out the lifecycle of the software asset.

Validating Stakeholder Participation

So you have covered your bases on the adoption risk front, and also have clarity on the lifetime costs of adopting the software architecture, but are everyone onboard? How many times have enterprise architects been surprised by late objections or key stakeholders withdrawing their support at the last minute? Sometimes support for enterprise projects fades away due to factors beyond the sphere of influence of the enterprise architect. But it always helps to keep all the stakeholders aware of the system architecture and the long term goals on a regular basis. It is vital for enterprise architects to understand that there are many major constituents whose long term participation is absolutely necessary for the ongoing success of enterprise projects. Figure 4.0 presents the stakeholder quadrant consisting of the key stakeholder groups and the architecture scope directly influenced by these groups. Each stakeholder group is a composition of appropriate leadership, management, and staff.

Each view is itself a universe of processes, objects, and state that needs to be enabled and supported by the system architecture. Validating the system architecture across these views is critical for all stakeholders to be in agreement that their interests are taken care of. Enterprise architects should be prepared to initiate and complete this onerous task.

Summary

Validating enterprise architectures is a vital component of ensuring long term successful implementations for enterprise systems. The best enterprise system architectures fail to deliver when defined in isolation. The validation process is essentially about involving all stake holders and getting their acceptance and adoption of the architecture.

I welcome all comments and feedback on this white paper by email at: [email protected]

Software Architecture and Design – Goals, Principles and Some Key Considerations

Definition:

Philippe Kruchten, Grady Booch, Kurt Bittner, and Rich Reitman derived and refined a definition of architecture based on work by Mary Shaw and David Garlan (Shaw and Garlan 1996). Their definition is:

“Software architecture encompasses the set of significant decisions about the organization of a software system including the selection of the structural elements and their interfaces by which the system is composed; behavior as specified in collaboration among those elements; composition of these structural and behavioral elements into larger subsystems; and an architectural style that guides this organization. Software architecture also involves functionality, usability, resilience, performance, reuse, comprehensibility, economic and technology constraints, tradeoffs and aesthetic concerns.”

In Patterns of Enterprise Application Architecture, Martin Fowler outlines some common recurring themes when explaining architecture. He identifies these themes as:

“The highest-level breakdown of a system into its parts; the decisions that are Hard to change; there are multiple architectures in a system; what is architecturally Significant can change over a system’s lifetime; and, in the end, architecture boils Down to whatever the important stuff is.”

Software application architecture is the process of defining and coming up with a solution that is well structured and meets all of the technical and operational requirements. The architecture should be able to take into account and improve upon the common quality attributes such as performance, security, and manageability.

The main focus of the Software architecture is how the major elements and components within an application are used by, or interact with, other major elements and components within the application. The selection of data structures and algorithms or the implementation details of individual components are design concerns, they are not an architectural concerns but sometimes Design and Architecture concerns overlap.

Before starting the architecting of any software, there are some basic questions that we should strive to get answers for. They are as follows:

How the users of the system will be interacting with the system?

How will the application be deployed into production and managed?

What are the various non-functional requirements for the application, such as security, performance, concurrency, internationalization, and configuration?

How can the application be designed to be flexible and maintainable over time?

What are the architectural trends that might impact your application now or after it has been deployed?

Goals of Software Architecture

Building the bridge between business requirements and technical requirements is the main goal of any software architecture. The goal of architecture is to identify the requirements that affect the basic structure of the application. Good architecture reduces the business risks associated with building a technical solution while a good design is flexible enough to be able to handle the changes that will occur over time in hardware and software technology, as well as in user scenarios and requirements. An architect must consider the overall effect of design decisions, the inherent tradeoffs between quality attributes (such as performance and security), and the tradeoffs required to address user, system, and business requirements.

Principles of Software Architecture

The basic assumption of any architecture should be the belief that the design will evolve over time and that one cannot know everything one need to know up front. The design will generally need to evolve during the implementation stages of the application as one learn more, and as one tests the design against real world requirements.

Keeping the above statement in mind, let’s try to list down some of the Architectural principles:

The system should be built to change instead of building to last.

Model the architecture to analyze and reduce risk.

Use models and visualizations as a communication and collaboration tool.

The key engineering decisions should be identified and acted upon upfront.

Architects should consider using an incremental and iterative approach to refining their architecture. Start with baseline architecture to get the big picture right, and then evolve candidate architectures as one iteratively test and improve one’s architecture. Do not try to get it all right the first time-design just as much as you can in order to start testing the design against requirements and assumptions. Iteratively add details to the design over multiple passes to make sure that you get the big decisions right first, and then focus on the details. A common pitfall is to dive into the details too quickly and get the big decisions wrong by making incorrect assumptions, or by failing to evaluate your architecture effectively.

When testing your architecture, consider the following questions:

What were the main assumptions that were made while architecting the system?

What are the requirements both explicit and implicit this architecture is satisfying?

What are the key risks with this architectural approach?

What countermeasures are in place to mitigate key risks?

In what ways is this architecture an improvement over the baseline or the last candidate architecture?

Design Principles

When getting started with Software design, one should keep in mind the proven principles and the principles that adheres to minimizes costs and maintenance requirements, and promotes usability and extensibility. The key principles of any Software Design are:

Separation of concerns: The key factor to be kept in mind is minimization of interaction points between independent feature sets to achieve high cohesion and low coupling.

Single Responsibility principle: Each component or module should be independent in itself and responsible for only a specific feature or functionality.

Principle of Least Knowledge: A component or object should not know about internal details of other components or objects.

Don’t repeat yourself (DRY): The intent or implementation of any feature or functionality should be done at only one place. It should never be repeated in some other component or module

Minimize upfront design: This principle is also sometimes known as YAGNI (“You ain’t gonna need it”). Design only what is necessary. Especially for agile development, one can avoid big design upfront (BDUF). If the application requirements are unclear, or if there is a possibility of the design evolving over time, one should avoid making a large design effort prematurely.

Design Practices

Keep design patterns consistent within each layer.

Do not duplicate functionality within an application.

Prefer composition to inheritance. If possible, use composition over inheritance when reusing functionality because inheritance increases the dependency between parent and child classes, thereby limiting the reuse of child classes. This also reduces the inheritance hierarchies, which can become very difficult to deal with.

Establish a coding style and naming convention for development.

Maintain system quality using automated QA techniques during development. Use unit testing and other automated Quality Analysis techniques, such as dependency analysis and static code analysis, during development

Not only development, also consider the operation of your application. Determine what metrics and operational data are required by the IT infrastructure to ensure the efficient deployment and operation of your application.

Application Layers: While architecting and designing the system, one needs to carefully consider the various layers into which the application will be divided. There are some key considerations that need to be kept in mind while doing that:

Separate the areas of concern. Break your application into distinct features that overlap in functionality as little as possible. The main benefit of this approach is that a feature or functionality can be optimized independently of other features or functionality

Be explicit about how layers communicate with each other.

Abstraction should be used to implement loose coupling between layers.

Do not mix different types of components in the same logical layer. For example, the UI layer should not contain business processing components, but instead should contain components used to handle user input and process user requests.

Keep the data format consistent within a layer or component.

Components, Modules, and Functions: Key Considerations

In the previous sections we talked about key considerations that need to be kept in mind while architecting or designing an application. We also touched based on what needs to be kept in mind when we are dividing our application into various layers. In this section let’s take a look at some key considerations for designing component, modules and Functions.

A component or an object should not rely on internal details of other components or objects.

Never overload the functionality of a component. For example, a UI processing component should not contain data access code or attempt to provide additional functionality.

Explicitly state how the components will communicate with each other. This requires an understanding of the deployment scenarios your application must support. You must determine if all components will run within the same process, or if communication across physical or process boundaries must be supported-perhaps by implementing message-based interfaces.

Keep crosscutting code (such as logging and performance) abstracted from the application business logic as far as possible.

Present a clear contract for components. Components, modules, and functions should define a contract or interface specification that describes their usage and behavior clearly.