I've also posted this on reddit but I'm taking the liberty of cross-posting on the channels that I regularely visit so that it's possible to ask me any questions you might have.
Today I’m announcing my new book called Asynchronous Programming in Rust.
Asynchronous Programming in Rust is meant to be the “missing” book that teaches you asynchronous programming from first principles. One of its core features are the examples and experiments we create that you later can pick apart, break, expand on. You get theoretical knowledge, useful mental models and hands on experience that will make the complex topics surrounding asynchronous programming a lot easier to grasp.
In this book, we explore fibers and green threads, async/await, non-blocking I/O, epoll, kqueue and IOCP, FFI, syscalls, runtimes, executors, wakers, pinning and much more. You’ll learn a lot about asynchronous programming that’s applicable to pretty much all programming languages, and you will learn everything you need to know about asynchronous programming in Rust.
Money was never the primary focus for me on this project and I wanted to find a way to give something back that can benefit everyone learning Rust. I’ve decided to sponsor Jon Gjengset with 50 % of my returns on the book sales for the first 4 months to support his work on podcasts, educational videos and other work that benefits the wider Rust community.
Jon Gjengset is a familiar name to many Rustaceans that I’ve had the pleasure of interacting with on a few occasions. He’s the author of Rust for Rustaceans, has an excellent video series called Crust of Rust on Youtube as well as long form streams, videos and podcasts on all kinds of topics related to Rust that is free for everyone. He recently announced a sponsorship (Sponsor @jonhoo on GitHub Sponsors · GitHub) to find a sustainable way to dedicate time to continue his work.
So, in short, if you purchase this book now, you will indirectly support the development of free high quality educational material for everyone in the Rust community.
You can buy the book on Amazon as of today.
People start programming for a variety of different reasons. Scientists start programming to model problems and perform calculations. Business experts create programs that solve specific problems that help their businesses. Some people start programming as a hobby in their spare time. Common to these programmers is that they usually learn programming from the top-down. That’s how I started programming myself.
I started writing about asynchronous programming since I found the information needed to get a deep and fundamental understanding of the topic to be incomplete and scattered around the internet – some of it had to be deducted from reading codebases in both Rust, C and C++, by engaging in programming language development, reading the documentation for various OS APIs and by discussing with experts on various forums.
So, after spending thousands of hours over the course of several years on just that I realized that this could, and should, be compiled into one book.
You can get quite productive writing asynchronous Rust without knowing how it really works, but Rust is more explicit and surfaces more complexity to the programmer than most other languages. You will have a much easier time handling this complexity if you get a deep understanding of asynchronous programming in general and what really happens when you write asynchronous Rust.
Another huge upside is that learning from first principles like this results in knowledge that is applicable way beyond Rust, and it will in turn make it easier to pick up asynchronous programming in other languages as well.
This book doesn’t shy away from complexity if it’s important to get the correct understanding of how things work. Instead, we try to get comfortable with it by explaining everything in detail and getting hands on experience with it.