[EN] arc42

arc42 is a proven method for documenting software architectures. It helps with the most important aspects to structure and communicate in a software architecture. As a beginner you should know the core elements and Understand principles of the arc42 method to get the most benefit from it.

Quick overview

1. Introduction and Objectives: Understand why the system exists and what problems it solves.
2. Conditions: Know the external influences and limitations.
3. Context demarcation: Clarity about the system boundaries and interactions with the environment.
4. Solution Concept: Understand the basic architectural principles and technology decisions.
5. Block view: Detailed knowledge of the main blocks and their interfaces.
6. Runtime view: Understanding the interactions between building blocks at runtime.
7. Design decisions: Document important architectural decisions and their reasons.

1. What is arc42?

arc42 is a template that gives you a structured method for describing and documenting software architecture offers. It is designed to provide both technical and non-technical stakeholders with a clear overview to give the architecture of a system.

2. Basic structure of arc42

arc42 consists of different chapters, each covering a specific aspect of software architecture. Here are the most important chapters you should know:

3. Introduction and objectives

• Objective: Why does the system exist? What problems does it solve?
• Stakeholders: Who are the users and what are their needs?
• Goals: What are the technical and non-technical goals of the system?

4. Conditions

• Technical constraints: Limitations caused by technologies and systems.
• Organizational constraints: project specifications, team structures.
• Legal constraints: Regulations and standards that must be adhered to.

5. Context demarcation

• External context diagram: Shows the interactions of the system with its environment (other systems, user groups).
• Context matching: Ensures that all interfaces and interactions are clearly defined.

6. Solution Concept

• Architecture Principles: Fundamental principles that guide the architecture (e.g. modularity, reusability).
• Technology selection: How and why were certain technologies chosen?

7. Block view

• Hierarchical structure: Divides the system into its main building blocks and their sub-building blocks.
• Building Block Description: Each building block is described in detail, including its responsibilities and Interfaces.

8. Runtime view

• Runtime diagrams: Shows the interaction of the building blocks during typical use cases (e.g. sequence diagrams).
• Process flows: Detailed description of the processes and their influence on the architecture.

9. Distribution View

• Distribution Diagrams: Shows how the system is physically distributed (across different hardware and networks).
• Deployment: Describes how and where different parts of the system run and how they communicate.

10. Cross-sectional aspects

• Security concepts: Approaches to ensure system security.
• Performance requirements: How is performance optimized and measured?
• Error Handling: Strategies for error detection and handling.

11. Design Decisions

• Architecture Decisions: Important decisions that influence the architecture.
• Justifications: Why were these decisions made and what alternatives were considered?

Key principles

• Uniformity and Completeness: arc42 helps document the architecture consistently and completely.
• Modularity: arc42 supports the modularity of the system through clear division into chapters and blocks.
• Traceability: Every decision and every design can be traced and justified.

With these insights, you should be well prepared to use the arc42 method and a clearly structured one and create well-documented software architecture.