book

Rust in Action

by Tim McNamara

August 2021

Beginner to intermediate

456 pages

12h 24m

English

Manning Publications

Read now

Unlock full access

prefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A roadmapAbout the codeliveBook discussion forumOther online resourcesabout the authorabout the cover illustration
1.1 Where is Rust used?1.2 Advocating for Rust at work1.3 A taste of the language1.3.1 Cheating your way to “Hello, world!”1.3.2 Your first Rust program1.4 Downloading the book’s source code1.5 What does Rust look and feel like?1.6 What is Rust?1.6.1 Goal of Rust: Safety1.6.2 Goal of Rust: Productivity1.6.3 Goal of Rust: Control1.7 Rust’s big features1.7.1 Performance1.7.2 Concurrency1.7.3 Memory efficiency1.8 Downsides of Rust1.8.1 Cyclic data structures1.8.2 Compile times1.8.3 Strictness1.8.4 Size of the language1.8.5 Hype1.9 TLS security case studies1.9.1 Heartbleed1.9.2 Goto fail;1.10 Where does Rust fit best?1.10.1 Command-line utilities1.10.2 Data processing1.10.3 Extending applications1.10.4 Resource-constrained environments1.10.5 Server-side applications1.10.6 Desktop applications1.10.7 Desktop1.10.8 Mobile1.10.9 Web1.10.10 Systems programming1.11 Rust’s hidden feature: Its community1.12 Rust phrase bookSummary
2.1 Creating a running program2.1.1 Compiling single files with rustc2.1.2 Compiling Rust projects with cargo2.2 A glance at Rust’s syntax2.2.1 Defining variables and calling functions2.3 Numbers2.3.1 Integers and decimal (floating-point) numbers2.3.2 Integers with base 2, base 8, and base 16 notation2.3.3 Comparing numbers2.3.4 Rational, complex numbers, and other numeric types2.4 Flow control2.4.1 For: The central pillar of iteration2.4.2 Continue: Skipping the rest of the current iteration2.4.3 While: Looping until a condition changes its state2.4.4 Loop: The basis for Rust’s looping constructs2.4.5 Break: Aborting a loop2.4.6 If, if else, and else: Conditional branching2.4.7 Match: Type-aware pattern matching2.5 Defining functions2.6 Using references2.7 Project: Rendering the Mandelbrot set2.8 Advanced function definitions2.8.1 Explicit lifetime annotations2.8.2 Generic functions2.9 Creating grep-lite2.10 Making lists of things with arrays, slices, and vectors2.10.1 Arrays2.10.2 Slices2.10.3 Vectors2.11 Including third-party code2.11.1 Adding support for regular expressions2.11.2 Generating the third-party crate documentation locally2.11.3 Managing Rust toolchains with rustup2.12 Supporting command-line arguments2.13 Reading from files2.14 Reading from stdinSummary
3.1 Using plain functions to experiment with an API3.2 Modeling files with struct3.3 Adding methods to a struct with impl3.3.1 Simplifying object creation by implementing new()3.4 Returning errors3.4.1 Modifying a known global variable3.4.2 Making use of the Result return type3.5 Defining and making use of an enum3.5.1 Using an enum to manage internal state3.6 Defining common behavior with traits3.6.1 Creating a Read trait3.6.2 Implementing std::fmt::Display for your own types3.7 Exposing your types to the world3.7.1 Protecting private data3.8 Creating inline documentation for your projects3.8.1 Using rustdoc to render docs for a single source file3.8.2 Using cargo to render docs for a crate and its dependenciesSummary

4.1 Implementing a mock CubeSat ground station4.1.1 Encountering our first lifetime issue4.1.2 Special behavior of primitive types4.2 Guide to the figures in this chapter4.3 What is an owner? Does it have any responsibilities?4.4 How ownership moves4.5 Resolving ownership issues4.5.1 Use references where full ownership is not required4.5.2 Use fewer long-lived values4.5.3 Duplicate the value4.5.4 Wrap data within specialty typesSummary
5.1 Bit patterns and types5.2 Life of an integer5.2.1 Understanding endianness5.3 Representing decimal numbers5.4 Floating-point numbers5.4.1 Looking inside an f325.4.2 Isolating the sign bit5.4.3 Isolating the exponent5.4.4 Isolate the mantissa5.4.5 Dissecting a floating-point number5.5 Fixed-point number formats5.6 Generating random probabilities from random bytes5.7 Implementing a CPU to establish that functions are also data5.7.1 CPU RIA/1: The Adder5.7.2 Full code listing for CPU RIA/1: The Adder5.7.3 CPU RIA/2: The Multiplier5.7.4 CPU RIA/3: The Caller5.7.5 CPU 4: Adding the restSummary
6.1 Pointers6.2 Exploring Rust’s reference and pointer types6.2.1 Raw pointers in Rust6.2.2 Rust’s pointer ecosystem6.2.3 Smart pointer building blocks6.3 Providing programs with memory for their data6.3.1 The stack6.3.2 The heap6.3.3 What is dynamic memory allocation?6.3.4 Analyzing the impact of dynamic memory allocation6.4 Virtual memory6.4.1 Background6.4.2 Step 1: Having a process scan its own memory6.4.3 Translating virtual addresses to physical addresses6.4.4 Step 2: Working with the OS to scan an address space6.4.5 Step 3: Reading from and writing to process memorySummary
7.1 What is a file format?7.2 Creating your own file formats for data storage7.2.1 Writing data to disk with serde and the bincode format7.3 Implementing a hexdump clone7.4 File operations in Rust7.4.1 Opening a file in Rust and controlling its file mode7.4.2 Interacting with the filesystem in a type-safe manner with std::fs::Path7.5 Implementing a key-value store with a log-structured, append-only storage architecture7.5.1 The key-value model7.5.2 Introducing actionkv v1: An in-memory key-value store with a command-line interface7.6 Actionkv v1: The front-end code7.6.1 Tailoring what is compiled with conditional compilation7.7 Understanding the core of actionkv: The libactionkv crate7.7.1 Initializing the ActionKV struct7.7.2 Processing an individual record7.7.3 Writing multi-byte binary data to disk in a guaranteed byte order7.7.4 Validating I/O errors with checksums7.7.5 Inserting a new key-value pair into an existing database7.7.6 The full code listing for actionkv7.7.7 Working with keys and values with HashMap and BTreeMap7.7.8 Creating a HashMap and populating it with values7.7.9 Retrieving values from HashMap and BTreeMap7.7.10 How to decide between HashMap and BTreeMap7.7.11 Adding a database index to actionkv v2.0Summary
8.1 All of networking in seven paragraphs8.2 Generating an HTTP GET request with reqwest8.3 Trait objects8.3.1 What do trait objects enable?8.3.2 What is a trait object?8.3.3 Creating a tiny role-playing game: The rpg project8.4 TCP8.4.1 What is a port number?8.4.2 Converting a hostname to an IP address8.5 Ergonomic error handling for libraries8.5.1 Issue: Unable to return multiple error types8.5.2 Wrapping downstream errors by defining our own error type8.5.3 Cheating with unwrap() and expect()8.6 MAC addresses8.6.1 Generating MAC addresses8.7 Implementing state machines with Rust’s enums8.8 Raw TCP8.9 Creating a virtual networking device8.10 “Raw” HTTPSummary
9.1 Background9.2 Sources of time9.3 Definitions9.4 Encoding time9.4.1 Representing time zones9.5 clock v0.1.0: Teaching an application how to tell the time9.6 clock v0.1.1: Formatting timestamps to comply with ISO 8601 and email standards9.6.1 Refactoring the clock v0.1.0 code to support a wider architecture9.6.2 Formatting the time9.6.3 Providing a full command-line interface9.6.4 clock v0.1.1: Full project9.7 clock v0.1.2: Setting the time9.7.1 Common behavior9.7.2 Setting the time for operating systems that use libc9.7.3 Setting the time on MS Windows9.7.4 clock v0.1.2: The full code listing9.8 Improving error handling9.9 clock v0.1.3: Resolving differences between clocks with the Network Time Protocol (NTP)9.9.1 Sending NTP requests and interpreting responses9.9.2 Adjusting the local time as a result of the server’s response9.9.3 Converting between time representations that use different precisions and epochs9.9.4 clock v0.1.3: The full code listingSummary
10.1 Anonymous functions10.2 Spawning threads10.2.1 Introduction to closures10.2.2 Spawning a thread10.2.3 Effect of spawning a few threads10.2.4 Effect of spawning many threads10.2.5 Reproducing the results10.2.6 Shared variables10.3 Differences between closures and functions10.4 Procedurally generated avatars from a multithreaded parser and code generator10.4.1 How to run render-hex and its intended output10.4.2 Single-threaded render-hex overview10.4.3 Spawning a thread per logical task10.4.4 Using a thread pool and task queue10.5 Concurrency and task virtualization10.5.1 Threads10.5.2 What is a context switch?10.5.3 Processes10.5.4 WebAssembly10.5.5 Containers10.5.6 Why use an operating system (OS) at all?Summary
11.1 A fledgling operating system (FledgeOS)11.1.1 Setting up a development environment for developing an OS kernel11.1.2 Verifying the development environment11.2 Fledgeos-0: Getting something working11.2.1 First boot11.2.2 Compilation instructions11.2.3 Source code listings11.2.4 Panic handling11.2.5 Writing to the screen with VGA-compatible text mode11.2.6 _start(): The main() function for FledgeOS11.3 fledgeos-1: Avoiding a busy loop11.3.1 Being power conscious by interacting with the CPU directly11.3.2 fledgeos-1 source code11.4 fledgeos-2: Custom exception handling11.4.1 Handling exceptions properly, almost11.4.2 fledgeos-2 source code11.5 fledgeos-3: Text output11.5.1 Writing colored text to the screen11.5.2 Controlling the in-memory representation of enums11.5.3 Why use enums?11.5.4 Creating a type that can print to the VGA frame buffer11.5.5 Printing to the screen11.5.6 fledgeos-3 source code11.6 fledgeos-4: Custom panic handling11.6.1 Implementing a panic handler that reports the error to the user11.6.2 Reimplementing panic() by making use of core::fmt::Write11.6.3 Implementing core::fmt::Write11.6.4 fledge-4 source codeSummary
12.1 Glossary12.1.1 Signals vs. interrupts12.2 How interrupts affect applications12.3 Software interrupts12.4 Hardware interrupts12.5 Signal handling12.5.1 Default behavior12.5.2 Suspend and resume a program’s operation12.5.3 Listing all signals supported by the OS12.6 Handling signals with custom actions12.6.1 Global variables in Rust12.6.2 Using a global variable to indicate that shutdown has been initiated12.7 Sending application-defined signals12.7.1 Understanding function pointers and their syntax12.8 Ignoring signals12.9 Shutting down from deeply nested call stacks12.9.1 Introducing the sjlj project12.9.2 Setting up intrinsics in a program12.9.3 Casting a pointer to another type12.9.4 Compiling the sjlj project12.9.5 sjlj project source code12.10 A note on applying these techniques to platforms without signals12.11 Revising exceptionsSummary

Content preview from Rust in Action

5 Data in depth

This chapter covers

Learning how the computer represents data
Building a working CPU emulator
Creating your own numeric data type
Understanding floating-point numbers

This chapter is all about understanding how zeroes and ones can become much larger objects like text, images, and sound. We will also touch on how computers do computation.

By the end of the chapter, you will have emulated a fully functional computer with CPU, memory, and user-defined functions. You will break apart floating-point numbers to create a numeric data type of your own that only takes a single byte. The chapter introduces a number of terms, such as endianness and integer overflow, that may not be familiar to programmers who have never done systems ...