book

The Rust Programming Handbook

Name: The Rust Programming Handbook
Author: Francesco Ciulla
ISBN: 9781836208877

by Francesco Ciulla

December 2025

Beginner

768 pages

15h 34m

English

Packt Publishing

Read now

Unlock full access

Contributors
Join us on Discord!
Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touchFree Benefits with Your BookHow to Unlock
Getting Started with Rust
Free Benefits with Your BookTechnical requirementsWhat is Rust?What is Rust good for?Key features of RustThe Rust ecosystemWhy learn Rust?Installation and Hello WorldInstalling RustVerifying the installationSetting up your development environmentSetting up VS Code for Rust (recommended)Hello WorldCompiling and running your Hello WorldUsing Cargo and Crates.ioVerifying Cargo installationWhat is Cargo?Cargo’s main featuresStable versus Nightly RustCreating a new Rust projectManaging dependencies with Cargo.tomlInstalling dependencies from Crates.ioCargo.lock: keeping dependencies consistentBuilding your projectRunning your project with CargoInitializing a new Rust project with cargo initCreating a library with cargo init --libYour first real Rust program: a CLI calculatorStep 1: Setting up your projectStep 2: Writing the calculator logicStep 3: Running the programWhat you learnedFunctionsFunctions exampleSummaryQuestionsGet This Book’s PDF Version and Exclusive Extras
Rust Syntax and Functions
Variable declarations and mutabilityImmutable variablesMutable variablesShadowingData types and structuresScalar typesIntegersFloating-point numbersBooleansCharactersCompound typesTuplesArraysSlicesStringsStructsClassic structsTuple structsUnit structsStruct initialization and update syntaxMethods and associated functionsEnumsDefining enumsMatching with enumsEnum methodsFunctions in RustFunction syntaxParameter passingPassing by valuePassing by referencePassing by mutable referenceReturn valuesOwnership and functionsControl flow constructsif and else statementsLoop constructsThe loop keywordThe while keywordThe for keywordUsing ranges with the for loopNesting loopsPattern matching with matchMatching literalsMatching with variablesDestructuring enumsCombining patternsAdding conditional logic with match guardsMatching rangesPattern matching with OptionUnderstanding Rust’s approach to error handlingFundamentals of error handlingThe Result typeThe Option typeError destructuringThe panic! macroSummaryQuestions and assignmentsQuestionsVariable declarations and mutabilityData types and structuresControl flow constructsFunctions in RustAssignmentsAssignment 2.1: Variable declarations and mutabilityAssignment 2.2: Data types and structuresGet This Book’s PDF Version and Exclusive Extras
Functions in Rust
Importance of understanding functions Defining and calling functionsBasic function syntaxParameters and return valuesFunctions that don’t return a valueFunctions with no parameters and no return valuesFunction syntax and best practicesFunction ownership and borrowingOwnership in functionsBorrowing in functionsImmutable borrowingMutable borrowingReturning values and ownershipAdvanced function featuresClosuresCapturing the environmentThe move keywordThe closure traits: Fn, FnMut, and FnOnceClosures in action: Higher-order functions and iteratorsAnonymous functions and iterator methodsSummaryQuestions and assignmentsQuestionsDefining functionsFunction ownership and borrowingAdvanced function featuresAssignmentsAssignment 3.1: basic function implementationAssignment 3.2: ownership and borrowing in functionsAssignment 3.3: using closuresGet This Book’s PDF Version and Exclusive Extras
Ownership, Borrowing, and References
ObjectiveWhat is ownership?Understanding ownershipWays variables interact: Move, copy, and cloneThe default behavior: Moving ownershipThe exception: Automatic copying with the Copy traitExplicit duplication: The Clone traitKey rules of ownership in RustEach value has a single ownerOwnership can be transferred (moved)The owner is responsible for cleaning up the valueMoving ownershipWhy move ownership?Moving in function callsAdvantages of moving ownershipOwnership and functionsOwnership transfer in function callsReturning ownershipBorrowing and referencesImmutable borrowingMutable borrowingBorrowing rulesBorrowing in functionsPractical example: Managing a libraryCommon patterns and idioms in Rust: Ownership, borrowing, and referencesBorrowing for read-only accessMutable borrowing for modificationExample: Mutable borrowing in a functionReturning references with borrowingExample: Returning a reference to the longest stringPitfalls and how to avoid themForgetting ownership has movedMultiple mutable referencesDangling referencesUnnecessary clonesSummaryQuestions and assignmentsQuestionsAssignmentsAssignment 4.1: ownership in actionAssignment 4.2: playing with borrowingGet This Book’s PDF Version and Exclusive Extras
Composite Types in Rust and the Module System
Structs: Named-field collectionsDefining structsCreating instances of structsInitializing structsField initialization shorthandAccessing struct fieldsReading field valuesModifying struct fieldsUpdating struct instancesStruct update syntaxCloning struct instancesMethods for structsDefining methodsCalling methodsAssociated functions introUnit-like structsDefining unit-like structsUse cases for unit-like structsTuple structsDefining tuple structsCreating instances of tuple structsAccessing tuple struct fieldsPractical example: Using tuple structs in a functionEmpty tuplesStructs and ownershipOwnership of struct fieldsBorrowing struct fieldsMutable borrowingDebugging with structsImplementing the Debug traitCustomizing debug outputPractical example: User profileDefining the UserProfile structAdding methods to UserProfileUsing the UserProfile structStructs: Exercises and assignmentsStructs: SummaryEnums: One of several possibilitiesDefining and using enumsEnum variants can hold dataEnum methods/functions introEnum methods exampleUsing enums with structsDefining structs with enum fieldsEnums: exercises and assignmentsEnums: summaryTuples: simple ordered groupsUsing tuplesAccessing tuple elementsAccessing elements by indexPractical example: employee recordDestructuring tuplesDestructuring tuplesPractical example: destructuring function return valuesDestructuring in a loopReturning tuples from functionsReturning multiple valuesDestructuring function return valuesPractical example: splitting a full namePractical example: point in 3D spaceCalculating the distance between pointsPractical usageTuples: exercises and assignmentsTuples: summaryUsing structs, enums, and tuples togetherPractical example: modeling a user profileManaging complexity with the module systemPackages and cratesThe Package layoutBinary crates vs. library cratesControlling scope and privacy with modulesDefining the module treeThe rules of privacy (the pub keyword)Referring to items via pathsAbsolute pathsRelative paths and the super keywordSimplifying scope with the use keywordIdiomatic use pathsHandling naming conflicts with “as”Physical organization: separating modules into filesThe module filesystem mappingSummaryQuestions and assignmentsQuestionsAssignmentsAssignment 5.1: order systemAssignment 5.2: geometric shapes enhancedGet This Book’s PDF Version and Exclusive Extras
Introduction to Error Handling
Why error handling mattersRust’s approach to errorsCore tools: Result and OptionIntroduction to Result and OptionThe Result typeThe Option typeOption exampleWhen to use Result versus OptionHandling Result and Option (unwrapping and alternatives)Unrecoverable errors: Understanding panic!Introduction to unwrappingUsing unwrap and expectSafe unwrapping with defaultsUsing combinatorsPropagating errors with ?The problem of manual propagationThe ? operator for ResultExample: the ? operator for Result with ResultThe ? operator for OptionWhen to use the ? operatorCustom error typesDefining custom error types with an enumImplementing standard error traitsUsing custom errors in functionsSimplifying custom errors with thiserror and anyhowThe thiserror crateThe anyhow crateWhen to use thiserror versus anyhowLogging errorsImportance of loggingThe log crate and implementationsBasic setup with env_loggerLogging levels and configurationLogging errors with ContextPractical examples and error handling best practicesPractical example: File data processingSummaryQuestions and assignmentsQuestionsAssignmentsAssignment 6.1: File reading with detailed error handlingAssignment 6.2: Division function with custom errors (using thiserror)Assignment 6.3: Finding elements with Option and ?Get This Book’s PDF Version and Exclusive Extras
Polymorphism and Lifetimes
Ad hoc polymorphism: defining behavior with traitsDefining a traitMethod signatures versus default implementationsAbstracting behaviorImplementing traitsImplementing custom typesThe orphan rule (where implementation is allowed)Trait objectsStatic versus dynamic dispatchParametric polymorphism: abstracting with genericsThe problem of duplicationWriting the same function for different typesThe <T> type parameterBounded parametric polymorphism (trait bounds)Limiting generics with traits (T: Trait)The where clause for complex constraintsReturning types that implement traitsMonomorphizationHow Rust optimizes polymorphism (zero-cost)Lifetimes: polymorphism for scopeThe necessity of lifetimesThe dangling reference problemHow the borrow checker validates scopesGeneric lifetime annotationsThe <’a> syntaxAnnotating functions holding referencesThe relationship between input and output lifetimesLifetimes in data structuresStructs with referencesThe impl block for lifetime-bound structsAdvanced lifetime conceptsLifetime elision rulesThe static lifetime (‘static)Applied polymorphism: a projectBuilding a zero-copy configuration parserDefining the capability (the Parse trait)Abstracting the input (using generics)The safety guaranteeValidating references (integrating lifetimes)SummaryQuestions and assignmentQuestionsAssignmentThe universal media playerGet This Book’s PDF Version and Exclusive Extras
Object-Oriented Programming in Rust
Understanding OOP principlesHow Rust approaches OOP differentlyEncapsulation: structs, methods, and privacyShared behavior with traitsDefining and implementing traitsTraits for polymorphism: impl TraitTraits for polymorphism: trait boundsUnderstanding static dispatch (monomorphization)Dynamic polymorphism with trait objectsIntroduction to trait objectsCreating trait objects: dyn TraitDynamic versus static dispatch recapObject safetySimulating inheritance patternsComposition over inheritanceSharing behavior via traitsDefault implementationsTrait bounds as “subclassing” constraints: supertraitsRequiring multiple traits with +Associated typesObject-oriented design patterns in RustIntroduction to patterns in RustBuilder patternState pattern/typed statesObserver patternStrategy patternSummaryQuestions and assignmentsQuestionsAssignmentsAssignment 8.1: The private bank account (encapsulation)Assignment 8.2: Animal sounds (basic traits)Subscribe to Deep Engineering

Thinking Functionally in Rust
Rust and functional programmingIterators: Processing sequences lazilyCreating and consuming iterators with next()Three ways to iterateThree ways to iterate: iter(), iter_mut(), and into_iter()The role of consumersCommon consumers: collect(), sum(), and fold()Iterator adapters: Transforming sequencesThe map adapterThe filter adapterOther useful adapters and consumersClosures: Capturing the environmentDefining closuresCapturing the environmentClosure traits: Fn, FnMut, and FnOncePattern matchingPattern matching in functional styleDestructuring structs and enumsif let and while letSummaryQuestions and assignmentsQuestionsAssignmentsAssignment 9.1 (easy): Simple data filtering and transformationAssignment 9.2 (advanced): Implementing a custom Fibonacci iteratorGet This Book’s PDF Version and Exclusive Extras
Testing in Rust
Why bother with testing?Types of tests in Rust’s ecosystemUnit tests: The building blocksWhat are unit tests?Writing your first unit testRunning your tests with cargo testCommon assertion macrosTesting Result and Option typesTesting for panicsControlling test executionIntegration tests: Checking how parts fit togetherPurpose of integration testsSetting up integration testsOur library code (src/lib.rs)Integration test file (tests/analyzer_integration.rs)Helper functions in integration testsExample shared helper (tests/common/mod.rs)Using shared helpers (tests/analyzer_integration.rs)Documentation tests: Keeping examples correctWhat are documentation tests?Writing documentation testsControlling doc test behaviorHiding lines from documentation output but not from the testA brief look at Test-Driven Development (TDD)TDD cycleTDD benefits and a micro example1. Red: Write a failing test2. Green: Write minimal code to make tests pass3. Refactor: Improve the codeNext cycle: red (for case-insensitivity)TDD for an API handler1. Red: Write the failing test2. Green: Write minimal code to make the test pass3. RefactorIsolating tests with test doubles (mocks and stubs)The need for isolationWhat are test doubles? Stubs and mocksManual stubbing (with traits)Mocking librariesBest practices for writing good testsSummaryQuestions and assignmentQuestionsAssignmentGet This Book’s PDF Version and Exclusive Extras
Smart Pointers and Memory Management
What are smart pointers, anyway?The role of smart pointers in Rust’s memory modelEnhancing safety beyond basic ownershipPerformance implicationsEnabling safe concurrencyKey ideas behind smart pointersOwnership and borrowing still applyAutomatic cleanupReference counting for shared dataInterior mutability: bending the rules safelyA quick tour of Rust’s smart pointer toolkitBox<T>: pointing to heap-allocated dataWhy use Box<T>?Creating and using a Box<T>Key use case: enabling recursive data structuresWhen to choose Box<T>: performance and ownershipSharing data safely: Rc<T> and Arc<T>The concept of shared ownershipRc<T>: reference counting for single-threaded scenariosCreating Rc<T> instances and cloning referencesArc<T>: atomic reference counting for multithreadingUsing Arc<T> to share data across threadsThe “atomic” in Arc<T>Reference counting, Drop, and potential cyclesHow Weak<T> can break cyclesInterior mutability: modifying data through shared referencesWhat is interior mutability and why is it needed?RefCell<T>: enforcing borrowing rules at runtime (single-threaded)Using borrow() and borrow_mut()Runtime panics on borrow rule violationsMutex<T>: ensuring exclusive access in concurrent codeLocking and unlocking with lock()Combining Arc<T> and Mutex<T> for shared mutable stateRwLock for read-mostly dataWorking effectively with smart pointersSmart pointers and method calls (the Deref trait in action)Implementing methods on structs that own smart pointersCombining smart pointers for complex scenariosSmart pointers and ownership transferPractical application: a simple graph with shared nodes (Rc<RefCell<Node>>)Important note on cycles and WeakSummaryQuestions and assignmentsQuestionsAssignmentGet This Book’s PDF Version and Exclusive Extras
Managing System Resources
Working with files in Rust (file I/O)Core concepts of file operationsReading from filesReading an entire file into a stringReading a file line by lineWriting to filesWriting a string or bytes to a fileAppending content to an existing fileManipulating files and directoriesKey takeaways for file I/O in RustNetwork programming essentials in RustFundamentals of network communicationBuilding a basic TCP serverListening for connections with TcpListenerHandling incoming client connectionsReading requests and sending responsesCreating a basic TCP clientConnecting to a server with TcpStream::connectSending data and receiving responsesEnsuring robust and secure network applicationsGraceful error handling in network codeHandling Result from network operationsTimeouts and non-blocking operationsImplementing secure connections with TLSIntroduction to TLS for secure communicationHow TLS worksUsing crates for TLSExample: Setting up a basic TLS client or serverBest practices for system resource managementEfficient memory usage with I/O operationsOptimizing file I/O performanceBuffering strategies recapProcessing large files in chunksOptimizing network I/O performanceUnderstanding asynchronous I/O for networkingManaging network buffers and packet sizesGeneral security principles for resource handlingValidating inputs from external sourcesPrinciple of least privilegeMinimizing resource contention in concurrent scenariosReal-world scenarios and examplesExample 1: Building a more robust HTTP serverImportant limitation: sequential handlingExample 2: Command-line tool for file operationsNext stepsSummaryQuestions and assignmentsQuestionsAssignmentsAssignment 12.1: Simple file copy utilityAssignment 12.2: Simple key-value TCP serverGet This Book’s PDF Version and Exclusive Extras
Concurrency and Parallelism
What are concurrency and parallelism?Why write concurrent programs?The classic challenges: Race conditions and deadlocksRust’s promise: Compile-time safety for concurrencyCreating and managing threadsSpawning new threads with std::thread::spawnBasic thread creationMoving data into threads with the move closureWaiting for threads to finish: JoinHandle and join()Handling thread panics gracefullyThread panics and their effectSharing data safely between threadsThe perils of unsafe shared stateArc<T>: Sharing ownership atomically across threadsRecap: Why Rc<T> isn’t enoughUsing Arc::clone() for thread distributionMutex<T>: Ensuring mutual exclusion for mutable dataAcquiring the lock with lock()The role of MutexGuardCombining Arc<Mutex<T>> for shared mutable stateThinking about deadlocksRwLock<T>: Allowing multiple readers or one writerWhen to use RwLock<T> versus Mutex<T>Message passing: Communicating between threadsAn alternative to shared state: ChannelsIntroduction to std::sync::mpsc channels (multiple producer, single consumer)Creating a channel: channel()Sending data with Sender<T>Receiving data with Receiver<T> (recv(), try_recv())Using channels for thread communication and synchronizationA glimpse into asynchronous programming with async/awaitWhen threads aren’t always the best fit (I/O-bound tasks versus CPU-bound tasks)Brief overview of the async and await keywordsAsync runtimes (such as tokio or async-std)Best practices for concurrent RustPrefer message passing for simplicity where possibleKeep critical sections (locks) short and sweetBe mindful of lock ordering to avoid deadlocksTrust the compiler: Leverage Rust’s safety guaranteesConsider the granularity of your parallelismSummaryQuestions and assignmentQuestionsAssignment: Concurrent file word counterGet This Book’s PDF Version and Exclusive Extras
Rust for Web Development: Building Full-Stack Applications
Core web concepts: a quick refresherThe HTTP protocol: requests, responses, and methodsRequests and responsesCommon HTTP methodsStatus codesData formats: JSON and RESTful API designJSON for APIsBrief on RESTful API design principlesGetting started with AxumProject setup and dependencies“Hello, Web!” – Your first Axum server (Getting started with Axum)Understanding handlers and the routerDefining handler functionsRegistering routes with Router::routeBuilding a RESTful API: an in-memory todo listProject setup for the APIManaging shared stateHandling requests and extracting dataImplementing the CRUD API endpointsAll the code for the RESTful API exampleTesting our RESTful applicationStep 1: Run your Axum serverStep 2: Open a new terminalStep 3: Test your API endpoints with curlAdding persistence with PostgreSQLDatabase setupIntegrating sqlx into the Axum projectAdding sqlx and dotenvy dependenciesConfiguring DATABASE_URLInstalling and using sqlx-cli for migrationsSchema management with sqlx migrationsCreating and running migrationsMapping Rust structs and using a connection poolUsing sqlx::PgPool for the connection poolDeriving FromRow for our Todo structSharing the pool in Axum’s AppStateRefactoring handlers for async database persistenceWriting raw SQL queriesRefactoring the CRUD endpoints to be fully asyncTesting the applicationVerifying with psqlA final backend step: enabling CORSFrontend: WebAssemblyBuilding and using a simple Wasm moduleExposing Rust functions with #[wasm_bindgen]Building the .wasm and JavaScript glueUsing the Wasm module from a simple web pageTesting the frontendSummaryQuestions and assignmentQuestionsAssignmentExpanding the API and using basic extractorsGet This Book’s PDF Version and Exclusive Extras
System Programming in Rust: Concrete Examples
What defines system programming?Why Rust is a strong candidate for systems workThe core tension: control versus abstractionThe systems programmer’s dilemmaRust’s solution: control without compromiseThe bridge to unsafe: when ZCAs aren’t enoughChapter roadmap: from low-level mechanics to practical buildsLow-level programming foundations in RustRust’s memory safety model: a systems perspectiveOwnership and borrowing recap for control and safetyStack versus heap: managing memory explicitlyThe role of smart pointers in memory managementVenturing into unsafe RustWhen and why unsafe is necessaryThe five superpowers of unsafe RustWorking with raw pointers (*const T and *mut T)Best practices for encapsulating unsafe codeBuilding practical command-line utilitiesDesigning a useful CLI toolParsing command-line argumentsUsing std::env::args() for basic argumentsIntroduction to argument parsingInteracting with the file systemReading and writing files in a CLI contextDirectory traversal and manipulationHandling standard input, output, and error streamsInterfacing with C code: the Foreign Function Interface (FFI)The “why” of FFI: leveraging existing C librariesDeclaring and linking external C functionsUsing extern “C” blocksThe #[link] attribute and build scriptsPassing data between Rust and CPrimitive types and their equivalentsWorking with C stringsRepresenting C structs in RustHandling pointers and callbacksCreating safe Rust wrappers around unsafe C APIsPractical example: using a simple custom C library from RustPrerequisite: installing a C compilerA glimpse into kernel module development with RustThe unique environment of kernel spaceEssential setup for Rust kernel developmentno_std and target specificationsBasic module structure (init/exit functions, logging)Building, loading, and further considerationsCompilation and loading processImportant caveats and next steps for explorationSummaryQuestions and assignmentsQuestionsAssignmentEnhanced command-line file analyzerGet This Book’s PDF Version and Exclusive Extras
Dockerization and Deployment of Rust Applications
What is Docker? An overviewKey benefits of using DockerWhy Dockerize Rust applications specifically?Chapter objectives: What you’ll learnGetting started with DockerSetting up your Docker environmentInstalling Docker Desktop (Windows, macOS, and Linux)Verifying your Docker installationEssential Docker conceptsImages and containers: The core building blocksDocker Hub and container registriesBasic Docker commands for interactionRunning a container: docker runListing containers: docker psManaging images: docker images, docker pull, and docker rmiStopping and removing containers: docker stop and docker rmDockerizing your Rust applicationUnderstanding the DockerfileCore instructions: FROM, WORKDIR, COPY, RUN, CMD, and EXPOSECreating a basic Dockerfile for a Rust applicationChoosing a base Rust imageCopying your project and buildingSetting the CMD to run your compiled binaryFinal DockerfileBuilding Your Docker ImageRunning your Rust application inside a Docker containerOptimizing Docker images for RustThe importance of small and efficient imagesUsing multi-stage buildsSeparating the build environment from the runtime environmentCopying artifactsChoosing minimal base images for runtimeConsiderations for Alpine and musl versus glibcLeveraging Docker build cache and cargo’s build cachingStructuring COPY and RUN commands effectivelyStripping debug symbols and binary compressionUsing stripUsing tools such as UPXManaging multi-container apps with Docker ComposeIntroduction to Docker Compose: Why you need itWriting a compose.yml fileDefining servicesLinking services and managing networksUsing environment variables for configurationManaging persistent data with volumesExample: A Rust application with a PostgreSQL databaseRunning and managing your application stackDeploying Dockerized Rust applicationsOverview of deployment strategiesUsing container registriesTagging your Docker images for versioningPushing images to a registryPulling images in a deployment environmentSummaryCongratulations!Questions and assignmentsQuestionsAssignmentsAssignment 16.1: Dockerize an existing Rust CLI or web applicationAssignment 16.2: Create a multi-container application with Docker ComposeGet This Book’s PDF Version and Exclusive Extras
Unlock Your Exclusive Benefits
Unlock this Book’s Free Benefits in 3 Easy StepsStep 1Step 2Step 3Need help?
Other Books You May Enjoy
Index

Content preview from The Rust Programming Handbook

7 Polymorphism and Lifetimes

We have spent the previous chapters defining concrete types such as structs and enums. These are excellent for modeling specific data, but real-world software often requires more flexibility! In real-world scenarios, we often need functions that can accept different types of data as long as they behave in a certain way.

In computer science, this concept is known as polymorphism. In Rust, we achieve this primarily through traits and generics. We will also cover lifetimes, which are a special form of generics that ensures references remain valid while our code becomes more abstract.

Ad hoc polymorphism: defining behavior with traits

The first step toward writing flexible code is changing how we view our data. Instead ...

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: 9781836208877

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Rust Programming Handbook

by Francesco Ciulla

7

Polymorphism and Lifetimes

Ad hoc polymorphism: defining behavior with traits

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.