Skip to content
  • Sign In
  • Try Now
View all events
Software Architecture

Iterative Architecture by Example

Published by O'Reilly Media, Inc.

Intermediate content levelIntermediate

Tools to continuously improve your architecture

Course outcomes

  • Understand iterative architecture and its benefits
  • Learn how to manage architectural change through iterative design
  • Build your toolbox for trade-off analysis and decision-making

Course description

No architect is so clever that they can look at complex situations and have perfect designs fall from their heads. However, modern engineering practices insist on rapid change, eliminating months of design in an ivory tower. What architects need are tools that allow them to create candidate designs, then iterate on the design and evaluate it so that they can work their way toward better solutions.

Join experts Mark Richards and Neal Ford to discover the tools and techniques that allow architects to perform iterative design on new and existing systems. You’ll learn how to tackle difficult problems such as determining proper granularity in microservices, how to manage data dependencies, and how to iteratively migrate from one architecture style to another. You’ll also examine techniques such as qualitative versus quantitative analysis, which allows architects to reason about solutions that may have never been built before.

What you’ll learn and how you can apply it

  • Iterate on architecture design
  • Apply integrators and disintegrators to determine appropriate granularity for services and data
  • Make reasoned architecture decisions with incomplete information
  • Choose the most appropriate architecture style, database, and transactional sagas

This live event is for you because...

  • You’re an architect or developer designing or building architectures.
  • You’re a senior developer or architect who wants to explore better ways to change an architecture.
  • You’re struggling with aligning your architecture with business needs.

Prerequisites

  • A basic understanding of the fundamentals of software architecture
  • Familiarity with distributed systems

Recommended follow-up:

Schedule

The time frames are only estimates and may vary according to how the class is progressing.

Iterative architecture (20 minutes)

  • Presentation: What does it mean to iterate architectural design?; differences between emergent design, evolutionary architecture, and iterative architecture; Gall’s Law; Ship of Theseus
  • Q&A

Iterating on domain design for greenfield applications (50 minutes)

  • Presentation: Avoiding the entity trap; workflow approach; actor action approach; event storming; comparing techniques; adding functionality; supporting architecture characteristics; shared resources; iterating on component design
  • Hands-on exercises: What’s missing?; explore when to use each technique; iterate on design
  • Q&A
  • Break

Qualitative versus quantitative design (50 minutes)

  • Presentation: Qualitative analysis—making decisions without metrics; architecture styles star ratings; database type star ratings; transactional saga star ratings; quantitative analysis—validating your decisions; observability and measurements
  • Hands-on exercises: Make an initial decision; qualify your decision
  • Q&A
  • Break

Iterative restructuring and migration (60 minutes)

  • Presentation: Definitions (migration, restructuring, or refactoring); restructuring patterns; identify, size, and flatten components; component domains; architecture stories
  • Hands-on exercises: Refactor components; iterative restructuring
  • Q&A
  • Break

Evolving existing architectures (50 minutes)

  • Presentation: Adding features; adding architectural characteristics; iterating on service granularity; iterating on database granularity; quantitative analysis revisited
  • Hands-on exercises: Adjust service granularity; adjust database granularity
  • Q&A
  • Break

Iteration tools for architecture (60 minutes)

  • Presentation: Service/database granularity integrators and disintegrators; qualitative versus quantitative analysis; building your own trade-off analysis
  • Q&A

Your Instructors

  • 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

    Xlinksearch

  • 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.

    linkedinXlinksearch