[VDBUH2025] Simon Martinelli - Goodbye Microservices, Hello Self-Contained Systems
Summary of the YouTube Video Transcript
The video is a presentation by Simon, a Java developer and consultant, advocating for “self-contained systems” (SCS) as an alternative to microservices, especially for businesses that don’t operate at the scale of companies like Netflix. The speaker traces the evolution of software architecture, from monolithic applications in the 90s to the rise of microservices. He argues that microservices, while beneficial for certain use cases, often introduce unnecessary complexity, especially for smaller companies. He contends that the term “microservices” is misleading and that the core issue is often not the architecture itself, but the lack of modularity in the underlying code, frequently leading to “big ball of mud” scenarios. The speaker highlights the importance of modularity, drawing on David Parnas’s work, and emphasizes that SCS offer a good balance.
The core concept of SCS is presented: breaking down a large system into smaller, autonomous units, each encompassing its own UI, business logic, and data storage. This approach aims to reduce dependencies, simplify deployments, and promote team autonomy. The presenter contrasts SCS with microservices, focusing on size, autonomy, communication patterns (favoring asynchronous communication), UI ownership, and deployment complexity. He also acknowledges the benefits, such as resilience, scalability, and technical independence, while acknowledging the need for a “macro architecture” and design system to manage the overall application’s consistency and maintainability.
The speaker then illustrates the practical application of SCS through a case study of his current project with a wholesale company. He outlines the business domain, the existing monolithic system (built on J2EE and Eclipse RCP), and the migration strategy. He explains how they’re implementing SCS using data replication between systems and a linked UI, using technologies like Vadin, Spring Boot, and Oracle. He emphasizes the use of a “strangler fig” pattern to gradually migrate functionality from the monolithic system to the new SCS architecture. The presentation concludes by reiterating the advantages of SCS, particularly in modernization projects, emphasizing their optimal modularity, reduced dependencies, team autonomy, and simplified deployments.
Accuracy
The transcript provides a generally accurate and insightful overview of the concepts of microservices and self-contained systems. The speaker draws on relevant history, and experience to back up his arguments. Here’s a breakdown of the accuracy of specific points:
- History and Evolution: The video accurately reflects the shift from monolithic applications to microservices and the problems that can arise from each. The mention of J2EE and Eclipse RCP as older technologies is accurate.
- Microservices Misconceptions: The presenter’s point that microservices are often misunderstood and misapplied is valid. The idea that the term “micro” is misleading is also valid, as microservices can vary significantly in size.
- Modularity & Dependency: The emphasis on modularity and the dangers of poorly designed monoliths and distributed systems is accurate and crucial for software architecture.
- Domain-Driven Design: The connection of SCS with concepts from Domain-Driven Design (DDD) is accurate. Bounded contexts often align well with SCS boundaries.
- Communication: The explanation of different communication styles (synchronous, asynchronous, event-based) and their implications is correct. The discussion of the N+1 problem and its impact on performance is relevant.
- Self-Contained Systems: The presentation accurately describes the core principles of SCS as a way to build software architectures. The information aligns with the definitions of the concept.
- Strangler Fig Pattern: The explanation of the “strangler fig” pattern for migrating monolithic applications is correct and a useful strategy.
- Case Study: The details about the wholesale company’s project and its use of specific technologies (e.g., Vadin, Spring Boot, symmetric ds) are accurate.
- Overall: The content is presented in a very clear and understandable manner.
Resources
Here are 5 relevant resources to learn more about self-contained systems and related topics:
- Self-Contained Systems Website: https://scs-architecture.org/ - This is the official website for SCS and provides a good starting point.
- “Building Microservices” by Sam Newman: This book is a great resource for gaining a deeper understanding of microservices architectures, design patterns, and trade-offs, and also covers the principles of distributed systems. It helps in building self-contained system as well.
- “Domain-Driven Design: Tackling Complexity in the Heart of Software” by Eric Evans: This is the foundational book on Domain-Driven Design, which is highly relevant to understanding bounded contexts and designing effective self-contained systems.
- “Monolith to Microservices: Evolutionary Patterns to Transform Your Monolith” by Sam Newman: While microservices-focused, this book provides practical strategies and patterns for migrating from monolithic applications, which directly relates to the “strangler fig” pattern.
- Martin Fowler’s website (martinfowler.com): This website has a wealth of articles, blog posts, and presentations on software architecture, design patterns, and related topics, including material on microservices, modularity, and distributed systems. Look for articles on “bounded contexts,” “microservices,” and “integration patterns.”