Software architecture with c++ : design modern systems using effective architecture concepts, design patterns and techniques with c++20

Software architecture with c++ design modern systems using effective architecture concepts, design patterns and techniques with c++20

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 so...

Descripción completa

Detalles Bibliográficos
Otros Autores: Ostrowski, Adrian, author (author), Gaczkowski, Piotr, author
Formato: Libro electrónico
Idioma:Inglés
Publicado: Birmingham, England : Packt Publishing, Limited [2021]
Materias:
Software architecture.
C++ (Computer program language)
Ver en Biblioteca Universitat Ramon Llull:https://discovery.url.edu/permalink/34CSUC_URL/1im36ta/alma991009631685806719
Tabla de Contenidos:
  • 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
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • 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
  • Summary
  • Questions
  • Further reading
  • Section 2: The Design and Development of C++ Software
  • Chapter 4: Architectural and System Design
  • Technical requirements
  • 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
  • Event sourcing
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 5: Leveraging C++ Language Features
  • Technical requirements
  • 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++
  • Summary
  • Questions
  • Further reading
  • Chapter 6: Design Patterns and C++
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 7: Building and Packaging
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Section 3: Architectural Quality Attributes
  • Chapter 8: Writing Testable Code
  • Technical requirements
  • 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
  • Summary
  • Questions
  • Further reading
  • Chapter 9: Continuous Integration and Continuous Deployment
  • Technical requirements
  • Understanding CI
  • Release early, release often
  • Merits of CI
  • Gating mechanism
  • Implementing the pipeline with GitLab
  • Reviewing code changes.
  • Automated gating mechanisms.

Ejemplares similares