Architecture: Conceptualization

Objective: System Delivery

It is critical and urgent that the system is delivered as soon as resources allow.
We would like to establish that a design (or architecture, per se) and documentation are not deliverables. The finished system is the deliverable. Everything that comes before is just a phase, a stage, or a milestone. The objective is the successfully completed system.

Strategic Approach

In order to achieve the final objective, a system must acquire specific attributes:
     - corresponding to the business requirements and expectations for successful business functioning;
     - providing ability to compensate resources and efforts spent during unsuccessful attempts;
     - facilitating business effectiveness;
     - supporting prospective business  changes, enhancements, and diversification.
Such attributes are called System Quality Attributes.

The system cannot acquire them just by itself or by someone’s wish. System Quality Attributes must be planned. Quality of a software system is not acquired automatically and not applied to a system in place. If a system does not have a certain quality attribute it is extremely difficult to force such quality in. This will require substantial reorganization (re-design) of the system. Quality must be designed in, so that the system is empowered with capability to propagate quality throughout and across all system elements and processes. In order for the system to be capable for that, it must have a consistent and recognizable pattern in design and functioning. Such a pattern is called Conceptual Integrity.

No architecture (civic or software) may be created or exist without System Conceptual Integrity. If Conceptual Integrity does not exist in a system, the system by definition is said "lacking (or missing) architecture".

System Conceptual Integrity

System conceptual integrity is central to system quality. This principle is by no means limited to software systems, but to the design of any complex construct, whether a computer, an airplane, a Strategic Defense Initiative, a Global Positioning System.

Conceptual Integrity unites all system elements and quality attributes by enduing them with the same common characteristics and technological ideas.

When architecture is created, a system design must be able to:
• accommodate a Conceptual Integrity;
• acquire a System Metaphor;
• propagate a conception (technical concept) to all elements and components;
• embody System Quality Attributes, both functional and structural, into each component and process;
• create a structure supporting functionality.

Vitruvian Triad

It is well known and established by principles of Architectural Theory that the conceptual integrity of a system (any systematic technical structure) is achieved by applying the Vitruvian Triad.

Vitruvius was a Roman writer, architect, and engineer active in the 1st century BC. He was the most prominent architectural theorist known today, having written De Architectura, (known today as The Ten Books of Architecture). It is the only surviving major book on architecture from classical antiquity, and it is the only contemporary source on classical architecture to have survived. The famous orders of architecture that we can see in every classical architecture are rigorously defined in the books. It also gathers three fundamental laws that Architecture must obey, in order to be so considered: Firmitas, Utilitas, Venustas.

All architecture is comprised of three elements: function (utilitas), structure (firmitas), and concept (venustas).
The three architectural elements are called the Vitruvian Triad. This triad has formed the basis of architecture and forms the theoretical basis of software architecture.


Utilitas represents the function of the structure, functionality.
Firmitas represents the means, materials, and logistics of the structure.
Venustas represents the design – a layout and combination of structural elements to meet the functional needs.

In the case of software architectural design:
     - Utilitas is a set of System Quality Attributes Discernable at Runtime (read more »);
     - Firmitas is System Quality Attributes Not Discernable at Runtime (read more »);
     - Venustas is the Conceptual Intergrity brining Utilitas and Firmitas together.

System Concept (Venustas)

Applying or utilizing a technical idea at a level of each individual component. It does not create a system. In order to create an organic system (i.e., systematic structure), we should apply a technical concept at the system level and facilitate propagation of the technical concept throughout the entire system and into each element of the system on all levels. This ensures that all components, elements, and processes within the system will share same characteristics and quality attributes.

Components, elements, and processes become organic parts of the system not because they have similar (patternal, for example) characteristics, but because the system makes them its parts by delegating to them its conception and quality attributes.

Product conceptual integrity means uncompromised adherence of the whole and entire system to the one and only software architectural concept and the implementation design, - in each and every programming unit, body of code, object, and component, as well as in process of creating architecture and producing the software product.

In a system having product integrity there may not be embodied any unit that does not follow the system conceptual guidelines and design. This approach produces consistency in both system development and user’s interaction with the system and its components (applications).

When a new element is implemented (in software development an "element" means a method, a rule, an object, a component, etc), there must always be a prescribed way to do that applying a concrete principle of system conceptual integrity established by the architectural design idea of the system. It must be strictly prohibited to implement any element not following the system concept.

     Disparate Structures and Absence of Conceptual Integrity

Conceptual definition brings the structure and the functionality together. t is almost impossible to implement all System Quality Attributes using only structural engineering or functional implementation. Neither structure nor functionality acquires necessary or expected quality automatically.

When we design a system considering quality attributes it is expected to have, we are contributing to a system concept. If we attempt to inherit or re-use some kind of existing third-party structure or component, we are risking to not obtain necessary quality because that structure may not be based on any concept or may (and most likely does) possess a technical parameters that do not correspond to our system concept.

A structure may not be based on any concept because it is created for structural re-utilization purposes only (such as a re-usable component or block) created outside the system being designed. This is specifically true for generic structures that are created in attempt to satisfy common needs of any system. Thus, such structures do not address particular requirements of concrete business scenarios. Such structures expose risk of not being correspondent or relevant to the business process requirements at hand.

Structural or engineering concepts may drive only interactions of internal elements of a structure. If we attempt to "connect" such a structure to our conceptual model, we need to make substantial effort to align our system concept with the structure functional capabilities.

At best, it creates tight coupling between the entire system we are creating and components of the structure. This leads to limitations to extensibility and maintainability (and thus, it deprives the system of important quality attributes).

At worst, it creates a dysfunctional system. The only solution to these scenarios is creation of an "integration" layer between two or more structures built with different specifications. This is similar to construction engineering efforts of connecting two buildings (different in design) with a pedestrian overpass. Or attempts to install a Toyota engine on a Nissan.

Examples of a Connector Between Two Different Structures


Being unable to vest System Quality Attributes to the system, in this situation we will have to attempt to force such attributes into the integration layer. Let alone engineers supposed to acquire a full technical knowledge of both structures to address weak points of interconnections.

External generic structural blocks (sometimes they are confusingly called "re-usable"), are unable to provide implementation of most System Quality Attributes to a particular system because such blocks have no knowledge of a system they are intended for. Therefore, particularly the resulting systems utilizing such generic components will have deficiency in such System Quality as high performance, security, extensibility and many others.

Example of a Dysfunctional Structure

Implementation of Conceptual Integrity

Conceptual Integrity resolves the problems outlined above and many others.
Furthermore, if a concept is designed in at early stages, System Quality Attributes are also designed into the system and become available on the structural and functional levels.

Conceptual Integrity is an abstract characteristic of a system. Conceptual Integrity is implemented by defining a System Metaphor and via applying specific design techniques. Each technique may address one or more System Quality Attributes.
For example, Component Loose Coupling design technique ensures that the system will possess Extensibility, Integrability, and Scalability.
Interface Consistency, as another principle, enhances system understanding and design knowledge transfer between parts of the system and between builders. An emphasis on consistency contributes to the discovery of commonality and opportunities for reuse, while unnecessary diversity in component design and implementation typically leads to decidedly negative consequences, such as brittle system structure.

The following non-exhaustive list specifies architectural design principles used to implement Conceptual Integrity and achieve System Quality Attributes:
• Conceptual System Metaphor including:
     - Conceptual System Subject;
     - Conceptual System Process operating on the System Subject;
• Logical System Metadata:
     - Definition of Core System Elements;
     - Definition of System Communication;
     - Components Metadata.

The following non-exhaustive list specifies certain techniques (principles) used to implement Conceptual Integrity and achieve System Quality Attributes:
• System Object types definitions using Published Interfaces (Facades);
• Component Loose Coupling;
• Separation of Concerns;
• Single Responsibility;
• Principle of Least Knowledge;
• Technology Transparency;
• JIT (Just-In-Time) process design;
• Single Design Point;
• Plug-In/Out and Switch-It-On/Off Approaches;
• Industry Patterns, Standards and Clichés used within System Concept.

Each technique comprises several more detailed and concrete techniques on the engineering level.

     Cross-cutting Concerns

Cross-cutting concerns are features of design that may apply across all layers, components, and tiers. They are also known as "services".
Typically, in an ideal world a business process would have perfectly functioned without them.

Examples of cross-cutting concerns and services are:
• Authentication and Authorization;
• Communication;
• Configuration Management;
• Exception Management;
• Logging and Instrumentation.

These services may or may not be included into conceptual design depending on whether we need to create such services and impose the System Metaphor and Conceptual Integrity upon them, or we’re planning to use an external components provided by third parties.

» Back To Steps to Create True Software Architecure

---