Network Programming in Rust

Introduction

The book "Network Programming with Rust" (author — Abhijit Gadgil, 2018, 286 pages) is a practical guide dedicated to creating network applications in the Rust language. In an era where performance and memory safety are becoming critical factors, Rust offers a unique combination of low-level control and safety guarantees. The author aims to teach the reader not just to write network code, but to do so efficiently, using all the language's strengths: the ownership system, borrowing, lifetimes, and a powerful type system.

What the book is about

The book covers a wide range of topics — from the basics of working with sockets to building high-load asynchronous servers. It begins with an introduction to the Rust ecosystem and basic concepts of network interaction (OSI model, TCP/UDP). Then it sequentially covers:

• Working with blocking and non-blocking sockets;
• TCP and UDP protocols, their implementation in Rust;
• Creating HTTP servers and clients using popular crates (hyper, reqwest);
• Asynchronous programming with tokio and async/await (at the time of the book's release — futures);
• Security: TLS/SSL encryption, working with certificates;
• Interaction with databases over the network (using PostgreSQL as an example);
• Testing network applications and debugging.

Each chapter contains practical code examples that can be run and modified immediately.

Who this book is for

The book is intended for developers already familiar with the basics of Rust (syntax, ownership, traits). If you are just starting to learn the language, you should first read The Rust Programming Language (the official guide). A basic understanding of network protocols (TCP/IP, HTTP) is also assumed.

Target audience:

• Backend developers looking to switch to Rust for building high-performance services;
• Systems programmers working on network daemons, proxies, load balancers;
• Students and researchers interested in safe systems programming;
• C/C++ developers who want to see how Rust solves memory safety issues in network code.

What the reader will learn

After reading the book, you will be able to:

• Create TCP servers and clients from scratch, handling connections in multi-threaded and asynchronous modes;
• Implement custom protocols over UDP;
• Write HTTP servers using the hyper crate and handle requests/responses;
• Use tokio to build asynchronous network applications with minimal overhead;
• Add TLS encryption to your applications using native-tls or rustls;
• Work with databases via network drivers (e.g., tokio-postgres);
• Write unit and integration tests for network code using mocks and test servers;
• Understand the internal structure of popular network crates and choose the right ones for your tasks.

Strengths

The book stands out for several important qualities:

• Practical focus. Each concept is backed by working code that can be adapted for your own projects.
• Deep dive into asynchrony. The author explains the async/await model (via futures) in detail and shows how to avoid common mistakes (e.g., blocking the event loop).
• Emphasis on safety. Rust is known for its safety, and the book consistently demonstrates how the type system prevents entire classes of vulnerabilities (race conditions, use-after-free, buffer overflow).
• Relevance of examples. Despite being from 2018, most of the examples remain relevant,