Software Architecture Patterns

General

• In defense of simple architectures • Dan Luu 📖
• Fundamentals of Software Architecture: An Engineering Approach • Mark Richards and Neal Ford 📕

Diagramming Software

• Creating Software with Modern Diagramming Techniques • Discussing his book about creating version-controlled diagrams with Mermaid • Ashley Peacock 📺
• Add more diagrams to repos? At multiple folder levels? Benefit vs risk of falling out of date?

Small vs Large Scale Architecture Patterns

• Larger Scale Software Development (and a Big Trap) • An overview of a number of simple-to-complex app architecture patterns with the overall recommendation to build even small side projects with scaling in mind • Code to the Moon 📺

Distributed systems

• 9 Software Architecture Patterns for Distributed Systems - DEV Community • Peer-to-peer, API Gateway, Pub-Sub, Request-Response, Event Sourcing, ETL, Batching, Streaming Processing, Orchestration • Soma 📖
  • Related to system design interviews + designing good-fit solutions at work

Messaging / event streaming / pub-sub

• Kafka in 100 Seconds • Fireship 📺
• Kafka in a Nutshell • Kevin Sookocheff 📖
• Apache Kafka: The Definitive Guide • Confluent 📕

State machines

• 📺 Formal Forms with State Machines | React Next 2019 • 32 minute video by David Khourshid using a website form example to demonstrate the benefits of using xstate to model app logic using statecharts
• 📺 Let’s learn state machines with David K. Piano! — Learn With Jason • 66 minute video by David Khourshid and Jason Lengstorf gradually exposing and fixing the bugs in a website feedback form by refactoring its boolean logic to a statechart using xstate
• 📺 XState: Data Loading Service • 20 minute video by Leigh Halliday showing how to use a callback service to incrementally load data from an API

Domain-Driven Design

• What Is Event Storming? | Lucidchart Blog
• Really enjoying Scott Wlaschin’s approach to implementing DDD using a functional paradigm (instead of the traditional OOP one):
  • The software is implemented as a pipeline composed of smaller pipelines, built by composing small functions
  • I/O is kept separate from domain logic and ideally pushed to the start/end of each use case
  • The domain is modeled using the type system by avoiding primitive types and preferring types named using ubiquitous domain language that compose smaller types and eventually model the entire system in terms of inputs and outputs at every level
  • Encourages ensuring every function takes inputs and returns a result making explicit what it accomplished, even if that was just a decision (which can be represented by an enum expressed in domain-specific terms)
  • Beware any function that takes no inputs or returns no result! That makes the domain modeling less explicit.
  • Resources:
    • Domain Modeling Made Functional • How to model a domain by defining all of its input and output types • Scott Wlaschin 📺
    • Moving IO to the edges of your app: Functional Core, Imperative Shell • Scott Wlaschin 📺
    • Pipeline-oriented programming • Argues the benefits of composing pure functions over OOP, specifically • Scott Wlaschin 📺

Microservices

• Stop Creating Microservices | Prime Reacts • To avoid network latency and deployment complexity, you probably want modules in a monolith instead • The Primeagen 📺
• Death By A Thousand MicroService | Prime Reacts • A monolith is almost always a simpler and more performant architecture than microservices, which sounds like a great way to break down a problem into smaller pieces but end up adding maintenance complexity and network/serialization lag • The Primeagen 📺

Hexagonal Architecture

• Hexagonal Architecture (All You Need to Know) • Makes a strong case for the benefits of preferring the hexagonal architecture for most projects, including testability and the ability to easily swap external dependencies • Gui Ferreira 📺
• Clean Architecture vs Hexagonal Architecture: Which One Should You Choose for Microservices? • You can likely apply the hexagonal architecture pattern or clean architecture pattern to any project, but the hexagonal pattern is simpler and that makes it a better general starting point • Gui Ferreira 📺

Clean Architecture

• The Grand Unified Theory of Clean Architecture and Test Pyramid - Gui Ferreira - CPH DevFest 2024 • Great video focusing on what kind of tests to write for each layer in a clean architecture project • Gui Ferreira 📺
• Clean Architectures in Python - Introduction - Leonardo Giordani
• Clean Architectures in Python - presented by Leonardo Giordani • Fantastic walkthrough of the four layers used when designing a system using the clean architecture pattern (entities, use cases, gateways, external systems) using a web app as an example. Study this! It’s well worth a try on my next new project • EuroPython Conference 📺
• Clean Architecture IS about Vertical Slicing, actually! • The clean architecture can lead to organizing your project by features (use cases); you don’t need to switch to the vertical slice architecture to do that • About Clean Code 📺
• Robert C Martin - Clean Architecture and Design

Folder Structure

• The BIGGEST Folder Structure MISTAKE on .NET • Regardless of your application architecture, organizing folders by feature rather than by technical concepts will always make your codebase more understandable to new teammates • Gui Ferreira 📺

Inbox

• The Architecture Behind A One-Person Tech Startup

• Engineering strategy notes. | Irrational Exuberance

• How Meta built the infrastructure for Threads - Engineering at Meta

• repo setup priorities: observability (especially useful error logging, but also traces) from the beginning; should be part of the initial setup step and a habit in every PR; when problems happen, it makes a huge difference if the logs/traces show you what’s wrong

• Multi-Tenant SaaS Architecture (Next.js Auth) • ByteGrad 📺

• Serving a billion web requests with boring code - llimllib notes • Great description of all aspects of how a large government website was implemented • Bill Mill 📖

• The Onion Architecture : part 1 | Programming with Palermo - Jeffrey Palermo

• Enterprise Tic-Tac-Toe, part 2 | F# for fun and profit - A capability-centric API design

• The Twelve-Factor App

• Python & the Clean Architecture in 2021 | breadcrumbs collector.tech

• Parse, don’t validate • such a good advice about type-driven design in general: map out your whole program as a sequence of types, start from both ends and work towards the middle, the types should capture all of the invariants so you don’t have to keep asserting the data is valid as you parse it; to avoid that, parse (i.e. convert to invariant types) at the I/O boundary and before you begin processing the data, even if it takes multiple parsing steps to get from the unknown inputs to domain types

• Kent Beck: “Design docs have the problem that I address in the Tidying books—when do you make design decisions. If you’re not going to learn anything & nothing external is going to change, then go ahead and make those decisions today. The greater the pace of change, the greater the value of deferring decisions.”