Search icon Close icon
Search icon
Subscription
0
Cart icon
Close icon
You have no products in your basket yet
Arrow left icon
All Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Newsletters
Free Learning
Arrow right icon
Home > Programming > Software Architecture with C++
Back Programming
Software Architecture with C++
Software Architecture with C++

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

By Adrian Ostrowski , Piotr Gaczkowski
Mex$902.99 Mex$631.99
Book Apr 2021 540 pages 1st Edition
eBook
Mex$902.99 Mex$631.99
Print
Mex$1,128.99
Audiobook
Mex$676.99
Subscription
Free Trial
eBook
Mex$902.99 Mex$631.99
Print
Mex$1,128.99
Audiobook
Mex$676.99
Subscription
Free Trial

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Buy Now

Product Details

Publication date : Apr 23, 2021
Length 540 pages
Edition : 1st Edition
Language : English
ISBN-13 : 9781838554590
Category :
Programming
Languages :
C++ (Expert)
Concepts :
Software Architecture
Table of content icon View table of contents Preview book icon Preview Book

Software Architecture with C++

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 introduce a domain-driven approach for both code and architecture.

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

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

Technical requirements

Left arrow icon

Page 1 of 27

Right arrow icon
Download code icon Download Code

Key benefits

  • Design scalable large-scale applications with the C++ programming language
  • Architect 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 tools

Description

Software 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 learn

Understand how to apply the principles of software architecture Apply design patterns and best practices to meet your architectural goals Write elegant, safe, and performant code using the latest C++ features Build applications that are easy to maintain and deploy Explore the different architectural approaches and learn to apply them as per your requirement Simplify development and operations using application containers Discover various techniques to solve common problems in software design and development

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Buy Now

Product Details

Publication date : Apr 23, 2021
Length 540 pages
Edition : 1st Edition
Language : English
ISBN-13 : 9781838554590
Category :
Programming
Languages :
C++ (Expert)
Concepts :
Software Architecture

Table of Contents

24 Chapters
Preface Chevron down icon Chevron up icon
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
1. Section 1: Concepts and Components of Software Architecture Chevron down icon Chevron up icon
Section 1: Concepts and Components of Software Architecture
2. Importance of Software Architecture and Principles of Great Design Chevron down icon Chevron up icon
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
3. Architectural Styles Chevron down icon Chevron up icon
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
4. Functional and Nonfunctional Requirements Chevron down icon Chevron up icon
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
5. Section 2: The Design and Development of C++ Software Chevron down icon Chevron up icon
Section 2: The Design and Development of C++ Software
6. Architectural and System Design Chevron down icon Chevron up icon
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
7. Leveraging C++ Language Features Chevron down icon Chevron up icon
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
8. Design Patterns and C++ Chevron down icon Chevron up icon
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
9. Building and Packaging Chevron down icon Chevron up icon
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
10. Section 3: Architectural Quality Attributes Chevron down icon Chevron up icon
Section 3: Architectural Quality Attributes
11. Writing Testable Code Chevron down icon Chevron up icon
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
12. Continuous Integration and Continuous Deployment Chevron down icon Chevron up icon
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
Code review – the manual gating mechanism
Different approaches to a code review
Using pull requests (merge requests) for a code review
Exploring test-driven automation
Behavior-driven development
Writing tests for CI
Continuous testing
Managing deployment as code
Using Ansible
How Ansible fits with the CI/CD pipeline
Using components to create deployment code
Building deployment code
Building a CD pipeline
Continuous deployment and continuous delivery
Building an example CD pipeline
Using immutable infrastructure
What is immutable infrastructure?
The benefits of immutable infrastructure
Building instance images with Packer
Orchestrating the infrastructure with Terraform
Summary
Questions
Further reading
13. Security in Code and Deployment Chevron down icon Chevron up icon
Security in Code and Deployment
Technical requirements
Checking the code security
Security-conscious design
Making interfaces easy to use and hard to misuse
Enabling automatic resource management
Drawbacks of concurrency and how to deal with it
Secure coding, the guidelines, and GSL
Defensive coding, validating everything
The most common vulnerabilities
Checking whether the dependencies are secure
Common Vulnerabilities and Exposures
Automated scanners
Automated dependency upgrade management
Hardening your code
Security-oriented memory allocator
Automated checks
Compiler warnings
Static analysis
Dynamic analysis
Valgrind and Application Verifier
Sanitizers
Fuzz-testing
Process isolation and sandboxing
Hardening your environment
Static versus dynamic linking
Address space layout randomization
DevSecOps
Summary
Questions
Further reading
14. Performance Chevron down icon Chevron up icon
Performance
Technical requirements
Measuring performance
Performing accurate and meaningful measurements
Leveraging different types of measuring tools
Using microbenchmarks
Setting up Google Benchmark
Writing your first microbenchmark
Passing arbitrary arguments to a microbenchmark
Passing numeric arguments to a microbenchmark
Generating the passed arguments programmatically
Choosing what to microbenchmark and optimize
Creating performance tests using benchmarks
Profiling
Choosing the type of profiler to use
Preparing the profiler and processing the results
Analyzing the results
Tracing
Correlation IDs
Helping the compiler generate performant code
Optimizing whole programs
Optimizing based on real-world usage patterns
Writing cache-friendly code
Designing your code with data in mind
Parallelizing computations
Understanding the differences between threads and processes
Using the standard parallel algorithms
Parallelizing computations using OpenMP and MPI
Using coroutines
Distinguishing between cppcoro utilities
Looking under the hood of awaitables and coroutines
Summary
Questions
Further reading
15. Section 4: Cloud-Native Design Principles Chevron down icon Chevron up icon
Section 4: Cloud-Native Design Principles
16. Service-Oriented Architecture Chevron down icon Chevron up icon
Service-Oriented Architecture
Technical requirements
Understanding Service-Oriented Arcitecture
Implementation approaches
Enterprise Service Bus
Web services
Benefits and disadvantages of web services
Messaging and streaming
Message queues
Message brokers
Cloud computing
Microservices
Benefits of Service-Oriented Architecture
Challenges with SOA
Adopting messaging principles
Low-overhead messaging systems
MQTT
ZeroMQ
Brokered messaging systems
Using web services
Tools for debugging web services
XML-based web services
XML-RPC
Relationship to SOAP
SOAP
WSDL
UDDI
SOAP libraries
JSON-based web services
JSON-RPC
REpresentational State Transfer (REST)
Description languages
OpenAPI
RAML
API Blueprint
RSDL
Hypermedia as the Engine of Application State
REST in C++
GraphQL
Leveraging managed services and cloud providers
Cloud computing as an extension of SOA
Using API calls directly
Using API calls through a CLI tool
Using third-party tools that interact with the Cloud API
Accessing the cloud API
Using the cloud CLI
Using tools that interact with the Cloud API
Cloud-native architecture
Summary
Questions
Further reading
17. Designing Microservices Chevron down icon Chevron up icon
Designing Microservices
Technical requirements
Diving into microservices
The benefits of microservices
Modularity
Scalability
Flexibility
Integration with legacy systems
Distributed development
Disadvantages of microservices
Reliance on a mature DevOps approach
Harder to debug
Additional overhead
Design patterns for microservices
Decomposition patterns
Decomposition by business capability
Decomposition by subdomain
Database per service pattern
Deployment strategies
Single service per host
Multiple services per host
Observability patterns
Log aggregation
Application metrics
Distributed tracing
Health check APIs
Building microservices
Outsourcing memory management
Memcached
Redis
Which in-memory cache is better?
Outsourcing storage
Outsourcing computing
Observing microservices
Logging
Logging with microservices
Logging in C++ with spdlog
Unified logging layer
Logstash
Filebeat
Fluentd
Fluent Bit
Vector
Log aggregation
Elasticsearch
Loki
Log visualization
Kibana
Grafana
Monitoring
Tracing
OpenTracing
Jaeger
OpenZipkin
Integrated observability solutions
Connecting microservices
Application programming interfaces (APIs)
Remote procedure calls
Apache Thrift
gRPC
Scaling microservices
Scaling a single service per host deployment
Scaling multiple services per host deployment
Summary
Questions
Further reading
18. Containers Chevron down icon Chevron up icon
Containers
Technical requirements
Reintroducing containers
Exploring the container types
The rise of microservices
Choosing when to use containers
The benefits of containers
The disadvantages of containers
Building containers
Container images explained
Using Dockerfiles to build an application
Naming and distributing images
Compiled applications and containers
Targeting multiple architectures with manifests
Alternative ways to build application containers
Buildah
Ansible-bender
Others
Integrating containers with CMake
Configuring the Dockerfile with CMake
Integrating containers with CMake
Testing and integrating containers
Runtime libraries inside containers
Alternative container runtimes
Understanding container orchestration
Self-hosted solutions
Kubernetes
Docker Swarm
Nomad
OpenShift
Managed services
AWS ECS
AWS Fargate
Azure Service Fabric
Summary
Questions
Further reading
19. Cloud-Native Design Chevron down icon Chevron up icon
Cloud-Native Design
Technical requirements
Understanding cloud-native
Cloud-Native Computing Foundation
Cloud as an operating system
Load balancing and service discovery
Reverse proxies
Service Discovery
Using Kubernetes to orchestrate cloud-native workloads
Kubernetes structure
Control plane
Worker nodes
Possible approaches to deploying Kubernetes
Understanding the Kubernetes concepts
Declarative approach
Kubernetes networking
Container-to-container communication
Pod-to-pod communication
Pod-to-service communication
External-to-internal communication
When is using Kubernetes a good idea?
Observability in distributed systems
How tracing differs from logging
Choosing a tracing solution
Jaeger and OpenTracing
Zipkin
Instrumenting an application with OpenTracing
Connecting services with a service mesh
Introducing a service mesh
Service mesh solutions
Istio
Envoy
Linkerd
Consul service mesh
Going GitOps
The principles of GitOps
Declarative description
The system's state versioned in Git
Auditable
Integrated with established components
Configuration drift prevention
The benefits of GitOps
Increased productivity
Better developer experience
Higher stability and reliability
Improved security
GitOps tools
FluxCD
ArgoCD
Jenkins X
Summary
Questions
Further reading
20. Assessments Chevron down icon Chevron up icon
Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13
Chapter 14
Chapter 15
21. About Packt Chevron down icon Chevron up icon
About Packt
Why subscribe?
22. Other Books You May Enjoy Chevron down icon Chevron up icon
Other Books You May Enjoy
Packt is searching for authors like you
Leave a review - let other readers know what you think
Appendix A Chevron down icon Chevron up icon
Appendix A
Designing data storage
Which NoSQL technology should I use?
Serverless architecture
Communication and culture
DevOps

Recommendations for you

Left arrow icon
Asynchronous Programming in Rust
Asynchronous Programming in Rust
Feb 2024 306 pages
ebook
eBook
  • ebook eBook Mex$458.99
  • print Print Mex$820.99
Mex$458.99 Mex$656.99
Mex$820.99
50 Algorithms Every Programmer Should Know
50 Algorithms Every Programmer Should Know
Sep 2023 538 pages
Full star icon 4
ebook
eBook
  • ebook eBook Mex$573.99
  • print Print Mex$1,025.99
Mex$573.99 Mex$820.99
Mex$1,025.99
Go Programming - From Beginner to Professional
Go Programming - From Beginner to Professional
Mar 2024 680 pages
ebook
eBook
  • ebook eBook Mex$516.99
  • print Print Mex$922.99
Mex$516.99 Mex$738.99
Mex$922.99
Pragmatic Microservices with C# and Azure
Pragmatic Microservices with C# and Azure
May 2024 508 pages
ebook
eBook
  • ebook eBook Mex$573.99
  • print Print Mex$1,025.99
Mex$573.99 Mex$820.99
Mex$1,025.99
Complete Python Course with 10 Real-World Projects
Complete Python Course with 10 Real-World Projects
Feb 2023 27h and 7min
Full star icon 5
video
Video
  • video Video Mex$2,256.99
Mex$2,256.99
Modern CMake for C++
Modern CMake for C++
May 2024 502 pages
ebook
eBook
  • ebook eBook Mex$573.99
  • print Print Mex$1,025.99
Mex$573.99 Mex$820.99
Mex$1,025.99
.NET MAUI Cross-Platform Application Development
.NET MAUI Cross-Platform Application Development
Mar 2024 496 pages
ebook
eBook
  • ebook eBook Mex$470.99
  • print Print Mex$840.99
Mex$470.99 Mex$672.99
Mex$840.99
Mastering Go
Mastering Go
Mar 2024 736 pages
ebook
eBook
  • ebook eBook Mex$631.99
  • print Print Mex$1,128.99
Mex$631.99 Mex$902.99
Mex$1,128.99
Modern C++ Programming Cookbook
Modern C++ Programming Cookbook
Feb 2024 816 pages
ebook
eBook
  • ebook eBook Mex$631.99
  • print Print Mex$1,128.99
Mex$631.99 Mex$902.99
Mex$1,128.99
Enterprise Architecture with .NET
Enterprise Architecture with .NET
May 2024 772 pages
ebook
eBook
  • ebook eBook Mex$596.99
  • print Print Mex$1,066.99
Mex$596.99 Mex$853.99
Mex$1,066.99
Right arrow icon

Customer reviews

Filter icon Filter
Top Reviews
  • Top Reviews
  • Most Recent
Rating distribution
Empty star icon Empty star icon Empty star icon Empty star icon Empty star icon 0
(0 Ratings)
5 star 0%
4 star 0%
3 star 0%
2 star 0%
1 star 0%

Filter reviews by

No reviews found

People who bought this also bought

Left arrow icon
The Python Workshop Second Edition
The Python Workshop Second Edition
Nov 2022 600 pages
Full star icon 5
ebook
eBook
  • ebook eBook Mex$596.99
  • print Print Mex$1,066.99
Mex$596.99 Mex$853.99
Mex$1,066.99
Python GUI Programming with Tkinter, 2nd edition
Python GUI Programming with Tkinter, 2nd edition
Oct 2021 664 pages
Full star icon 5
ebook
eBook
  • ebook eBook Mex$573.99
  • print Print Mex$1,025.99
Mex$573.99 Mex$820.99
Mex$1,025.99
Learn Python Programming, 3rd edition
Learn Python Programming, 3rd edition
Oct 2021 554 pages
Full star icon 5
ebook
eBook
  • ebook eBook Mex$539.99
  • print Print Mex$963.99
Mex$539.99 Mex$771.99
Mex$963.99
Software Architecture for Busy Developers
Software Architecture for Busy Developers
Oct 2021 174 pages
ebook
eBook
  • ebook eBook Mex$447.98
  • print Print Mex$799.99
  • audiobook Audiobook Mex$1,004.99
Mex$447.98 Mex$639.99
Mex$799.99
Mex$1,004.99
Software Architecture with C++
Software Architecture with C++
Apr 2021 540 pages
ebook
eBook
  • ebook eBook Mex$631.99
  • print Print Mex$1,128.99
  • audiobook Audiobook Mex$676.99
Mex$631.99 Mex$902.99
Mex$1,128.99
Mex$676.99
Advanced Python Programming
Advanced Python Programming
Mar 2022 606 pages
ebook
eBook
  • ebook eBook Mex$539.99
  • print Print Mex$963.99
Mex$539.99 Mex$771.99
Mex$963.99
Right arrow icon

Authors (2)

Profile icon Mr. Adrian Ostrowski
LinkedIn Github
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.
Read more
See other products by Mr. Adrian Ostrowski
Profile icon Mr. Piotr Gaczkowski
LinkedIn Github
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.
Read more
See other products by Mr. Piotr Gaczkowski
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

How do I buy and download an eBook? Chevron down icon Chevron up icon

Where there is an eBook version of a title available, you can buy it from the book details for that title. Add either the standalone eBook or the eBook and print book bundle to your shopping cart. Your eBook will show in your cart as a product on its own. After completing checkout and payment in the normal way, you will receive your receipt on the screen containing a link to a personalised PDF download file. This link will remain active for 30 days. You can download backup copies of the file by logging in to your account at any time.

If you already have Adobe reader installed, then clicking on the link will download and open the PDF file directly. If you don't, then save the PDF file on your machine and download the Reader to view it.

Please Note: Packt eBooks are non-returnable and non-refundable.

Packt eBook and Licensing When you buy an eBook from Packt Publishing, completing your purchase means you accept the terms of our licence agreement. Please read the full text of the agreement. In it we have tried to balance the need for the ebook to be usable for you the reader with our needs to protect the rights of us as Publishers and of our authors. In summary, the agreement says:

  • You may make copies of your eBook for your own use onto any machine
  • You may not pass copies of the eBook on to anyone else
How can I make a purchase on your website? Chevron down icon Chevron up icon

If you want to purchase a video course, eBook or Bundle (Print+eBook) please follow below steps:

  1. Register on our website using your email address and the password.
  2. Search for the title by name or ISBN using the search option.
  3. Select the title you want to purchase.
  4. Choose the format you wish to purchase the title in; if you order the Print Book, you get a free eBook copy of the same title. 
  5. Proceed with the checkout process (payment to be made using Credit Card, Debit Cart, or PayPal)
Where can I access support around an eBook? Chevron down icon Chevron up icon
  • If you experience a problem with using or installing Adobe Reader, the contact Adobe directly.
  • To view the errata for the book, see www.packtpub.com/support and view the pages for the title you have.
  • To view your account details or to download a new copy of the book go to www.packtpub.com/account
  • To contact us directly if a problem is not resolved, use www.packtpub.com/contact-us
What eBook formats do Packt support? Chevron down icon Chevron up icon

Our eBooks are currently available in a variety of formats such as PDF and ePubs. In the future, this may well change with trends and development in technology, but please note that our PDFs are not Adobe eBook Reader format, which has greater restrictions on security.

You will need to use Adobe Reader v9 or later in order to read Packt's PDF eBooks.

What are the benefits of eBooks? Chevron down icon Chevron up icon
  • You can get the information you need immediately
  • You can easily take them with you on a laptop
  • You can download them an unlimited number of times
  • You can print them out
  • They are copy-paste enabled
  • They are searchable
  • There is no password protection
  • They are lower price than print
  • They save resources and space
What is an eBook? Chevron down icon Chevron up icon

Packt eBooks are a complete electronic version of the print edition, available in PDF and ePub formats. Every piece of content down to the page numbering is the same. Because we save the costs of printing and shipping the book to you, we are able to offer eBooks at a lower cost than print editions.

When you have purchased an eBook, simply login to your account and click on the link in Your Download Area. We recommend you saving the file to your hard drive before opening it.

For optimal viewing of our eBooks, we recommend you download and install the free Adobe Reader version 9.