Software Architecture with C++: Designing robust C++ systems with modern architectural practices

First off, great work, authors! This is an amazing book that's quite comprehensive in terms of its breadth of subjects related to C++. I'd recommend this book for any C++ developer who wants to better understand software architecture or those who plan to take on a tech lead role. The book is best suited for developers at the intermediate level, past beginner and comfortable with the language. In broad terms, the book covers: 1. Software Development Philosophy: SOLID principles, DRY, Agile, functional and non-functional requirements, and more 2. C++ Language: features, design patterns, application building, library packaging, and more 3. Software Quality: software testing, CI/CD, security, and performance 4. Cloud-Native Design Principles I work in electronics design and embedded systems, so cloud-native design principles might seem irrelevant to me at first glance. But there are highly valuable universal topics here, such as inter-service communication (protobufs, anyone?), services, using containers, and adding telemetry and tracing. Here’s a list of things I really appreciated about this book: - Covers modern C++ features including C++20 modules, LLVM's `[[lifetimebound]]` attribute, and C++23/26 previews like contracts - Explains what are and how to use polymorphic allocators (a favorite feature of C++17) - Walks through real CI/CD workflows using GitLab, pre-commit, linting, and code format checks - Shows how to package libraries using C++20 modules, CMake, and Conan—my favorite package manager - Demonstrates how to write unit tests using Boost.UT (my favorite testing library! No macros!) - Features a modular structure that lets you skip sections not relevant to your work - Much of the discussion is nuanced, with both sides of an argument usually presented - In the performance section, they describe the GOTO "label" trick for opcodes that I used in part two of my exception series. 🤩 Overall, great stuff! But I do have a few points I didn’t like: - The book overstates the cost of virtual functions. Indirect calls may have negligible impact compared to I/O or long-running operations - Some examples appear after long blocks of explanatory text, making it harder to follow. I’d recommend skipping around when you notice this. There are a few other minor nits, but they’re not significant. Overall, this is the book I’ll be recommending to anyone looking for a broad understanding of software architecture in C++. It will be a go-to reference for me.

I have mixed feelings about the second edition of "Software Architecture with C++." On one hand, it is a very modern book. It uses cutting edge C++23 and even C++26 constructs, which is great to see. The real "juice" of the book for me is in Chapters 5 and 6. These are excellent. They cover important items like RAII, std::optional, and Ranges. I specifically liked the depth in Chapter 6, where you find things that are hard to find in other books, like the copy-and-swap idiom, monadic interfaces, and "niebloids." If the whole book was like these chapters, it would be a 5-star resource. However, the book is very long (around 700 pages) and feels a bit bloated. There is a lot of information that isn't really about C++ architecture specifically. For example, it spends a lot of time on Microservices, Docker, and Package Managers. While these are useful for software engineers in general, they are orthogonal to C++ domain topics. I would have preferred a leaner book that focused more on C++ idioms and design patterns, similar to Klaus Iglberger’s "C++ Software Design." If you are looking for modern C++ snippets and specific library-building techniques, there is a lot of value here. But be prepared to skip through many chapters that feel more like general infrastructure or DevOps than core C++ architecture.

As a low-latency C++ developer, I often focus on How to optimize code to be run efficiently. But lately, I’ve been reflecting on the Where. Where does our code live, and how does it talk to the rest of the system? I am reading an upcoming book, "Software Architecture with C++" by Andrey Gavrilin, Adrian Ostrowski and Piotr Gaczkowski, and it changed how I think. Here are my three biggest lessons learned: 1. Data locality is the new performance king We often talk about Big O notation, but this book reminds us that "pointer chasing" (like in std::list) is a silent performance killer. Swapping to flat structures like std::vector or the new C++23 std::flat_map keeps data close in memory. In modern C++, the CPU cache is your best friend. 2. Is DRY making your system fragile? This was a surprise. We are taught "Don’t Repeat Yourself." But the authors argue that in microservices, duplicating a bit of code is often better than "tight coupling." Sharing too much code can mean that a slight change in one service breaks everything else. Sometimes, independence is worth the repetition. 3. Infrastructure is part of the code Moving from math to industry taught me that code must be deployable. I loved the tip on multi-stage Docker builds. Shrinking a production image from 3.5GB to 137MB isn't just a DevOps task; it makes our C++ applications more secure and faster to scale. My favorite quote from the book: "Whether you put thought into it or not, when writing software, you are creating an architecture." If coding is like learning to drive a car perfectly, architecture is understanding the highway system. If you want to stop building accidental architectures, I highly recommend reading the book.

(Disclaimer: A review copy of this book was provided by the publisher) The first thing you’ll notice when holding a physical copy of this book is that it’s big! At over 700 pages, the contents are organized into four parts across 18 chapters: - Part 1: Concepts and Components of Software Architecture (3 chapters) - Part 2: The Design and Development of C++ Software (6 chapters) - Part 3: Architectural Quality Attributes (4 chapters) - Part 4: Cloud-Native Design Principles (5 chapters) (There is a chapter 19, which is about the publisher’s services available to readers: Next-gen Packt Reader, AI assistant, and DRM-free PDF/ePub downloads.) Studying this title reminded me of some technical books from the 90s and 00s [1]: it covers a lot of ground regarding software architecture while using C++ as the programming language. As with the titles from the past, I still think this approach is a double-edged sword, because if you want only one [practical] book about the subject (or can only afford one), this is a great one! But if you are a senior or already have experience designing software using other technologies, you might find yourself skimming through many pages (at least the more theoretical parts). If you are interested only in the C++ language topics, you will probably focus on Part 2. However, I’d suggest you read other chapters as well, since the authors always make the connection between C++ and other technologies. For instance: using different testing frameworks (Chapter 10), test-driven automation and CI/CD pipelines using GitLab, GitHub Actions, and Conan (Chapter 11). They also cover security in code and deployment (Chapter 12), and performance and benchmarks (Chapter 13). Both chapters have lots of C++ content, tips, and third-party libraries to help us deal with these topics. While I didn’t get my hands dirty with Part 4, I did take notes to explore some of the topics in the future. And that brings me to another aspect of the book: maybe (probably) you won’t apply everything from this book all at once. Some things are easily applicable to any [C++] project, but many depend on the specifics of the project, team decisions, and so on (I know the notes I wrote down for further exploration will be applied in toy projects to get familiar with some tech stacks and later be comfortable using them in real projects). Each chapter ends with a summary, a set of review questions (you can check your answers with the “Assessments” appendix), and a “Further Reading” section with lots of references. All in all, I recommend this book for developers looking to integrate modern architectural practices into their C++ workflow, knowing that maybe not everyone will use all the contents right away and that the book is not only about C++. --- [1] I read many books from The Premier Press Game Development Series and often they would dedicate the first half to Win32 API programming, as it was the main tech used to implement the books’ examples. So, if the reader didn’t know the Win32 API, she didn’t have to get another book about that particular topic to start exploring the examples.

What the book does well: Connects C++ and architecture. It shows how design decisions (modules, interfaces, layering) map to concrete C++ constructs, build layout, and dependency management in real-world codebases. ​ Focus on maintainability: The book emphasizes evolution, boundaries, and clear contracts over “clever” code, which aligns strongly with modern expectations from senior/lead C++ engineers. ​ Patterns in context: Architectural patterns are presented with trade-offs, not as silver bullets, and are always tied back to runtime costs, build complexity, and team workflows. ​ Why it stands out for C++ developers: Bridges a real gap. Most C++ books go deep on language and low-level details but barely touch system structure; this one explicitly targets that missing layer between “class design” and “distributed systems architecture.”Software architecture with C++.pdf ​ Production-oriented mindset: Topics like coupling, module boundaries, testing strategy, and dependency direction are discussed with the reality of large C++ builds, legacy code, and incremental refactoring in mind. Who I’d recommend it to: - Senior C++ developers who are already comfortable with the language but want to level up their architectural thinking. ​- Tech leads and architects working on large C++ systems who need a common vocabulary to discuss structure and evolution with their teams. ​- Teams struggling with “big ball of mud” C++ codebases and looking for a pragmatic roadmap to improve them over time. ​ If you’re working in C++ and feel that your biggest challenges are no longer about syntax but about structure, coupling, and long-term maintainability, this book is well worth your time. ​

Note: I wrote a review for the 1st edition of this book - and gave that version 5-stars. This book is full of interesting information. And that's part of the problem. This 2nd edition is 41.5% longer (in terms of total pages)...and it tries to cover too many things - but often only giving a bare mention of something - before quickly racing on to mention something else - without ever going into any substantive elaboration, detail, or example. Don't get me wrong - there is some good content here - but the book suffers from several issues: - The editing process should have caught several significant issues in the content and structure of the book. - The are far too many things that are suggested as additional topics/resources for the reader - for which no link is provided. - Resources mentioned in a chapter - may (or may not) be provided as links at the end of the chapter. This separation of being told to go read something, and then having to flip back-and-forth to 1) see if there is a link (often, only to be disappointed); and 2) then needing to find your place back in the chapter - is disruptive to the reader experience. - There are quite a few technologies that are mentioned - which are referred to by old/invalid names, or for technologies that have no recent releases - and are no longer being maintained (see Chapter 14, pages 463-464, for the list of ESBs suggested). - The world of software development has rapidly evolved in the five years since the 1st edition was written - and seeing tired old concepts/terminology, such a Enterprise Service Bus (ESBs), Service Oriented Architecture (SOA), and SOAP - makes the book feel very dated.

Started learning C++ and realized code that works isn't enough. Projects get messy - dependencies breaking, performance dying, deployment impossible. This book shows you WHY and HOW to actually build real systems. The architectural fundamentals chapters finally explain what nobody teaches in tutorials. Decomposition strategies, design patterns, system patterns - these are the difference between hobby code and professional systems. The distributed systems section is mind-opening. Microservices, observability, cloud-native design suddenly make sense. Then the real skills: CMake, Conan, CI/CD pipelines, testable code, logging and tracing. You learn not just C++ features but how to assemble them into something that scales. The modules chapter shows the future of C++. Security, performance, containers - each connects to real problems. This book takes you from "I can write C++" to "I can build systems that don't fall apart."

I found this book to be a thoughtful and practical resource for understanding how modern C++ fits into larger system architectures. The book strikes a strong balance between big-picture architectural thinking and concrete, hands-on C++ examples. I’d recommend this book to anyone looking for a modern survey of software tools. It effectively connects concepts that many engineers encounter only in isolation — service models, deployment strategies, observability, CI/CD, and performance — and grounds them in real-world C++ implementations. I also appreciated that the authors introduce contemporary tools such as Prometheus, Grafana, Ansible, and sanitizers, and concisely compare approaches rather than prescribing a single solution. My only critique is one that has been echoed in other reviews: it lacks depth in some of the covered topics. Personally, I also found a lot of value in the chapter review questions and the curated recommendations for additional talks, books, and other resources. I would treat these additional resources as required reading for any specific topic you want to explore more deeply.