Book Image

Practical System Programming for Rust Developers

By : Prabhu Eshwarla
Book Image

Practical System Programming for Rust Developers

By: Prabhu Eshwarla

Overview of this book

Modern programming languages such as Python, JavaScript, and Java have become increasingly accepted for application-level programming, but for systems programming, C and C++ are predominantly used due to the need for low-level control of system resources. Rust promises the best of both worlds: the type safety of Java, and the speed and expressiveness of C++, while also including memory safety without a garbage collector. This book is a comprehensive introduction if you’re new to Rust and systems programming and are looking to build reliable and efficient systems software without C or C++. The book takes a unique approach by starting each topic with Linux kernel concepts and APIs relevant to that topic. You’ll also explore how system resources can be controlled from Rust. As you progress, you’ll delve into advanced topics. You’ll cover network programming, focusing on aspects such as working with low-level network primitives and protocols in Rust, before going on to learn how to use and compile Rust with WebAssembly. Later chapters will take you through practical code examples and projects to help you build on your knowledge. By the end of this Rust programming book, you will be equipped with practical skills to write systems software tools, libraries, and utilities in Rust.

Related Content you might be interested in

Current Title:

Small book image
Practical System Programming for Rust Developers
Prabhu Eshwarla
Dec, 2020 | 388 pages
Small book image
Mastering Rust.
Vesa Kaihlavirta | Rahul Sharma
Jan, 2019 | 554 pages
Small book image
Rust Essentials.
Ivo Balbaert
Nov, 2017 | 264 pages
Small book image
Learning Rust
Vesa Kaihlavirta | Paul Johnson
Nov, 2017 | 308 pages
Table of Contents (17 chapters)
Preface
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: Getting Started with System Programming in Rust
Section 1: Getting Started with System Programming in Rust
Free Chapter
2
Chapter 1: Tools of the Trade – Rust Toolchains and Project Structures
Chapter 1: Tools of the Trade – Rust Toolchains and Project Structures
Technical requirements
Choosing the right Rust configuration for your project
Introducing Cargo and project structures
Automating build management with Cargo
Automating dependency management
Writing and running automated tests
Documenting your project
Summary
Further reading
3
Chapter 2: A Tour of the Rust Programming Language
Chapter 2: A Tour of the Rust Programming Language
Technical requirements
Analyzing the problem domain
Modeling the system behavior
Building the tokenizer
Building the parser
Building the evaluator
Dealing with errors
Putting it all together
Summary
4
Chapter 3: Introduction to the Rust Standard Library
Chapter 3: Introduction to the Rust Standard Library
Technical requirements
The Rust Standard Library and systems programming
Exploring the Rust Standard Library
Building a template engine
Summary
Further reading
5
Chapter 4: Managing Environment, Command Line, and Time
Chapter 4: Managing Environment, Command Line, and Time
Technical requirements
Project scope and design overview
Coding the imagix library
Developing the command-line application and testing
Summary
6
Section 2: Managing and Controlling System Resources in Rust
Section 2: Managing and Controlling System Resources in Rust
7
Chapter 5: Memory Management in Rust
Chapter 5: Memory Management in Rust
Technical requirements
The basics of OS memory management
Understanding the memory layout of Rust programs
The Rust memory management lifecycle
Implementing a dynamic data structure
Summary
Further reading
8
Chapter 6: Working with Files and Directories in Rust
Chapter 6: Working with Files and Directories in Rust
Technical requirements
Understanding Linux system calls for file operations
Doing file I/O in Rust
Learning directory and path operations
Setting hard links, symbolic links, and performing queries
Writing a shell command in Rust (project)
Summary
9
Chapter 7: Implementing Terminal I/O in Rust
Chapter 7: Implementing Terminal I/O in Rust
Technical requirements
Introducing terminal I/O fundamentals
Working with the terminal UI (size, color, styles) and cursors
Processing keyboard inputs and scrolling
Processing mouse inputs
Summary
10
Chapter 8: Working with Processes and Signals
Chapter 8: Working with Processes and Signals
Technical requirements
Understanding Linux process concepts and syscalls
Spawning processes with Rust
Handling I/O and environment variables
Handling panic, errors, and signals
Writing a shell program in Rust (project)
Summary
11
Chapter 9: Managing Concurrency
Chapter 9: Managing Concurrency
Technical requirements
Reviewing concurrency basics
Spawning and configuring threads
Error handling in threads
Message passing between threads
Achieving concurrency with shared state
Pausing thread execution with timers
Summary
12
Section 3: Advanced Topics
Section 3: Advanced Topics
13
Chapter 10: Working with Device I/O
Chapter 10: Working with Device I/O
Technical requirements
Understanding device I/O fundamentals in Linux
Doing buffered reads and writes
Working with standard input and output
Chaining and iterators over I/O
Handling errors and returning values
Getting details of connected USB devices (project)
Summary
14
Chapter 11: Learning Network Programming
Chapter 11: Learning Network Programming
Technical requirements
Reviewing networking basics in Linux
Understanding networking primitives in the Rust standard library
Programming with TCP and UDP in Rust
Writing a TCP reverse proxy (project)
Summary
15
Chapter 12: Writing Unsafe Rust and FFI
Chapter 12: Writing Unsafe Rust and FFI
Technical requirements
Introducing unsafe Rust
Introducing FFIs
Reviewing guidelines for safe FFIs
Calling Rust from C (project)
Understanding the ABI
Summary
16
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Preface

The modern software stack is evolving rapidly in size and complexity. Technology domains such as the cloud, the web, data science, machine learning, DevOps, containers, IoT, embedded systems, distributed ledgers, virtual and augmented reality, and artificial intelligence continue to evolve and specialize. This has resulted in a severe shortage of system software developers able to build out the system infrastructure components. Modern societies, businesses, and governments increasingly rely heavily on digital technologies, which puts greater emphasis on developing safe, reliable, and efficient systems software and software infrastructure that modern web and mobile applications are built on.

System programming languages such as C/C++ have proved their mettle for decades in this domain, and provide a high degree of control and performance, but it is at the cost of memory safety.

Higher-level languages such as Java, C#, Python, Ruby, and JavaScript provide memory safety but offer less control over memory layout, and suffer from garbage collection pauses.

Rust is a modern, open source system programming language that promises the best of three worlds: the type safety of Java; the speed, expressiveness, and efficiency of C++; and memory safety without a garbage collector.

This book adopts a unique three-step approach to teaching system programming in Rust. Each chapter in this book starts with an overview of the system programming fundamentals and kernel system calls for that topic in Unix-like operating systems (Unix/Linux/macOS). You will then learn how to perform common system calls using the Rust Standard Library, and in a few cases, external crates, using abundant code snippets. This knowledge is then reinforced through a practical example project that you will build. Lastly, there are questions in each chapter to embed learning.

By the end of this book, you will have a sound foundational understanding of how to use Rust to manage and control operating system resources such as memory, files, processes, threads, system environment, peripheral devices, networking interfaces, terminals, and shells, and you'll understand how to build cross-language bindings through FFI. Along the way, you will learn how to use the tools of the trade, and get a firm appreciation of the value Rust brings to build safe, performant, reliable, and efficient system-level software.

Previous Section
Next Section