Architects are often harried and worried because they have no clean, easy decisions: everything is an awful trade-off between two or more less-than-perfect alternatives. Architecture has lots of difficult problems—but there are also proven ways to address them.
Join experts Mark Richards and Neal Ford as they guide you through the jungle of software architecture’s hard parts. Over three interactive, scenario-driven hours, you’ll learn how to choose an appropriate architecture, decide on service granularity, manage workflows and orchestration, manage and decouple contracts, manage distributed transactions, and optimize operational characteristics such as scalability, elasticity, and performance. Find out just what makes software architecture so hard—and the things that can make it easier.
What you'll learn-and how you can apply it
By the end of this live online course, you’ll understand:
- Why software architecture is so hard and ways to make it easier
- The trade-offs between available options
- The complexities of breaking apart monolithic applications
- Techniques for managing workflow and transactions when breaking apart applications
And you’ll be able to:
- Analyze trade-offs and effectively document your decisions
- Determine the right level of granularity for your services
- Decouple services in a distributed architecture
- Manage and decouple contracts between services
- Manage data in a highly distributed architecture
This training course is for you because...
- You’re an architect or developer 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 preparation:
- Brush up on fundamentals with Fundamentals of Software Architecture (book)
- Watch any sections of the following learning paths that you find interesting or relevant to your software architecture practice:
Software Architecture Fundamentals—Architectural Thinking
Software Architecture Fundamentals—Architecture Styles
Software Architecture Fundamentals—Soft Skills
Software Architecture Fundamentals—Evolutionary Architecture
Recommended follow-up:
- Explore Software Architecture Fundamentals—Diagramming and Documenting Architecture (learning path)
- Explore Software Architecture Fundamentals—Architecture Techniques (learning path)
About your instructors
-
Mark Richards is an experienced hands-on software architect involved in the architecture, design, and implementation of microservices architectures, service-oriented architectures, and distributed systems. He's been in the software industry since 1983 and has significant experience and expertise in application, integration, and enterprise architecture. He's the author of numerous O’Reilly technical books and videos, including several books on microservices, the Software Architecture Fundamentals video series, the Enterprise Messaging video series, and Java Message Service, second edition, and was a contributing author to 97 Things Every Software Architect Should Know. A speaker and trainer, he’s given talks on a variety of enterprise-related technical topics at hundreds of conferences and user groups around the world.
-
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 has authored seven books (and counting), a number of magazine articles, and dozens of video presentations and spoken at hundreds of developers conferences worldwide. His topics include software architecture, continuous delivery, functional programming, cutting-edge software innovations, and a business-focused book and video on improving technical presentations. Check out his website, Nealford.com.
Schedule
The timeframes are only estimates and may vary according to how the class is progressing
How do I effectively analyze trade-offs and document architecture decisions? (20 minutes)
- Presentation: Architecture decision records; documenting architecture decisions; documenting trade-off analysis
How do I choose an appropriate architecture? (10 minutes)
- Presentation: Characteristics; quanta; databases; communication styles
How do I determine the appropriate level of granularity (20 minutes)
- Presentation: Granularity drivers; granularity factors
- Hands-on exercise: Choose the right level of granularity
- Break (10 minutes)
How do I handle workflow and transactions in a distributed architecture? (25 minutes)
- Presentation: Orchestration; choreography; sagas
- Hands-on exercise: Identify workflow and sagas
How do I create systems with high semantic coupling but low syntactic coupling? (25 minutes)
- Presentation: Contract management; caching; GraphQL; the trade-offs of REST versus SOAP
- Hands-on exercise: Reduce coupling
- Break (10 minutes)
How do I manage data in a distributed system? (30 minutes)
- Presentation: Data sharing techniques
- Hands-on exercise: Manage data ownership; manage data access
How do I achieve high levels of scalability and elasticity in a system? (30 minutes)
- Presentation: Architecture styles and solutions; case study
- Hands-on exercise: Choose an architecture