Rapid Interactive Software-Architecture Design with Split-n-Join Actions

The architecture design process is an essential and critical part of the overall software development lifecycle. During the early design phases it is imperative to ensure that an optimal architecture is outlined, reflecting the requirements of the target software product. Then, continuous refinement, syncing and maintenance is needed, in order to guarantee that the software architecture precisely reflects the particular state of the source code base and vice versa. Both processes involve elements and activities at an abstract level and require support for easy and quick experimentation, exploration and prototyping. In existing tools, commonly relying on UML diagrams, the architecture design process is very detailed and thus time consuming, asking designers to elaborate early on aspects that are usually finalized latter in the process. Effectively, such tools are not interactive prototyping laboratories, but are primarily architecture documentation environments. However, because they require so fine-grained detail, which is transient, volatile and non-final in the early design phases, they are less preferred for initial experimentation and analysis. Effectively, it is impractical for architects to spend the required effort in supplying data for components, specifications and relationships when those frequently change in the early design process.Based on these remarks, our work focuses on supporting the very early phases of the architecture design process, putting primary emphasis on rapid interactive construction, ease-of-use, continuous experimentation, minimal information, and adoption of common architectural abstractions. While our tool focuses on components, it reflects the exploratory nature of the design process by offering two key actions, namely splitting and joining components, besides typical creation and removal. Our work is inspired by the quick class design method known as CRC Cards (Classes, Responsibilities and Collaborators), part of agile development, by adapting the original notions to fit with the scale and abstractions of the software architecture domain as Components, Roles, Operations and Synergies (CROS).In our tool, the primary requirement has been the facilitation of rapid exploratory interactive design, with small effort on behalf of the user, making it a laboratory for testing where related ideas may be easily instantiated via the tool. Considering that the architecture structure changes frequently in this process, we identified most common actions architects perform when revisiting component roles, besides component insertion and removal: •Splitting: when a particular component is identified that blends many different disciplines together that deserve representation (i.e. decomposition) into distinct and separate components;•Joining: when a few components are considered as weak or arbitrary to stand on the own, while in terms of their functional role they look as pieces of the same concept, likely requiring merging together under the same umbrella.•Mapping: when the high-level functions that are typically identified following the requirement analysis process should be mapped to components in a way better matching its functional role – such mapping may change as well, while new operations may be introduced in the process.We discuss how such simple activities are fundamental and capture the essential aspects the early architecture design tasks, and the way we supported interactively such key tasks, while keeping their delivery simple, quick and yet sufficient. For instance, component associations or synergies may change by simply rearranging links with the mouse, while operations are managed easily by typical drag-n-drop. Additionally, further component decomposition is supported, enabling craft quickly the sub-architecture of any selected component. Notes may be freely added to components, while their view may be toggled with just a click.