Categories: Architecture, Links

See also the link collection for this site related to programming.

Architectural Patterns

• STOSA: Single Team Oriented Service Architecture
• SCS Architecture: Self Contained Systems
• [video] Greg Young: CQRS and Event Sourcing - intro to the basic concepts
• [video] Michael Nygard: Architecture Without an End State - evolutionary architecture, patterns for long-term enterprise-scale architecture

Microservices

• Christian Posta: When Not To Do Microservices
• Google Cloud Architecture Center: Microservices Series
• NGINX: Microservices Series
• AppDynamics: How Anti-Patterns Can Stifle Microservice Adoption
• Daniel Westheide/InnoQ: Restful communication between microservices - looks into the topic of sync vs async communication between microservices. I don’t agree with everything here, but it’s an interesting viewpoint.
• Martin Fowler: How to break a Monolith into Microservices
• microservices.io: Adopt the Microservice Architecture
• Ben Morris: Microservices, Rest and the Distributed Big Ball of Mud
• Ben Stopford/Confluent: Build Services on a Backbone of Events - see “Query by Event Carried State Transfer”
• Sam Newman’s Blog
• Oscar uit de Bos: The Event-Carried State Transfer Pattern
• [video] Sam Newman: Principles of Microservices
• [video] Axel Fontaine: Majestic Modular Monoliths
• [video] Jimmy Bogart: Avoiding Microservice Megadisasters - the story of a microservice project with very poor scalability and uptime, and how to do things otherwise.
• [video] Chris Richardson : Not Just Events - Developing Asynchronous Microservices
• [video] Charity Majors: Test in Production

Domain-Driven Design

• [video] Nick Tune: The Art of Discovering Bounded Contexts
• Domain Driven Design Community - some useful resources, but site seems dead: last “post” from 2014 and copyright last updated 2018.
• [video] Eric Evans: DDD and Microservices - at last some boundaries - about how the boundaries of multiple contexts in a monolithic system tend to get broken over time, and how using microservices more strongly “enforces” boundaries. Plus some other very interesting stuff on the role of context-maps.
• [video] Michael Bryzek: Design Microservices the Right Way - I don’t agree with all points made, but it is an interesting report from a successfull company..
• [video] Andrew Schofield: Creating event-driven microservices - see minute 25:00 where replication of data via “snapshots” is discussed.

Event Driven Systems

• [video course] Confluent: Designing Events and Event Streams

Team Structure

• Christian Posta: The Real Success Story of Microservice Architectures - looks at the benefits of small cross-functional teams
• [video] Dan North: Patterns of Effective Teams - superb presentation!

Articles by Christian Posta

Christian Posta has written so many excellent articles on microservices and related topics that it’s worth a dedicated section. Here are the articles I found most interesting, though it is worth checking out everything he has written. I’ve ordered these posts in the sequence that makes the most sense to me (not in publishing date):

• When Not To Do Microservices
• The Real Success Story of Microservices
• DevOps and the Myth of Efficiency
• Prefer Verticals Not Layers
• Why Microservices Should Be Event Driven
• The Hardest Part About Microservices: Your Data
• The Hardest Part About Microservices: Calling Your Services
• Being a Better Enterprise Architect

Generally Useful Resources

• SQUER company blog
• Structurizr - C4 model for drawing architecture diagrams

Other Interesting Stuff

• [video] Dan North/Youtube: Simplicity - a very short presentation on not overcomplicating
• [video] Kevlin Henney/Youtube: Old is the New New - how many new ideas are actually old ones (with 1968 being a particularly productive year..)
• Shopify: Under Deconstruction: The State of Shopify’s Monolith - how one company is modularising a monolithic codebase
• [video] Simon Brown/Youtube: Modular Monoliths - How should you allocate code to modules in a large monolithic codebase? How can architectural abstractions be reflected in the codebase? How can the model-code gap be minimised? How can architectural decisions be enforced?