book

Software Architecture with C++

Name: Software Architecture with C++
ISBN: 9781838554590

by Adrian Ostrowski, Piotr Gaczkowski

April 2021

Intermediate to advanced

540 pages

12h 3m

English

Packt Publishing

Read now

Unlock full access

Title Page
Copyrights
Software Architecture with C++
Dedication
Contributors
About the authorsAbout the reviewer
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesDownload the color imagesConventions usedGet in touchReviews
Section 1: Concepts and Components of Software Architecture
Importance of Software Architecture and Principles of Great Design
Technical requirementsUnderstanding software architectureDifferent ways to look at architectureLearning the importance of proper architectureSoftware decayAccidental architectureExploring the fundamentals of good architectureArchitecture contextStakeholdersBusiness and technical environmentsDeveloping architecture using Agile principlesDomain-driven designThe philosophy of C++Following the SOLID and DRY principlesSingle responsibility principleOpen-closed principleLiskov substitution principleInterface segregation principleDependency inversion principleThe DRY ruleCoupling and cohesionCouplingCohesionSummaryQuestionsFurther reading
Architectural Styles
Technical requirementsDeciding between stateful and stateless approachesStateless and stateful servicesUnderstanding monoliths—why they should be avoided, and recognizing exceptionsUnderstanding services and microservicesMicroservicesBenefits and disadvantages of microservicesCharacteristics of microservicesMicroservices and other architectural stylesScaling microservicesTransitioning to microservicesExploring event-based architectureCommon event-based topologiesEvent sourcingUnderstanding layered architectureBackends for FrontendsLearning module-based architectureSummaryQuestionsFurther reading
Functional and Nonfunctional Requirements
Technical requirements documentation from sources, you must haveUnderstanding the types of requirementsFunctional requirementsNonfunctional requirementsQuality attributesConstraintsRecognizing architecturally significant requirementsIndicators of architectural significanceHindrances in recognizing ASRs and how to deal with themGathering requirements from various sourcesKnowing the contextKnowing existing documentationKnowing your stakeholdersGathering requirements from stakeholdersDocumenting requirementsDocumenting the contextDocumenting the scopeDocumenting functional requirementsDocumenting nonfunctional requirementsManaging the version history of your documentationDocumenting requirements in Agile projects Other sectionsDocumenting architectureUnderstanding the 4+1 modelUnderstanding the C4 modelDocumenting architecture in Agile projectsChoosing the right views to documentFunctional viewInformation viewConcurrency viewDevelopment viewDeployment and operational viewsGenerating documentationGenerating requirements documentationGenerating diagrams from codeGenerating (API) documentation from codeSummaryQuestionsFurther reading
Section 2: The Design and Development of C++ Software

Architectural and System Design
Technical requirementsUnderstanding the peculiarities of distributed systemsDifferent service models and when to use themOn-premises modelInfrastructure as a Service (IaaS) modelPlatform as a Service (PaaS) modelSoftware as a Service (SaaS) modelFunction as a Service (FaaS) model and serverless architecture Avoiding the fallacies of distributed computingThe network is reliableLatency is zeroBandwidth is infiniteThe network is secureTopology doesn't changeThere is one administratorTransport cost is zeroThe network is homogeneousCAP theorem and eventual consistencySagas and compensating transactionsChoreography-based sagasOrchestration-based sagasMaking your system fault tolerant and availableCalculating your system's availabilityBuilding fault-tolerant systemsRedundancyLeader electionConsensusReplicationMaster-slave replicationMulti-master replicationQueue-based load levelingBack pressureDetecting faultsSidecar design patternHeartbeat mechanismLeaky bucket counterMinimizing the impact of faultsRetrying the callAvoiding cascading failuresCircuit breakerBulkheadGeodesIntegrating your systemPipes and filters patternCompeting consumersTransitioning from legacy systemsAnti-corruption layerStrangler patternAchieving performance at scaleCQRS and event sourcingCommand-query responsibility segregationCommand-query separationEvent sourcingCachingUpdating cachesWrite-through approachWrite-behind approachCache-asideDeploying your systemThe sidecar patternDeploying a service with tracing and a reverse proxy using EnvoyZero-downtime deploymentsBlue-green deploymentsCanary releasesExternal configuration storeManaging your APIsAPI gatewaysSummaryQuestionsFurther reading
Leveraging C++ Language Features
Technical requirementsDesigning great APIsLeveraging RAIISpecifying the interfaces of containers in C++Using pointers in interfacesSpecifying preconditions and postconditionsLeveraging inline namespacesLeveraging std::optionalOptional function parametersOptional function return valuesOptional class membersWriting declarative codeShowcasing a featured items galleryIntroducing standard rangesReducing memory overhead and increasing performance using rangesMoving computations at compile timeHelping the compiler help you by using constLeveraging the power of safe typesConstraining template parametersWriting modular C++SummaryQuestionsFurther reading
Design Patterns and C++
Technical requirementsWriting idiomatic C++Automating scope exit actions using RAII guardsManaging copyability and movabilityImplementing non-copyable typesAdhering to the rules of three and fiveAdhering to the rule of zeroUsing hidden friendsProviding exception safety using the copy-and-swap idiomWriting niebloidsPolicy-based design idiomCuriously recurring template patternKnowing when to use dynamic versus static polymorphismImplementing static polymorphismInterlude – using type erasureCreating objectsUsing factoriesUsing factory methodsUsing factory functionsChoosing the return type of a factoryUsing factory classesUsing buildersBuilding with composites and prototypesTracking state and visiting objects in C++Dealing with memory efficientlyReducing dynamic allocations using SSO/SOOSaving memory by herding COWsLeveraging polymorphic allocatorsUsing memory arenasUsing the monotonic memory resourceUsing pool resourcesWriting your own memory resourceEnsuring there are no unexpected allocationsWinking out memorySummaryQuestionsFurther reading
Building and Packaging
Technical requirementsGetting the most out of compilersUsing multiple compilersReducing build timesUsing a fast compilerRethinking templatesLeveraging toolsFinding potential code issuesUsing compiler-centric toolsAbstracting the build processIntroducing CMakeCreating CMake projectsDistinguishing between CMake directory variablesSpecifying CMake targetsSpecifying the output directoriesUsing generator expressionsUsing external modulesFetching dependenciesUsing find scriptsWriting find scriptsUsing the Conan package managerPreparing Conan profilesSpecifying Conan dependenciesInstalling Conan dependenciesUsing Conan targets from CMakeAdding testsReusing quality codeInstallingExportingUsing CPackPackaging using ConanCreating the conanfile.py scriptTesting our Conan packageAdding Conan packaging code to our CMakeListsSummaryQuestionsFurther reading
Section 3: Architectural Quality Attributes
Writing Testable Code
Technical requirementsWhy do you test code?The testing pyramidNon-functional testingRegression testingRoot cause analysisThe groundwork for further improvementIntroducing testing frameworksGTest examplesCatch2 examplesCppUnit examplesDoctest examplesTesting compile-time codeUnderstanding mocks and fakesDifferent test doublesOther uses for test doublesWriting test doublesGoogleMock exampleTrompeloeil exampleTest-driven class designWhen tests and class design clashDefensive programmingThe boring refrain – write your tests firstAutomating tests for continuous integration/continuous deploymentTesting the infrastructureTesting with ServerspecTesting with TestinfraTesting with GossSummaryQuestionsFurther reading
Continuous Integration and Continuous Deployment
Technical requirementsUnderstanding CIRelease early, release oftenMerits of CIGating mechanismImplementing the pipeline with GitLabReviewing code changesAutomated gating mechanismsCode review – the manual gating mechanismDifferent approaches to a code reviewUsing pull requests (merge requests) for a code reviewExploring test-driven automationBehavior-driven developmentWriting tests for CIContinuous testingManaging deployment as codeUsing AnsibleHow Ansible fits with the CI/CD pipelineUsing components to create deployment codeBuilding deployment codeBuilding a CD pipelineContinuous deployment and continuous deliveryBuilding an example CD pipelineUsing immutable infrastructureWhat is immutable infrastructure?The benefits of immutable infrastructureBuilding instance images with PackerOrchestrating the infrastructure with TerraformSummaryQuestionsFurther reading
Security in Code and Deployment
Technical requirementsChecking the code securitySecurity-conscious designMaking interfaces easy to use and hard to misuseEnabling automatic resource managementDrawbacks of concurrency and how to deal with itSecure coding, the guidelines, and GSLDefensive coding, validating everythingThe most common vulnerabilitiesChecking whether the dependencies are secureCommon Vulnerabilities and ExposuresAutomated scannersAutomated dependency upgrade managementHardening your codeSecurity-oriented memory allocatorAutomated checksCompiler warningsStatic analysisDynamic analysisValgrind and Application VerifierSanitizersFuzz-testingProcess isolation and sandboxingHardening your environmentStatic versus dynamic linkingAddress space layout randomizationDevSecOpsSummaryQuestionsFurther reading
Performance
Technical requirementsMeasuring performancePerforming accurate and meaningful measurementsLeveraging different types of measuring toolsUsing microbenchmarksSetting up Google BenchmarkWriting your first microbenchmarkPassing arbitrary arguments to a microbenchmarkPassing numeric arguments to a microbenchmarkGenerating the passed arguments programmaticallyChoosing what to microbenchmark and optimizeCreating performance tests using benchmarksProfilingChoosing the type of profiler to usePreparing the profiler and processing the resultsAnalyzing the resultsTracingCorrelation IDsHelping the compiler generate performant codeOptimizing whole programsOptimizing based on real-world usage patternsWriting cache-friendly codeDesigning your code with data in mindParallelizing computationsUnderstanding the differences between threads and processesUsing the standard parallel algorithmsParallelizing computations using OpenMP and MPIUsing coroutinesDistinguishing between cppcoro utilitiesLooking under the hood of awaitables and coroutinesSummaryQuestionsFurther reading
Section 4: Cloud-Native Design Principles
Service-Oriented Architecture
Technical requirementsUnderstanding Service-Oriented ArcitectureImplementation approachesEnterprise Service BusWeb servicesBenefits and disadvantages of web servicesMessaging and streamingMessage queuesMessage brokersCloud computingMicroservicesBenefits of Service-Oriented ArchitectureChallenges with SOAAdopting messaging principlesLow-overhead messaging systemsMQTTZeroMQBrokered messaging systemsUsing web servicesTools for debugging web servicesXML-based web servicesXML-RPCRelationship to SOAPSOAPWSDLUDDISOAP librariesJSON-based web servicesJSON-RPCREpresentational State Transfer (REST)Description languagesOpenAPIRAMLAPI BlueprintRSDLHypermedia as the Engine of Application StateREST in C++GraphQLLeveraging managed services and cloud providersCloud computing as an extension of SOAUsing API calls directlyUsing API calls through a CLI toolUsing third-party tools that interact with the Cloud APIAccessing the cloud APIUsing the cloud CLIUsing tools that interact with the Cloud APICloud-native architectureSummaryQuestionsFurther reading
Designing Microservices
Technical requirementsDiving into microservicesThe benefits of microservicesModularityScalabilityFlexibilityIntegration with legacy systemsDistributed developmentDisadvantages of microservicesReliance on a mature DevOps approachHarder to debugAdditional overheadDesign patterns for microservicesDecomposition patternsDecomposition by business capabilityDecomposition by subdomainDatabase per service patternDeployment strategiesSingle service per hostMultiple services per hostObservability patternsLog aggregationApplication metricsDistributed tracingHealth check APIsBuilding microservicesOutsourcing memory managementMemcachedRedisWhich in-memory cache is better?Outsourcing storageOutsourcing computingObserving microservicesLoggingLogging with microservicesLogging in C++ with spdlogUnified logging layerLogstashFilebeatFluentdFluent BitVectorLog aggregationElasticsearchLokiLog visualizationKibanaGrafanaMonitoringTracingOpenTracingJaegerOpenZipkinIntegrated observability solutionsConnecting microservicesApplication programming interfaces (APIs)Remote procedure callsApache ThriftgRPCScaling microservicesScaling a single service per host deploymentScaling multiple services per host deploymentSummaryQuestionsFurther reading
Containers
Technical requirementsReintroducing containersExploring the container typesThe rise of microservicesChoosing when to use containersThe benefits of containersThe disadvantages of containersBuilding containersContainer images explainedUsing Dockerfiles to build an applicationNaming and distributing imagesCompiled applications and containersTargeting multiple architectures with manifestsAlternative ways to build application containersBuildahAnsible-benderOthersIntegrating containers with CMakeConfiguring the Dockerfile with CMakeIntegrating containers with CMakeTesting and integrating containersRuntime libraries inside containersAlternative container runtimesUnderstanding container orchestrationSelf-hosted solutionsKubernetesDocker SwarmNomadOpenShiftManaged servicesAWS ECSAWS FargateAzure Service FabricSummaryQuestionsFurther reading
Cloud-Native Design
Technical requirementsUnderstanding cloud-nativeCloud-Native Computing FoundationCloud as an operating systemLoad balancing and service discoveryReverse proxiesService DiscoveryUsing Kubernetes to orchestrate cloud-native workloadsKubernetes structureControl planeWorker nodesPossible approaches to deploying KubernetesUnderstanding the Kubernetes conceptsDeclarative approachKubernetes networkingContainer-to-container communicationPod-to-pod communicationPod-to-service communicationExternal-to-internal communicationWhen is using Kubernetes a good idea?Observability in distributed systemsHow tracing differs from loggingChoosing a tracing solutionJaeger and OpenTracingZipkinInstrumenting an application with OpenTracingConnecting services with a service meshIntroducing a service meshService mesh solutionsIstioEnvoyLinkerdConsul service meshGoing GitOpsThe principles of GitOpsDeclarative descriptionThe system's state versioned in GitAuditableIntegrated with established componentsConfiguration drift preventionThe benefits of GitOpsIncreased productivityBetter developer experienceHigher stability and reliabilityImproved securityGitOps toolsFluxCDArgoCDJenkins XSummaryQuestionsFurther reading
Appendix A
Designing data storageWhich NoSQL technology should I use?Serverless architectureCommunication and cultureDevOps
Assessments
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10Chapter 11Chapter 12Chapter 13Chapter 14Chapter 15
About Packt
Why subscribe?
Other Books You May Enjoy
Packt is searching for authors like youLeave a review - let other readers know what you think

Content preview from Software Architecture with C++

Writing Testable Code

The ability to test code is the most important quality of any software product. Without proper testing, it is prohibitively expensive to refactor the code or to improve any other part of it, such as its security, scalability, or performance. In this chapter, we'll learn how to design and manage automated tests and how to correctly use fakes and mocks when it is necessary to do so.

The following topics will be covered in this chapter:

Why do you test code?
Introducing testing frameworks
Understanding mocks and fakes
Test-driven class design
Automating tests for continuous integration/continuous deployment

Technical requirements

The sample code for this chapter can be found at https://github.com/PacktPublishing/Software-Architecture-with-Cpp/tree/master/Chapter08 ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781838554590

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages