Gavrilin / Ostrowski / Gaczkowski Software Architecture with C++

Designing robust C++ systems with modern architectural practices
1. Auflage 2025
ISBN: 978-1-80323-505-9
Verlag: Packt Publishing
Format: EPUB
Kopierschutz: 0 - No protection

E-Book, Englisch, 738 Seiten

Designing scalable and maintainable software with C++ requires more than language expertise-it demands strong architectural thinking. This practical guide equips you with the skills to design and build robust, distributed systems using modern C++.

Starting with fundamental architectural principles and design philosophies, the book walks you through practical approaches to designing and deploying reliable systems. This edition contains significant updates across the book, including new chapters on observability, package management, and C++ modules to address real-world software challenges. You will explore software decomposition strategies, design and system patterns, fault tolerance, API management, and testability-all applied with C++.

Additionally, the book covers modern CI/CD pipelines, cloud-native design, microservices, and modular development, helping developers navigate today's fast-evolving software landscape. With updated examples and a renewed emphasis on maintainable and observable architectures, this edition equips C++ professionals to architect modern systems. By the end of this book, you will be able to design, build, test, and deploy well-architected solutions using modern C++ and proven architectural techniques.

*Email sign-up and proof of purchase required

Autoren/Hrsg.

Gavrilin, Andrey

Ostrowski, Adrian

Gaczkowski, Piotr

Leseproben

1

Importance of Software Architecture and Principles of Great Design

The purpose of this introductory chapter is to show what role software architecture plays in software development. It will focus on the key aspects to keep in mind when designing the architecture of a C++ solution. We’ll discuss how to design efficient code with convenient and functional interfaces. We’ll also show how the domain-driven approach complements Agile principles and guides both code and architecture.

In this chapter, we’ll cover the following topics:

• Understanding software architecture
• The importance of proper architecture
• The fundamentals of good architecture
• Developing architecture using Agile principles
• The philosophy of C++
• Following the SOLID and DRY principles
• Coupling and cohesion

Getting the most out of this book – get to know your free benefits

Unlock exclusive free benefits that come with your purchase, thoughtfully crafted to supercharge your learning journey and help you learn without limits.

Here’s a quick overview of what you get with this book:

Next-gen reader

Figure 1.1: Illustration of the next-gen Packt Reader’s features

Our web-based reader, designed to help you learn effectively, comes with the following features: Multi-device progress sync: Learn from any device with seamless progress sync. Highlighting and notetaking: Turn your reading into lasting knowledge. Bookmarking: Revisit your most important learnings anytime. Dark mode: Focus with minimal eye strain by switching to dark or sepia mode.

Interactive AI assistant (beta)

Figure 1.2: Illustration of Packt’s AI assistant

Our interactive AI assistant has been trained on the content of this book, to maximize your learning experience. It comes with the following features: Summarize it: Summarize key sections or an entire chapter. AI code explainers: In the next-gen Packt Reader, click the Explain button above each code block for AI-powered code explanations.

DRM-free PDF or ePub version

Figure 1.3: Free PDF and ePub

Learn without limits with the following perks included with your purchase: Learn from anywhere with a DRM-free PDF copy of this book. Use your favorite e-reader to learn using a DRM-free ePub version of this book.

Unlock this book’s exclusive benefits now Scan this QR code or go to packtpub.com/unlock, then search for this book by name. Ensure it’s the correct edition.

Technical requirements

To play with the code from this chapter, you’ll need the following:

• A Git client for checking out the book’s repository
• A C++23-compliant compiler
• The GitHub link for code snippets: https://github.com/PacktPublishing/Software-Architecture-with-Cpp-2E/tree/main/Chapter01

Understanding software architecture

Let’s begin by defining what software architecture is. When you create an application, library, or any software component, you need to think about how the elements you write will look and how they will interact with each other. This arrangement of elements and their interactions defines software architecture. In other words, you’re designing different elements and their relationships with their surroundings.

Just like with urban architecture, it’s important to think about the bigger picture so as not to end up in a haphazard state. Thus, the architecture of a software system is a metaphor similar to the architecture of a building; it is a set of important decisions about the organization of a software system. On a small scale, every single building may look okay, but they may not fit together well. Similarly, while software architecture aims to create a well-structured system, software development might progress in unexpected ways.

Keep in mind that whether you put thought into it or not, when writing software, you are creating an architecture. Therefore, avoid accidental architectures—those that arise without a clear strategy—as this can disrupt your IT systems.

On the other hand, emerging architectures—those that emerge gradually from the multitude of design decisions—are inevitable as systems grow. Over time, they become explicitly identified and are implemented intentionally after proving themselves.

So, what exactly should you be creating if you want to mindfully define the architecture of your solution? The Software Engineering Institute has this to say:

The software architecture of a system is the set of structures needed to reason about the system, which comprise software elements, relations among them, and properties of both.

In the following section, we will discuss different types of architectures and explore how software architecture fits within a broader context. A clear understanding of the architecture type helps in correctly identifying the elements involved and defining the scope of work instead of just hopping into writing code.

Different ways to look at architecture

There are several ways to look at architecture, each with a different scope:

• Enterprise architecture deals with the whole company or even a group of companies. It takes a holistic approach and is concerned about the strategy of whole enterprises. When thinking about enterprise architecture, you should be looking at how all the systems in a company behave and cooperate with each other. It’s concerned with the alignment between business and IT.
• Solution architecture is less abstract than its enterprise counterpart. It stands somewhere in the middle between enterprise and software architecture. Usually, solution architecture is concerned with one specific system and the way it interacts with its surroundings. A solution architect needs to come up with a way to fulfill a specific business need, usually by designing a whole software system or modifying existing ones.
• Software architecture is even more concrete than solution architecture. It concentrates on a specific project, the technologies it uses, and how it interacts with other projects. A software architect is interested in the internals of the project’s components.
• Infrastructure architecture is, as the name suggests, concerned with the infrastructure that the software will use. It defines the deployment environment and strategy, how the application will scale, failover handling, site reliability, and other infrastructure-oriented aspects.

Solution architecture is based on both software and infrastructure architectures to satisfy the business requirements. Later in this chapter, we will talk about key principles of software architecture to prepare you for both small- and large-scale architecture design. Let’s now discuss another critical aspect of understanding software architecture.

Communication and culture

The focus of this book is software architecture. Why would we want to mention communication and culture in a book around software, then? If you think about it, all software is written people people. The human aspect is prevalent, and yet we often fail to admit it.

As an architect, your role won’t be just about figuring out the best approach to solving a given problem. You’ll also have to communicate your proposed solution to your team members. Often, the choices you make will result from previous discussions.

These are the reasons communication and team culture also play a role in software architecture.

Conway’s Law states that the architecture of the software system reflects the organization that’s working on it. This means that building great products requires building great teams and understanding that social interaction impacts the success or failure of projects.

Development culture can be compared to an ecosystem. It is a daily task and cannot be introduced by decree. The culture can become destructive if you don’t take care of it. Poor management can degrade even a well-established team culture...