Designing Microservices
Published by O'Reilly Media, Inc.
Overcoming service and data granularity challenges
Course outcomes
- Understand the architectural difference between modularity and granularity
- Learn the complexities of and techniques for breaking apart monolithic applications
- Understand the difference and impact between static and dynamic coupling in software architecture
- Explore tools and techniques for analyzing and governing static coupling
Course description
Distributed architectures such as microservices present a number of challenges for architects, especially around issues like service granularity and data dependencies. Presented by Neal Ford, this course focuses on static coupling in software architecture and presents tools and techniques for understanding and managing this critical concept.
A simple definition of coupling states that two parts are coupled if a change in one might necessitate a change in the other. Often, software architecture creates multidimensional problems, where multiple forces all interact in interdependent ways. To analyze trade-offs, an architect must first determine what forces need to trade off with each other by finding what parts are entangled together and analyzing how they are coupled to one another.
This course distinguishes between modularity and granularity in code, then shows you how to iteratively determine granularity in both code and data dependencies in both greenfield and existing systems. Neal focuses on the application of understanding modularity, breaking large monolithic applications into separate and smaller parts to provide more capacity for further scalability and growth, and describe a number of software architecture migration patterns. Increased scalability is only one benefit of architectural modularity. Another important benefit is agility, the ability to respond quickly to change. Understanding and applying these capabilities can help achieve a company’s strategic goals, making it easier to add, change, or remove functionality.
What you’ll learn and how you can apply it
- Distinguish different types of coupling in microservices
- Apply integrators and disintegrators to identify the right size for a service
- Apply patterns to assist architecture migration and restructuring
This live event is for you because...
- You’re an architect or developer who’s designing or building distributed systems.
- You’re a senior developer or architect who wants to better understand the harder parts of software architecture.
- You’re struggling with service granularity, distributed transactions, service coupling, and distributed workflows.
Prerequisites
- A basic understanding of the fundamentals of software architecture
- Familiarity with distributed systems
Recommended follow-up:
- Read Software Architecture: The Hard Parts (book)
Schedule
The time frames are only estimates and may vary according to how the class is progressing.
Class intro (5 minutes)
- Sysops Squad intro (functions plus data)
Modularity versus granularity (25 minutes)
- Presentation: Drivers for modularity (why); technical versus domain partitioning (modularity realization); high-level approaches (tactical forking versus CBD) - (how); granularity; determining modularity via metrics
- Q&A
Coupling in software architecture (40 minutes)
- Presentation: Architecture quantum definition; static coupling; dynamic coupling; discovering static coupling
- Q&A
- Exercise: What is the scope of the quantum?
- Break
Granularity in microservices code (55 minutes)
- Presentation: Disintegrators (service functionality, volatility, operational architecture characteristics, fault tolerance, access); integrators—transactions, data dependencies, coordination, code reuse (shared functionality)
- Q&A
- Exercise: What is the appropriate granularity?
Automating architectural governance (25 minutes)
- Presentation: Using fitness functions to protect architecture design
- Case studies: Fixing referential integrity; performing experiments; fitness functions for migration and analysis
- Q&A
- Exercise: Designing a fitness function to govern coupling (pseudo code in chat)
- Break
Granularity for database dependencies (55 minutes)
- Presentation: Database granularity issues; physical bounded context; database dependency integrators; data coupling, data sharing (performance, data consistency); database dependency disintegrators (change control, connection pool, scalability); fault tolerance; data domains
- Q&A
- Exercises: Determining database granularity; reduce scoped (targeted) trade-off between two entities; customer to ticket domains
- Break
Data mesh (30 minutes)
- Presentation: Understanding the distinction between operational and analytical data; previous solutions (data warehouses and lakes); data mesh definition and how it’s different; the architecture parts of data mesh; cooperative quanta; mesh-style decoupling
- Case study: Analytical data for Sysops Squad
- Exercises: How many tickets did we close last month? (operational); How much did we make last month on tickets? (DPQ); re-repair rate (expert, ticket, product, locale, cost)
Wrap-up and Q&A (5 minutes)
- Presentation: Review of tools and techniques presented
Your Instructor
Neal Ford
Neal Ford is a director, software architect, and meme wrangler at Thoughtworks, a software company and a community of passionate, purpose-led individuals who think disruptively to deliver technology to address the toughest challenges, all while seeking to revolutionize the IT industry and create positive social change. He’s an internationally recognized expert on software development and delivery, especially in the intersection of Agile engineering techniques and software architecture. Neal’s authored eight books (and counting), a number of magazine articles, and dozens of video presentations (including a video on improving technical presentations) and spoken at hundreds of developers conferences worldwide. His topics of interest include software architecture, continuous delivery, functional programming, and cutting-edge software innovations. Check out his website, Nealford.com.