Software Architecture

Principles and patterns for structuring a codebase and a system as a whole.

Beginner

  1. What is Software Architecture?: The high-level decisions about how a codebase is organized and how its pieces fit together — decided before a single function gets written.
  2. Separation of Concerns: Keeping different responsibilities — like displaying data, fetching it, and validating it — in different places instead of tangled together.
  3. Coupling & Cohesion: How tightly pieces of code depend on each other (coupling) versus how well a single piece of code focuses on one clear job (cohesion).
  4. Layered Architecture: Organizing code into layers — like presentation, business logic, and data access — where each layer only talks to the one next to it.

Intermediate

  1. SOLID Principles: Five plain-language guidelines for keeping object-oriented code flexible and easy to change, bundled together under one acronym.
  2. Dependency Inversion: Making important code depend on an abstraction — an interface describing what it needs — instead of on one specific, concrete implementation.
  3. Clean Architecture / Hexagonal Architecture: Keeping business logic independent of frameworks, databases, and UI, so any of those can be swapped without touching the core logic.
  4. Domain-Driven Design (DDD) Basics: Organizing code around the real-world business concepts it models — entities, value objects, and a shared vocabulary with domain experts — rather than around technical convenience.
  5. Monorepo vs Polyrepo: Deciding whether to keep multiple projects or packages in one shared repository, or spread across separate repositories, and weighing the tradeoffs.

Advanced

  1. Event Sourcing & CQRS: Storing every change that happened instead of just the current state, and separating the model used to write data from the model used to read it.
  2. Architectural Decision Records (ADRs): Writing down significant architecture decisions and the reasoning behind them, so future maintainers understand why a choice was made, not just what was chosen.
  3. Technical Debt: The tradeoff between shipping a faster, less-ideal solution now and the ongoing cost of maintaining or fixing it later — much like financial debt.
  4. Anti-Corruption Layer: A translation layer that protects your system's clean internal model from a messy or incompatible external system, so its quirks don't leak inward.