Software Architecture Book Club
This podcast goes chapter-by-chapter through books about software architecture, by the authors of those books, starting with Head First Software Architecture.
Episodes
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
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.
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.
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.
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.
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
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
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
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 a
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.
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.
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.
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 afte
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 challeng
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 th
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
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 kr
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.
Head First Software Architecture Chapter 7: The Modular Monolith
In our second architecture styles chapter, we delve into the Domain-driven Design inspired cousin of the Layered architecture (our previous episode)--the Modular Monolith. We describe what sets these two monolithic architectures apart, what the superpowers (and kryptonite) for this style, and when you would use it rather than a layered architecture.And, as always, we answer the voluminous question
Head First Software Architecture Chapter 6. The Layered Architectural Style
The main part of the Head First Software Architecture book is a catalog of architecture styles; this is the first of several chapters delving in the structure, communication, and all the other characteristics of named architectural styles, in this case, the Layered Architecture. We start with the traditional layered architecture as it is so common, and it has an easy to understand structure. We di
Head First Software Architecture Chapter 5: Styles and Patterns
As architects, we often talk about patterns--contextualized solutions to problems. But we must also choose between architectural styles: named topologies that include component organization, logical (and sometimes physical) deployment, communication,and a host of other characteristics. In this episode, we distinguish between patterns and styles and answer some common questions.
Head First Software Architecture Chapter 4: Logical Components
Structural design in software architecture entails both architectural characteristics analysis and deriving logical component from the problem domain. This episode of the podcast delves into logical component analysis, some traps to avoid, and some different analysis techniques. And, as always, answer lots of questions that came up during the discussion.
Head First Software Architecture Chapter 3: The Two Laws of Software Architecture
Chapter Three of Head First Software Architecture covers our Two Laws of software architecture: 1) Everything in software architecture is a trade-off2) Understanding why is more important than understanding howIn this episode, we discuss the origin of these two laws, why we consider them universal, and the (sometimes deep) implications of them for architects making trade-off decisions.
Head First Software Architecture Chapter 2: Architectural Characteristics
In this episode, we cover the first of the core four dimensions that make up software architecture: architectural characteristics. We discuss what they are and answer questions about derivation, composition, and a host of other factors required to understand this building block of structural design.
Head First Software Architecture Chapter 1: Architecture versus Design
Covering the first chapter of Head First Software Architecture, this episode dives into the spectrum of differences between architecture and design. We also cover the four dimensions of software architecture, which forms the narrative scaffolding for the next few chapters: architectural characteristics, architectural decisions, logical components, and architectural styles.
Recommended
The Young and Called Podcast .
Snoop Dogg - Flash Biográfico
Deadline: White House
Thrilling Threads - Conspiracy Theories, Strange Phenomena, True Crime, Unsolved Mysteries, etc!
The Daily Conspiracy Podcast
2819 Church
Markus Schulz presents Global DJ Broadcast
Bad Friends
The Bill Simmons Podcast
The Joe Rogan Experience
Psalms: The Ancient Songs
Culture & Christianity: The Allen Jackson Podcast
