Software architecture with c++ : design modern systems using effective architecture concepts, design patterns and techniques with c++20 / Adrian Ostrowski, Piotr Gaczkowski.

Format:

Book

Author/Creator:

Ostrowski, Adrian, author.

Gaczkowski, Piotr, author.

Language:

English

Subjects (All):

Software architecture.

C++ (Computer program language).

Physical Description:

1 online resource (522 pages) : illustrations

Place of Publication:

Birmingham, England : Packt Publishing, Limited, [2021]

Biography/History:

Ostrowski Adrian: Adrian Ostrowski is a modern C++ enthusiast interested in the development of both the C++ language itself and the high-quality code written in it. A lifelong learner with over a decade of experience in the IT industry and more than 8 years of experience with C++ specifically, he's always eager to share his knowledge. His past projects range from parallel computing, through fiber networking, to working on a commodity exchange's trading system. Currently, he's one of the architects of Intel and Habana's integration with machine learning frameworks. Gaczkowski Piotr: Piotr Gaczkowski has more than 10 years of experience in programming and practicing DevOps and uses his skills to improve people's lives. He likes building simple solutions to human problems, organizing cultural events, and teaching fellow professionals. Piotr is keen on automating boring activities and using his experience to share knowledge by conducting courses and writing articles about personal growth and remote work. He has worked in the IT industry both in full-time positions and as a freelancer, but his true passion is music. When not making his skills useful at work, you can find him building communities. In his spare time, Adrian used to promote music bands together with Piotr and has learned how to fly a glider. Currently, he likes riding his bicycle, going to music events, and browsing memes.

Summary:

Apply business requirements to IT infrastructure and deliver a high-quality product by understanding architectures such as microservices, DevOps, and cloud-native using modern C++ standards and featuresKey FeaturesDesign scalable large-scale applications with the C++ programming languageArchitect software solutions in a cloud-based environment with continuous integration and continuous delivery (CI/CD)Achieve architectural goals by leveraging design patterns, language features, and useful toolsBook DescriptionSoftware architecture refers to the high-level design of complex applications. It is evolving just like the languages we use, but there are architectural concepts and patterns that you can learn to write high-performance apps in a high-level language without sacrificing readability and maintainability. If you're working with modern C++, this practical guide will help you put your knowledge to work and design distributed, large-scale apps. You'll start by getting up to speed with architectural concepts, including established patterns and rising trends, then move on to understanding what software architecture actually is and start exploring its components. Next, you'll discover the design concepts involved in application architecture and the patterns in software development, before going on to learn how to build, package, integrate, and deploy your components. In the concluding chapters, you'll explore different architectural qualities, such as maintainability, reusability, testability, performance, scalability, and security. Finally, you will get an overview of distributed systems, such as service-oriented architecture, microservices, and cloud-native, and understand how to apply them in application development. By the end of this book, you'll be able to build distributed services using modern C++ and associated tools to deliver solutions as per your clients' requirements.What you will learnUnderstand how to apply the principles of software architectureApply design patterns and best practices to meet your architectural goalsWrite elegant, safe, and performant code using the latest C++ featuresBuild applications that are easy to maintain and deployExplore the different architectural approaches and learn to apply them as per your requirementSimplify development and operations using application containersDiscover various techniques to solve common problems in software design and developmentWho this book is forThis software architecture C++ programming book is for experienced C++ developers looking to become software architects or develop enterprise-grade applications.

Contents:

Cover

Title Page

Copyrights

Dedication

Contributors

Table of Contents

Preface

Section 1: Concepts and Components of Software Architecture

Chapter 1: Importance of Software Architecture and Principles of Great Design

Technical requirements

Understanding software architecture

Different ways to look at architecture

Learning the importance of proper architecture

Software decay

Accidental architecture

Exploring the fundamentals of good architecture

Architecture context

Stakeholders

Business and technical environments

Developing architecture using Agile principles

Domain-driven design

The philosophy of C++

Following the SOLID and DRY principles

Single responsibility principle

Open-closed principle

Liskov substitution principle

Interface segregation principle

Dependency inversion principle

The DRY rule

Coupling and cohesion

Coupling

Cohesion

Summary

Questions

Further reading

Chapter 2: Architectural Styles

Deciding between stateful and stateless approaches

Stateless and stateful services

Understanding monoliths-why they should be avoided, and recognizing exceptions

Understanding services and microservices

Microservices

Benefits and disadvantages of microservices

Characteristics of microservices

Microservices and other architectural styles

Scaling microservices

Transitioning to microservices

Exploring event-based architecture

Common event-based topologies

Event sourcing

Understanding layered architecture

Backends for Frontends

Learning module-based architecture

Chapter 3: Functional and Nonfunctional Requirements

Technical requirements documentation from sources, you must have

Understanding the types of requirements.

Functional requirements

Nonfunctional requirements

Quality attributes

Constraints

Recognizing architecturally significant requirements

Indicators of architectural significance

Hindrances in recognizing ASRs and how to deal with them

Gathering requirements from various sources

Knowing the context

Knowing existing documentation

Knowing your stakeholders

Gathering requirements from stakeholders

Documenting requirements

Documenting the context

Documenting the scope

Documenting functional requirements

Documenting nonfunctional requirements

Managing the version history of your documentation

Documenting requirements in Agile projects

Other sections

Documenting architecture

Understanding the 4+1 model

Understanding the C4 model

Documenting architecture in Agile projects

Choosing the right views to document

Functional view

Information view

Concurrency view

Development view

Deployment and operational views

Generating documentation

Generating requirements documentation

Generating diagrams from code

Generating (API) documentation from code

Section 2: The Design and Development of C++ Software

Chapter 4: Architectural and System Design

Understanding the peculiarities of distributed systems

Different service models and when to use them

On-premises model

Infrastructure as a Service (IaaS) model

Platform as a Service (PaaS) model

Software as a Service (SaaS) model

Function as a Service (FaaS) model and serverless architecture

Avoiding the fallacies of distributed computing

The network is reliable

Latency is zero

Bandwidth is infinite

The network is secure

Topology doesn't change

There is one administrator

Transport cost is zero.

The network is homogeneous

CAP theorem and eventual consistency

Sagas and compensating transactions

Choreography-based sagas

Orchestration-based sagas

Making your system fault tolerant and available

Calculating your system's availability

Building fault-tolerant systems

Redundancy

Leader election

Consensus

Replication

Master-slave replication

Multi-master replication

Queue-based load leveling

Back pressure

Detecting faults

Sidecar design pattern

Heartbeat mechanism

Leaky bucket counter

Minimizing the impact of faults

Retrying the call

Avoiding cascading failures

Circuit breaker

Bulkhead

Geodes

Integrating your system

Pipes and filters pattern

Competing consumers

Transitioning from legacy systems

Anti-corruption layer

Strangler pattern

Achieving performance at scale

CQRS and event sourcing

Command-query responsibility segregation

Command-query separation

Caching

Updating caches

Write-through approach

Write-behind approach

Cache-aside

Deploying your system

The sidecar pattern

Deploying a service with tracing and a reverse proxy using Envoy

Zero-downtime deployments

Blue-green deployments

Canary releases

External configuration store

Managing your APIs

API gateways

Chapter 5: Leveraging C++ Language Features

Designing great APIs

Leveraging RAII

Specifying the interfaces of containers in C++

Using pointers in interfaces

Specifying preconditions and postconditions

Leveraging inline namespaces

Leveraging std::optional

Optional function parameters

Optional function return values

Optional class members

Writing declarative code

Showcasing a featured items gallery

Introducing standard ranges.

Reducing memory overhead and increasing performance using ranges

Moving computations at compile time

Helping the compiler help you by using const

Leveraging the power of safe types

Constraining template parameters

Writing modular C++

Chapter 6: Design Patterns and C++

Writing idiomatic C++

Automating scope exit actions using RAII guards

Managing copyability and movability

Implementing non-copyable types

Adhering to the rules of three and five

Adhering to the rule of zero

Using hidden friends

Providing exception safety using the copy-and-swap idiom

Writing niebloids

Policy-based design idiom

Curiously recurring template pattern

Knowing when to use dynamic versus static polymorphism

Implementing static polymorphism

Interlude - using type erasure

Creating objects

Using factories

Using factory methods

Using factory functions

Choosing the return type of a factory

Using factory classes

Using builders

Building with composites and prototypes

Tracking state and visiting objects in C++

Dealing with memory efficiently

Reducing dynamic allocations using SSO/SOO

Saving memory by herding COWs

Leveraging polymorphic allocators

Using memory arenas

Using the monotonic memory resource

Using pool resources

Writing your own memory resource

Ensuring there are no unexpected allocations

Winking out memory

Chapter 7: Building and Packaging

Getting the most out of compilers

Using multiple compilers

Reducing build times

Using a fast compiler

Rethinking templates

Leveraging tools

Finding potential code issues

Using compiler-centric tools

Abstracting the build process

Introducing CMake.

Creating CMake projects

Distinguishing between CMake directory variables

Specifying CMake targets

Specifying the output directories

Using generator expressions

Using external modules

Fetching dependencies

Using find scripts

Writing find scripts

Using the Conan package manager

Preparing Conan profiles

Specifying Conan dependencies

Installing Conan dependencies

Using Conan targets from CMake

Adding tests

Reusing quality code

Installing

Exporting

Using CPack

Packaging using Conan

Creating the conanfile.py script

Testing our Conan package

Adding Conan packaging code to our CMakeLists

Section 3: Architectural Quality Attributes

Chapter 8: Writing Testable Code

Why do you test code?

The testing pyramid

Non-functional testing

Regression testing

Root cause analysis

The groundwork for further improvement

Introducing testing frameworks

GTest examples

Catch2 examples

CppUnit examples

Doctest examples

Testing compile-time code

Understanding mocks and fakes

Different test doubles

Other uses for test doubles

Writing test doubles

GoogleMock example

Trompeloeil example

Test-driven class design

When tests and class design clash

Defensive programming

The boring refrain - write your tests first

Automating tests for continuous integration/continuous deployment

Testing the infrastructure

Testing with Serverspec

Testing with Testinfra

Testing with Goss

Chapter 9: Continuous Integration and Continuous Deployment

Understanding CI

Release early, release often

Merits of CI

Gating mechanism

Implementing the pipeline with GitLab

Reviewing code changes.

Automated gating mechanisms.

Notes:

Includes index.

Description based on print version record.

ISBN:

9781789612462

1789612462

OCLC:

1247671849