Architecture: The Hard Parts
Published by O'Reilly Media, Inc.
Learn how to manage workflows, orchestration, distributed transactions, and optimize operational characteristics such as scalability, elasticity, and performance.
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 live event 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:
- Read Software Architecture: The Hard Parts (book)
- 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)
Schedule
The time frames 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
Your Instructors
Mark Richards
Mark Richards is an experienced, hands-on software architect involved in the architecture, design, and implementation of microservices architectures and other distributed systems in a variety of technologies. He has been in the software industry since 1983 and has significant experience and expertise in application, integration, and enterprise architecture. Mark is the founder of DeveloperToArchitect.com, a free website devoted to helping developers in the journey to becoming a software architect. In addition to hands-on consulting, Mark has authored numerous technical books and videos, including his two latest books Fundamentals of Software Architecture and Software Architecture: The Hard Parts that he co-authored with Neal Ford. Mark has spoken at hundreds of conferences and user groups around the world on a variety of enterprise-related technical topics.
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 several books, a number of magazine articles, and dozens of video presentations (including a video on improving technical presentations) and spoken at hundreds of developer conferences worldwide. His topics of interest include software architecture, continuous delivery, functional programming, and cutting-edge software innovations. Check out his website, Nealford.com