Software Delivery in Small Batches

A look into the ideas of empiricism, iteration, and incrementalism applied to software engineering. These are the code ideas of Dave Farley's 2022 book "Modern Software Engineering".

Learn More
★ Support this podcast on Patreon ★

Creators & Guests

Host
Adam Hawkins
Software Delivery Coach

What is Software Delivery in Small Batches?

Adam Hawkins presents the theory and practices behind software delivery excellence. Topics include DevOps, lean, software architecture, continuous delivery, and interviews with industry leaders.

Hello and welcome to the Small Batches podcast. I'm your host Adam Hawkins. In each episode I share a small batch of software delivery education. Topics include DevOps, lean, continuous delivery, and conversations with industry leaders. Now, let's begin today's episode.

Listeners to this podcast should be familiar with Dave Farley. Dave Farley is a coauthor of the book "Continuous Delivery". He has also written a few shorter books on continuous delivery and deployment pipelines. He also runs the "Continuous Delivery" channel on YouTube.

He was also the first person I interviewed for this podcast. During the interview he made a point on the importance of doing actual engineering.

Or as Dave puts it: the application of an empirical, scientific approach to finding efficient, economic solutions to practical problems in software.

This is the topic of his newest book "Modern Software Engineering". I think Dave Farley is someone we should listen to and learn from so I had this one preordered the second I learned about it.

Reading "Modern Software Engineering" is like having a long pairing session with a senior engineer. It's part "Extreme Programming Explained", part "DevOps Handbook", and part "The Pragmatic Programmer". All those are wonderful books in their own right which I highly recommend as well.

"Modern Software Engineering" is part advice, part theory, and part technical practices. This is a wonderful book to give developing engineers because it describes the path and how to walk it.
The path begins with optimizing for learning. Why here? Because software engineering is complex. Most of the time we're building things we don't fully understand at the outset, so we must discover the appropriate solutions.

We must work iteratively following feedback. Our solutions should be developed incrementally guided by empirical experiments.

Those two sentences summarize almost half the text. Let's go a bit deeper by examining the difference between iterative and incremental.

Iteration is defined as "a procedure in which repetition of a sequence of operations yields results successively closer to a desired result".

Incrementalism is defined as "related to any modular design application, in which components can be freely substituted if improved to ensure better performance".

Iteration is a way of working. Incrementalism is a way of design. This is an important distinction.
We need automated feedback to guide iterations. "Feedback" begins with automated tests we run on our machine before committing code, then onward through the deployment pipeline that proves the change is fit for production, and ultimately ends with telemetry from production operations. Voilla, continuous delivery.

As always, fast feedback is better because we can adapt and change earlier. This is why I say "Modern Software Engineering" is part "DevOps Handbook" because this mindset capture the three ways of DevOps: flow, feedback, and learning.

Dave Farley adds something more with the focus on empirical incrementalism. Dave pushed the importance of empiricism in our conversation and repeatedly throughout Modern Software Engineering.
Empiricism, in the philosophy of science, is defined as "emphasizing evidence, especially as discovered in experiments. It is a fundamental part of the scientific method that all hypotheses and theories must be tested against observations of the natural world rather than resting soley on a priori reasoning, intuition, or revelation."

This is another way of "genchi genbutsu", or grasping the objective reality of the situation. We must use facts, figures, and data to truly understand the current condition. Farley describes this as: assume that what you know, and what you think, is probably wrong, and then figure out how could find out how it is wrong.

You'll need experiments for that. Experiments that test the edges of your understanding. Experiments that yield new information about the problem domain. Conduct enough experiments and you'll navigate the domain with confidence.

Applying incremental design allows you to replace parts of the existing system with newer and improved parts as you discover them through experimentation.

Achieving this means managing complexity. This is where "Modern Software Engineering" moves past "The DevOps Handbook" to discuss software architecture.

"Modern Software Engineering" says that a primary focus is managing complexity though modularity, cohesion, separation of concerns, abstraction, and loose coupling.

This is all to say that complexity is managed through designing systems that support TDD. That's a broad statement that implies many others.

The most important being use the loose coupling at boundaries. Incrementalism is not entirely useful if you need to change many parts of a system when only changing one part.

"Modern Software Engineering" describes using the ports & adapters (or Hexagonal architecture) pattern. Dave Farley tells the story of how this pattern allowed his team to easily swap the database for a financial exchange when new requirements called for a different database.

All in all, I don't think there's anything in this book that I disagree with. In fact, it's quite the opposite. Dave Farley has managed to compress the best parts of "The DevOps Handbook", "Extreme Programming", and "The Pragmatic Programmer" into a single book. I highly recommend it.

You've just completed another episode of Small Batches. I have few more resources I have to share with you.

The first is my interview with Dave Farley. Looking back on the conversation I wonder if he was writing this book when he came on the show. Dave brings up the same points he mentions in the book--specifically about the focus on "just doing software engineering" as he puts it.

Second is the Small Batches slack app. I've loaded the app with the best passages and tips from "Modern Software Engineering". Think of the app as one of those daily desk calendars. The app is currently FREE in beta, so try it out and share some software delivery education.

Go to SmallBatches.fm/63 for links to what I just mentioned and to buy Modern Software Engineering by Dave Farley.

Alright, that's it for this batch. I hope to have you back again for the next episode. Until then, Happy shipping.