Department of Electrical and Computer Engineering


1. Molhado approach for architectural SCM

Software architecture defines the overall logical structure of high-level design of a software system in terms of components, interactions, and
relationships among them. Software architecture provides conceptual integrity for a system and the mental framework that engineers use to
design, discuss, document, and reuse its elements. It can also be used for generating partial or full implementations and for structuring the
repository of software artifacts.

Software development is a dynamic process where engineers constantly modify and refine their systems. As a consequence, everything evolves
including software architecture. The ability to manage this evolution is crucial to a successful software development and maintenance
process. Unlike source code, for which the use of a software configuration management (SCM) system is the predominant approach to
capturing evolution, approaches to capturing and managing evolution of software architecture span a wide range of disconnected
alternatives. Many traditional SCM systems treat a software system as a ``set of files'' in directories on a file system, and consistent configurations are defined implicitly as sets of file versions with a certain label or tag. This creates an impedance mismatch between the design domain (architecture level) and the configuration management domain (file level). SCM systems, whose concepts are heavily based on physical structure on a file system can become burdensome for ordinary developers partly
because design methods and SCM infrastructures require different mental models.

The Molhado approach for managing the architectural evolution is

  • Object-oriented
    • All system objects are versioned and persistent
    • Objects do not have to be files
    • Architectural elements are one kind of object.
    • Configurations are managed among objects.
  • Architecture-centered
    • Combines architectural and SCM concepts
      • bridging the gap between architecture domain (object level) and SCM domain (file level)
    • Architectural objects are integrated into an architectural SCM system model
  • Product versioning
    • Version control for entire software project
      • One global version space
    • A version is a point in the project’s lifetime
    • So, the connection between architecture version and implementation version is always maintained
      • Because their versions are not maintained separately

2. MolhadoArch environment

Figure 1. MolhadoArch snapshot

MolhadoArch is an architectural SCM environment that is built based on Molhado SCM infrastructure and framework. Figure 1 shows a snapshot from MolhadoArch.

First of all, a user creates a new software project. Then, the user can create the initial version of software architecture of that project by either using a built-in graphical tool or loading a system architecture description written in xADL 2.0, an XML-based ADL. SC parses a description file, creates architectural objects according to the Molhado's architectural system model, and then displays the initial version of architectural structure on a project structure window. From this window, the user graphically manipulates the architecture to create different versions and variants.

Figure 2. Implementation mapping for architectural objects

To specify the implementations of architectural elements (see Figure 2), the user can create new source code via built-in editors or importing external programs into the system. An xADL description often has the file names of the programs that realize architectural elements. The user can display this logical structure in the same window as architecture by double-clicking on architectural elements, or in a different window. From this window, the user can also graphically modify the source code's organization, edit, delete, import, and export any documentation or programs. The user can choose to display any component and an appropriate component editor will be invoked.

3. Distinguished characteristics of our approach

Molhado's approach for managing architectural evolution has valuable characteristics.

  • Firstly, architectural objects are versioned and persistent since Molhado SCM infrastructure is object-oriented. Developers do not need to worry about actual file storing in a file system.
  • Secondly, using product versioning, architectural evolution is captured together with implementations in a natural, tightly connected, cohesive manner. Changes to architectures and program source code are integrally captured and easily related to each other. Consistent configurations are maintained not only among source code files but also with the high-level software architecture.
  • Thirdly, MolhadoArch supports both planned (via xADL) and unplanned architectural evolution (via its versioning services). Therefore, it adds an important dimension to versioning support of ADLs for architectural evolution.
  • Fourthly, Molhado's system model is extensible and not tied to any particular ADL or architectural style. New components can always be defined to accommodate different ADLs and architectural styles.
  • Fine-grained version control for structured objects is inherited from Molhado infrastructure.
  • Structural differencing tools are also supported via Molhado infrastructure.
  • Beside providing compositional modeling facilities via composite components to support free-style architecture designs , Molhado can precisely capture how the architectural elements are connected and interact with each other via the the explicit and separate treatment of architectural components and connectors. Figure 2 shows an example of versioning and organizing source code of a theorem prover according to its system architectural design. System architecture in this example does not follow any particular architectural style.