Agile Architecture

Agile Architecture emphasizes the minimum amount of design upfront, and focusing on building something and evolving the architecture as our understanding changes.

Architecture in software development is often defined as relationships between the parts in a system. Traditional approaches to software architecture emphasize Big Upfront Design - get it right at the start. The problem, of course, is that requires us to foresee all architectural considerations (scale, security, fault tolerance, fault recovery) at the moment when our understanding of our problems is at its weakest. Agile Architecture allows for the design to evolve and adapt as more is learned about what is needed.

The number of useful principles and patterns is vast:

• YAGNI - You Ain’t Gonna Need It - always said with a southern drawl
• DRY - Don’t Repeat Yourself or Avoid Duplication Principle
• KISS - Keep It Simple, Stupid
• Last Responsible Moment
• Tell Don’t Ask - tell an object to do something, don’t ask for its data
• Reversible vs Non-reversible Decisions - most decisions are reversible; some decisions are like a door that is locked behind you
• Build for Resilience (or Fault Tolerance)
• CUPID - Composable; Unix Like; Predictable; Idiomatic; Domain based
• Hexagonal Architecture (also known as Ports and Adapters)
• SOLID - Single Responsibility Principle; Open/Closed Principle; Liskov’s Substitution Principle; Interface Segration Principle; Dependency Inversion Principle
• High Cohesion, Low Coupling - High Cohesion is a restatement of the Single Responsibility Principle. Within a module, things should be tightly related. Low Coupling between modules, modules don’t have a strong reliance on one and other.
• Clean Architecture (relates to Hexagonal)

MicroService Architecture and Domain Driven Design are each large topics in their own right:

• MicroService Architecture
• Domain Driven Design

(Hint: when searching for more ideas, consider using the term: “Evolutionary Architecture”)