EducationSelf-Improvement

Software Architecture Book Club

Mark Richards, Neal Ford, Raju Gandhi

This podcast goes chapter-by-chapter through books about software architecture, by the authors of those books, starting with Head First Software Architecture.

Play

Open in

21 episodes
monthly
Avg 56 min
English

Episodes 21

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

August 25 · 45 min
Software Architecture Fundamentals 2nd Edition, Chapter 15: Space-based Architecture
No, it has nothing to do with outer space but rather tuple space. We continue our survey of architectural styles with an exotic one, Space-based architecture, which answers the question: how can you design an architecture that can handle several hundred thousand simultaneous requests...before cloud providers existed. Today, this architecture style is used for caching and other high volume problems. Join us as we describe this architecture style, how it works, what's good and bad, and how it's still useful today.
S2 · E14
July 23 · 56 min
Software Architecture Fundamentals 2nd Edition, Chapter 14: Event-driven Architecture
We continue our survey of architectural styles with a widely misunderstood one, Event-driven Architecture. The first thing we attack on this episode is how this style and microservices are alike and, more importantly, differ. We talk about common usages of this style, variations based on events versus messages, data strategies, and a host of other details, some not found in the book (including some extended metaphors). Join us as we cover one of the most powerful distributed architecture styles.
S2 · E13
June 18 · 50 min
Software Architecture Fundamentals 2nd Edition, Chapter 13: Service-based Architecture
Continuing our relentless cataloging of architectural styles, in this episode we cover the service-based architecture. This is the only style in the book with a bespoke name, created by Mark and Neal, because it appeared in the wild so often as a pragmatic compromise on the extremes of microservices. In this episode, we describe the origins of the style, untangle the name from other architectures that include the word "service", and discuss trade-offs and ramifications beyond what we covered in the book, leading to a wide-ranging conversation.
May 14 · 56 min
Software Architecture Fundamentals 2nd Edition, Chapter 12: Microkernel
Continuing our catalog of architectural styles, in this episode we cover the Microkernel architecture. Sometimes also known as a plug-in architecture, we introduce the idea of "microkernality" in this episode and talk about the myriad ways this architecture style appears in the real world. We cover a lot of information in this episode, expanding on the material in the book chapter.
S2 · E11
April 16 · 47 min
Software Architecture Fundamentals 2nd Edition, Chapter 11: Pipeline Architecture
Continuing our exploration of architecture styles, this month we go deep on the Pipeline (or Pipes and Filters) Style. This episode explores different types of filters, uses of this architecture, and how it differs from other similar styles.
S2 · E10
March 19 · 59 min
Software Architecture Fundamentals 2nd Edition, Chapter 10: Layered Architectures
This is the first of many chapters that each do a deep-dive on a particular architecture style; in this chapter, we start with the layered monolithic architecture, also known by many as the default architecture. We describe the topology, communication, data strategies, and philosophy underlying this style. We also point to ways to govern this style and how to adapt the style without breaking it.
S2 · E9
February 19 · 57 min
Software Architecture Fundamentals 2nd Edition, Chapter 9: Foundations
The outcome of the architectural characteristics and logical component analysis we've been undertaking over the last few chapters is for an architect to choose an appropriate architecture style most suitable for the problem and capabilities we must build to be successful. Thus, this chapter starts a deep-dive on the most popular generic architecture styles that architects should be aware of. This chapter separates the concept of style versus pattern and describe how we'll tackle each fundamental style.
S2 · E8
January 15 · 1 hr
Software Architecture Fundamentals 2nd Edition, Chapter 8: Logical Components
For the past few chapters/episodes, we've been delving into the analysis and definition of architectural characteristics, one of the two key structural design activities for software architects. In this chapter, we cover the other aspect of structural design in defining logical components, the building blocks of most software architectures. These define the behavior of the system, and we talk about some techniques and challenges in understanding the problem domain and translating it to software structure.
S2 · E7
Dec 18, 2025 · 56 min
Software Architecture Fundamentals 2nd Edition, Chapter7: Scoping Architecture Characteristics
In this episode, we cover one of the key indicators for architects to answer one of the first questions they must consider--should they choose a monolithic or distributed architecture? Understanding and applying the scope of architectural characteristics is one of the keys to properly choosing most applicable solution. As usual, we cover details and background from the chapter and answer questions from the recording audience.
S2 · E6
Nov 20, 2025 · 56 min
Software Architecture Fundamentals 2nd Edition, Chapter 6: Measuring Architecture Characteristics
In this episode, we cover the critical topic of how architects can govern the architectural characteristics they identified. Architects are responsible for both identifying architectural characteristics, but should also ensure that they check on them to make sure the aspirational goal is manifesting. For example, if the team has a goal of 50ms First Contentful Paint for responsiveness, how can you determine if you've achieved that goal? As always, we cover some details and background from the chapter, and answer some live questions.
S2 · E5
Oct 16, 2025 · 55 min
Software Architecture Fundamentals 2nd Edition, Chapter 5: Indenifying Architectural characteristics
In this episode, we cover the Software Architecture Fundamentals 2nd Edition chapter on identifying architectural characteristics, an important skill for all software architects. Many think this type of analysis is only useful at project inception, but it turns out to be useful even for existing systems. As always, we cover the basics of the chapter and answer a number of questions from the live audience.
S2 · E4
Sep 18, 2025 · 57 min
Software Architecture Fundamentals 2nd Edition, Chapter 4: Architectural Characteristics Defined
Architects can split structural design into two analyses: architectural characteristics and logical component analysis. This episode introduces what we mean by architectural characteristics (and why we don't care for alternative terms such as non-functional requirements, cross-cutting requirements, etc.). We discuss our definition and how it impacts architecture decisions.
S2 · E3
Aug 14, 2025 · 55 min
Software Architecture Fundamentals 2nd Edition, Chapter 3: Modularity
A key concept for structural design in software architecture is modularity, which this episode dives into. We define the difference between modularity and granularity, and focus on some of the concrete measurements architects have to understand the macro structure of component-based systems. As usual, we also answer some great questions from our live audience.
S2 · E2
Jul 17, 2025 · 59 min
Software Architecture Fundamentals 2nd Edition Chapter 2: Architectural Thinking
In this episode of the podcast, we sync up with chapter two of Software Architecture Fundamentals 2nd Edition, Architectural Thinking, including topics like architecture versus design, the distinction and importance of technical depth versus breadth, the primacy of analyzing trade-offs, understanding business drivers, and balancing role expectations like coding versus non-coding activities.
S2 · E1
Jun 19, 2025 · 59 min
Software Architecture Fundamentals 2nd Edition Chapter 1: Introduction, Laws of Software Architecture
In this episode, we start our chapter-by-chapter exploration of Software Architecture Fundamentals 2nd Edition. We discuss our (updated) definition of software architecture. While we were writing the first edition, we kept our eyes open for things that seems universally true; we hoped to find about 10, but we ended up with two in the first edition. For the second edition, we added a third law after some insights in the intervening years. In this episode of the podcast, we cover all three laws and how they apply to the remainder of the book.
S1 · E12
May 15, 2025 · 59 min
Writing a Technical Book
What's it like to author a technical book? Especially one as stylized at Head First Software Architecture? We take a brief departure from our normal pattern of covering one book chapter per episode as we're between books and thought this might be a good time to go meta. We provide some insight in writing "regular" technical books, along with the special constraints and challenges inherent in writing for a series like Head First.
S1 · E11
Apr 17, 2025 · 1 hr
Head First Software Architecture Chapter 11: Leftovers!
Head First books by their nature cannot cover as much material as conventional books, especially for such a broad topic as software architecture. Thus, the "Leftovers" chapter was born--several important topics that we just didn't have room to cover in the book. In this episode of the podcast, we cover the Head First Software Architecture "Leftovers" and sum up our last thoughts on the book.
Mar 13, 2025 · 58 min
Head First Software Architecture Chapter 10. Event-driven Architectures
Continuing our exploration of distributed architectures, our next architecture style is event-driven architecture, one of the few styles that can also double as a communication pattern. We discuss what makes an architecture event-driven versus microservices, and discuss why architects might choose this style for certain classes of problems ill suited to other styles. And, as always, we cover both the super powers and kryptonite for this style.
S1 · E9
Feb 13, 2025 · 57 min
Head First Software Architecture Chapter 9. Microservices Architecture
Everyone's favorite popular architecture of the moment, our next architecture style goes fully into distributed architectures with microservices, discussing how it differs from monolithic architectures and other distributed ones. Regardless of what people say, this isn't the only architecture anyone should use; we discuss the good and bad for this style, along with its superpowers and kryptonite.
S1 · E8
Jan 16, 2025 · 59 min
Head First Software Architecture Chapter 8. Microkernel Architecture
Our third monolithic (sometimes) architecture style is the micro-kernel architecture. We delve into how this is different than an architecture that just supports plug-ins, and talk about some of the great uses and dangers to watch out for. As with all our style chapters, we end with a discussion of the super powers and kryptonite of this style.

Showing 1–20 of 21 episodes