removed emoji from filenames, Obsidian changed all relevant links

Corpus/Sparks/C4 model for software development/C4 model for software architecture.md

@@ -0,0 +1,88 @@
+# C4 model for software architecture
+
+The four layers, or Cs, are: **Context, Containers, Components, and Code**.
+
+The C4 model is a technique for visualizing software architecture using a **hierarchical set of four core diagrams**, which provide different levels of abstraction.1 The four layers, or Cs, are: **Context, Containers, Components, and Code**.2 This structure allows you to zoom in from a high-level overview to implementation-level details.3
+
+Here is the full C4 model table including all four levels:
+
+| Aspect       | Level 1: System Context                                                                                                  | Level 2: Container                                                                                                         | Level 3: Component                                                                                  | Level 4: Code/Classes                                                                        |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| Purpose      | Shows the system as a whole and its external users and systems interacting with it. Defines system scope and boundaries. | Breaks the system into high-level technology units (applications, services, databases) that can be deployed independently. | Details the internal structure of a container, consisting of cooperating units of code or services. | Shows the detailed design of the individual components, including classes or code elements.  |
+| Focus        | Who uses the system and what external systems it interacts with.                                                         | What applications/services/data stores make up the system and how they communicate.                                        | How each container is organized internally in terms of functionality and code structure.            | The implementation specifics such as classes, methods, relationships, and code organization. |
+| Detail Level | High-level, abstract view                                                                                                | Mid-level, technical architecture view                                                                                     | Low-level, detailed design view                                                                     | Very low-level, source code or design diagrams                                               |
+| Example      | Web application used by customers, admins, and external payment service                                                  | Web app, database, API service                                                                                             | Authentication module, data repository, business logic component                                    | Class diagrams, method calls within the authentication module                                |
+| Deployment   | N/A (conceptual boundary definition)                                                                                     | Independent deployable units                                                                                               | Runs inside a container, not independently deployable                                               | Runs inside components, part of the source code base                                         |
+
+Level 4 is optional and is generally only needed when an extremely detailed design of the software's internals is required. It bridges the gap between abstract design and actual source code[1][2][3].
+
+Sources
+[1] C4 model https://en.wikipedia.org/wiki/C4_model
+[2] Container diagram https://c4model.com/diagrams/container
+[3] Component https://c4model.com/abstractions/component
+
+---
+
+## 1. Context Diagram (Level 1) 🌍
+
+The Context diagram provides the **highest-level view**—the "big picture."4 It shows the software system you are describing at the center and how it **fits into the world around it**.5
+
+- **Focus:** The system in scope, its users (**People**), and the **other software systems** it directly interacts with (external dependencies).
+    
+- **Purpose:** To give all stakeholders, including non-technical ones, a quick and easy-to-understand view of the system's role, scope, and key dependencies. – *Who uses the system and why?*
+
+
+| ![](C1-example.png.avif) | ![](C1-example2%201.png) |
+| ------------------------ | ---------------------- |
+Bronnen:
+https://mstack.nl/blogs/software-architecture-documentation-using-the-c4-model/
+https://dev.to/anwaar/c4-model-real-world-example-with-google-maps-3ano
+
+
+---
+
+## 2. Container Diagram (Level 2) 📦
+
+The Container diagram zooms **inside the system** to show its high-level technology choices and the **major structural building blocks**.8 A "container" is an independently deployable/executable unit.9
+
+- **Focus:** The **containers** (e.g., web applications, mobile apps, databases, separate server-side applications/microservices) that make up the software system, how they interact, and the technology used for each.10
+    
+- **Purpose:** To show software development teams and technical stakeholders the structure of the system and the communication between the major parts.11
+    
+- **Analogy:** The floor plan of a building, showing the different rooms and how they connect (e.g., kitchen, bedrooms, garage).12
+    
+| ![](C2-example.png) | ![](C2-example2.png) |
+| ------------------- | -------------------- |
+
+---
+
+## 3. Component Diagram (Level 3) 🧩
+
+The Component diagram zooms **inside a single container** to show the internal structure.13
+
+- **Focus:** The **components** (e.g., services, modules, repositories, controllers) that reside within a single container, their responsibilities, and how they interact with each other and with other containers/systems.14
+    
+- **Purpose:** To help developers and architects understand the internal design and organization of the code within a container before diving into code.
+    
+- **Analogy:** Inspecting a single room in the building, showing the furniture, appliances, and internal wiring.15
+
+
+| ![](C3-example.png) | ![](C3-example2.png) |
+| ------------------- | -------------------- |
+
+
+---
+
+## 4. Code Diagram (Level 4) 💻
+
+The Code diagram provides the **lowest level of detail**, zooming inside a single component.16
+
+- **Focus:** Implementation-level details, such as **classes, interfaces, objects, and functions**.17
+    
+- **Purpose:** To explain the detailed design of complex or particularly important components.18 This level often relies on existing modeling techniques like UML class diagrams and can often be automatically generated by tools, making it an **optional** level in many cases.19
+    
+- **Analogy:** A detailed schematic diagram of a single appliance in the room, showing its internal parts and electrical connections.
+
+![](C4-example.png)
+
+