book

Code Like a Pro in Rust

Name: Code Like a Pro in Rust
Author: Brenden Matthews
ISBN: 9781617299643

by Brenden Matthews

March 2024

Intermediate to advanced

264 pages

7h 8m

English

Manning Publications

Read now

Unlock full access

inside front cover
Code Like a Pro in Rust
Copyright
contents
Front matter
prefaceacknowledgmentsabout this bookHow is this book different?Who should read this book?How this book is organizedAbout the codeliveBook discussion forumabout the authorabout the cover illustration
1 Feelin’ Rusty
1.1 What’s Rust?1.2 What’s unique about Rust?1.2.1 Rust is safe1.2.2 Rust is modern1.2.3 Rust is pure open source1.2.4 Rust vs. other popular languages1.3 When should you use Rust?1.3.1 Rust use cases1.4 Tools you’ll needSummary
Part 1 Pro Rust
2 Project management with Cargo
2.1 Cargo tour2.1.1 Basic usage2.1.2 Creating a new application or library2.1.3 Building, running, and testing2.1.4 Switching between toolchains2.2 Dependency management2.2.1 Handling the Cargo.lock file2.3 Feature flags2.4 Patching dependencies2.4.1 Indirect dependencies2.4.2 Best practices for dependency patching2.5 Publishing crates2.5.1 CI/CD integration2.6 Linking to C libraries2.7 Binary distribution2.7.1 Cross compilation2.7.2 Building statically linked binaries2.8 Documenting Rust projects2.8.1 Code examples in documentation2.9 Modules2.10 Workspaces2.11 Custom building scripts2.12 Rust projects in embedded environments2.12.1 Memory allocationSummary
3 Rust tooling
3.1 Overview of Rust tooling3.2 Using rust-analyzer for Rust IDE integration3.2.1 Magic completions3.3 Using rustfmt to keep code tidy3.3.1 Installing rustfmt3.3.2 Configuring rustfmt3.4 Using Clippy to improve code quality3.4.1 Installing Clippy3.4.2 Clippy’s lints3.4.3 Configuring Clippy3.4.4 Automatically applying Clippy’s suggestions3.4.5 Using Clippy in CI/CD3.5 Reducing compile times with sccache3.5.1 Installing sccache3.5.2 Configuring sccache3.6 Integration with IDEs, including Visual Studio Code3.7 Using toolchains: Stable vs. nightly3.7.1 Nightly-only features3.7.2 Using nightly on published crates3.8 Additional tools: cargo-update, cargo-expand, cargo-fuzz, cargo-watch, cargo-tree3.8.1 Keeping packages up to date date with cargo-update3.8.2 Debugging macros with cargo-expand3.8.3 Testing libFuzzer3.8.4 Iterating with cargo-watch3.8.5 Examining dependencies with cargo-treeSummary
Part 2 Core data

4 Data structures
4.1 Demystifying String, str, &str, and &'static str4.1.1 String vs str4.1.2 Using strings effectively4.2 Understanding slices and arrays4.3 Vectors4.3.1 Diving deeper into Vec4.3.2 Wrapping vectors4.3.3 Types related to vectors4.4 Maps4.4.1 Custom hashing functions4.4.2 Creating hashable types4.5 Rust types: Primitives, structs, enums, and aliases4.5.1 Using primitive types4.5.2 Using tuples4.5.3 Using structs4.5.4 Using enums4.5.5 Using aliases4.6 Error handling with Result4.7 Converting types with From/Into4.7.1 TryFrom and TryInto4.7.2 Best practices for type conversion using From and Into4.8 Handling FFI compatibility with Rust’s typesSummary
5 Working with memory
5.1 Memory management: Heap and stack5.2 Understanding ownership: Copies, borrowing, references, and moves5.3 Deep copying5.4 Avoiding copies5.5 To box or not to box: Smart pointers5.6 Reference counting5.7 Clone on write5.8 Custom allocators5.8.1 Writing a custom allocator5.8.2 Creating a custom allocator for protected memory5.9 Smart pointers summarizedSummary
Part 3 Correctness
6 Unit testing
6.1 How testing is different in Rust6.2 Review of built-in testing features6.3 Testing frameworks6.4 What not to test: Why the compiler knows better than you6.5 Handling parallel test special cases and global state6.6 Thinking about refactoring6.7 Refactoring tools6.7.1 Reformatting6.7.2 Renaming6.7.3 Relocating6.7.4 Rewriting6.8 Code coverage6.9 Dealing with a changing ecosystemSummary
7 Integration testing
7.1 Comparing integration and unit testing7.2 Integration testing strategies7.3 Built-in integration testing vs. external integration testing7.4 Integration testing libraries and tooling7.4.1 Using assert_cmd to test CLI applications7.4.2 Using proptest with integration tests7.4.3 Other integration testing tools7.5 Fuzz testingSummary
Part 4 Asynchronous Rust
8 Async Rust
8.1 Runtimes8.2 Thinking asynchronously8.3 Futures: Handling async task results8.3.1 Defining a runtime with #[tokio::main]8.4 The async and .await keywords: When and where to use them8.5 Concurrency and parallelism with async8.6 Implementing an async observer8.7 Mixing sync and async8.8 When to avoid using async8.9 Tracing and debugging async code8.10 Dealing with async when testingSummary
9 Building an HTTP REST API service
9.1 Choosing a web framework9.2 Creating an architecture9.3 API design9.4 Libraries and tools9.5 Application scaffolding9.5.1 main()9.5.2 init_tracing()9.5.3 init_dbpool()9.6 Data modeling9.6.1 SQL schema9.6.2 Interfacing with our data9.7 Declaring the API routes9.8 Implementing the API routes9.9 Error handling9.10 Running the serviceSummary
10 Building an HTTP REST API CLI
10.1 Deciding which tools and libraries to use10.2 Designing the CLI10.3 Declaring the commands10.4 Implementing the commands10.5 Implementing requests10.6 Handling errors gracefully10.7 Testing our CLISummary
Part 5 Optimizations
11 Optimizations
11.1 Zero-cost abstractions11.2 Vectors11.2.1 Vector memory allocation11.2.2 Vector iterators11.2.3 Fast copies with Vec and slices11.3 SIMD11.4 Parallelization with Rayon11.5 Using Rust to accelerate other languages11.6 Where to go from hereSummary
appendix
Installing tools for this bookInstalling tools on macOS using HomebrewInstalling tools on Linux systemsInstalling rustup on Linux- or UNIX-based systemsInstalling tools on WindowsManaging rustc and other Rust components with rustupInstalling rustc and other componentsSwitching default toolchains with rustupUpdating Rust componentsInstalling HTTPie
index

Content preview from Code Like a Pro in Rust

6 Unit testing

This chapter covers

Understanding how unit testing is unique in Rust
Exploring unit testing dos and don’ts, features, and frameworks
Discussing unit testing with parallel code
Writing unit tests that consider refactoring
Exploring tools to help with refactoring
Measuring code covered by tests
Testing strategies for dealing with Rust’s ecosystem

Unit testing is one way to improve code quality, as it can catch regressions and ensure code meets requirements before shipping. Rust includes a built-in unit testing framework to make your life easier. In this chapter, we’ll review some of the features Rust provides and discuss some of the shortfalls of Rust’s unit testing framework—and how to overcome them.

6.1 How testing is different ...

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: 9781617299643Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Code Like a Pro in Rust

by Brenden Matthews

6 Unit testing

6.1 How testing is different ...

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.