Comprehensive Rust: course used by the Android team at Google(github.com)
github.com
Comprehensive Rust: course used by the Android team at Google
https://github.com/google/comprehensive-rust
72 comments
Hey there! I wrote the course and you're spot on: the course is meant for classroom training (at Google and elsewhere). If you have the time to read a book, then I highly recommend diving into one of the many great Rust books. I've linked some of the freely available ones here: https://google.github.io/comprehensive-rust/other-resources.....
We've made an attempt at making Comprehensive Rust useful for self-learners by providing speaker notes on many of the pages. However, they're still quite terse and could be expanded in many places. PRs for that will be gratefully accepted :-)
We've made an attempt at making Comprehensive Rust useful for self-learners by providing speaker notes on many of the pages. However, they're still quite terse and could be expanded in many places. PRs for that will be gratefully accepted :-)
Discussion: https://news.ycombinator.com/item?id=34091271 (568 points | 5 months ago | 198 comments)
For newcomers, https://github.com/rust-lang/rustlings is a good way to start.
I'm very happy I dug into rust half a decade ago. The language has been fun to learn as it evolved futures and async/await, and the future continues to look promising. I've had the pleasure of working professionally in Rust twice in my life (once at Full story, now at Deno) and I can say it's by far my favourite language to work in.
I did some Rust training with Ferrous but by far the most useful way to learn was just picking up a project and building it.
I did some Rust training with Ferrous but by far the most useful way to learn was just picking up a project and building it.
I envy people who can pick up Rust and just get stuff done.
I've tried many times but every time, I find it far more difficult to build things than any other language I know, so I just give up and go back to "easier" languages.
I think previous experience programming in C++ can be helpful, in picking up Rust faster.
For me, in large part, the borrow checker is encoding in the compiler rules that you should be following in C++ anyway.
A few hours debugging dangling references or iterator invalidation will make you appreciate what the borrow checker is trying to prevent.
You also have experience knowing the difference between pass by reference, pass by const reference, copy, and move.
Also, if you want to keep your sanity, you will learn to take ownership seriously. Deciding what owns what and whether objects will be owned by the scope (on the stack), be owned by unique_ptr, or be shared with shared_ptr is a large part of designing a C++ program.
Again these all map very neatly onto Rust idioms, and as a benefit are enforced by the compiler.
Coming from a garbage collected language where you previously did not have to care about things like that, and now, not only being forced to care, but having the compiler yell at you for every mistake can be a pretty big learning curve.
However, I would say that not knowing C++ doesn't mean that you can't learn Rust, only that it may take a little longer because you have to learn new concepts with regards to memory management and ownership, and so give yourself some slack and do not be discouraged.
For me, in large part, the borrow checker is encoding in the compiler rules that you should be following in C++ anyway.
A few hours debugging dangling references or iterator invalidation will make you appreciate what the borrow checker is trying to prevent.
You also have experience knowing the difference between pass by reference, pass by const reference, copy, and move.
Also, if you want to keep your sanity, you will learn to take ownership seriously. Deciding what owns what and whether objects will be owned by the scope (on the stack), be owned by unique_ptr, or be shared with shared_ptr is a large part of designing a C++ program.
Again these all map very neatly onto Rust idioms, and as a benefit are enforced by the compiler.
Coming from a garbage collected language where you previously did not have to care about things like that, and now, not only being forced to care, but having the compiler yell at you for every mistake can be a pretty big learning curve.
However, I would say that not knowing C++ doesn't mean that you can't learn Rust, only that it may take a little longer because you have to learn new concepts with regards to memory management and ownership, and so give yourself some slack and do not be discouraged.
> For me, in large part, the borrow checker is encoding in the compiler rules that you should be following in C++ anyway.
My experience was sort of the inverse of yours: I knew a little C++ before learning Rust, and being educated by the borrow checker has really helped me writing C++.
My experience was sort of the inverse of yours: I knew a little C++ before learning Rust, and being educated by the borrow checker has really helped me writing C++.
I've seen that too: having experience with Rust made C++ feel easy.
I looked at C++ many years ago but never used it professionally. About 6-7 years ago, I learnt Rust and a few years later, I started working full time in a C++ team at Google. There are many things in the Google C++ Style Guide[1] that reminds me of Rust, from the ban on exceptions to the use of `std::optional` for optional inputs and outputs.
[1]: https://google.github.io/styleguide/cppguide.html
I looked at C++ many years ago but never used it professionally. About 6-7 years ago, I learnt Rust and a few years later, I started working full time in a C++ team at Google. There are many things in the Google C++ Style Guide[1] that reminds me of Rust, from the ban on exceptions to the use of `std::optional` for optional inputs and outputs.
[1]: https://google.github.io/styleguide/cppguide.html
> Also, if you want to keep your sanity, you will learn to take ownership seriously. Deciding
> what owns what and whether objects will be owned by the scope (on the stack), be owned by unique_ptr, or
> be shared with shared_ptr is a large part of designing a C++ program.
I've found this Youtube video (and the whole channel) very good to help understanding Rust:
https://www.youtube.com/watch?v=TJTDTyNdJdY
Agree with the quote: that's the biggest challenge with Rust... I have been trying to pretend Rust is like Java and I think that was my big mistake.
When you design anything in Rust, even the most basic stuff, you will need to decide "what owns what", unless you clone everything on every usage. Try some very simple code that requires allocation and you will quickly notice that. I am now back at Rust and redesigning all my code to make "what owns what" the first question I ask when writing anything, and that is already being very helpful.
But of course: if you don't need the performance of Rust or the small footprint, it's just not worth it spending time on stuff like that can be completely and utterly ignored in any non-systems language.
https://www.youtube.com/watch?v=TJTDTyNdJdY
Agree with the quote: that's the biggest challenge with Rust... I have been trying to pretend Rust is like Java and I think that was my big mistake.
When you design anything in Rust, even the most basic stuff, you will need to decide "what owns what", unless you clone everything on every usage. Try some very simple code that requires allocation and you will quickly notice that. I am now back at Rust and redesigning all my code to make "what owns what" the first question I ask when writing anything, and that is already being very helpful.
But of course: if you don't need the performance of Rust or the small footprint, it's just not worth it spending time on stuff like that can be completely and utterly ignored in any non-systems language.
Thank you.
What I find difficult is to switch my 2 decade C++ career into a rust job, despite learned Rust and finished some hobby projects touching ui, async and http server/client in Rust. Somehow most Rust job is about crypto currency.
I agree with the OP that the best way to learn it is to work through a real project, but I wouldn’t necessarily equate that with “picking it up and just getting stuff done”. At least, that’s not how it went for me, anyway! I hit all the real roadblocks along the way and it took a good few months before I felt actually comfortable. Until then, it felt like I kept running up against mismatches between how I wanted to solve a problem and how Rust wanted me to do it. It was more difficult to build stuff and I had to rewrite things many times. For background, I had worked with C/C++, Java, JS/TS, Ruby, and some others prior to Rust, and it was the first time in a while that learning a new language was pretty hard even after the syntax made sense.
The first time I ever experienced lane assist in a car was in a borrowed Honda Accord. Any time I drifted towards the lane line without signalling, an alarm would go off. This doesn't mean the Accord is hard to drive. It's not even hard to learn to drive. I already knew I was supposed to signal before making a lane change. It just made me concerned about how often I must have drifted over lines in other cars without lane assist. "I'm a great driver. I've driven fine for decades without lane assist. I don't need lane assist." I added lane assist to the list of features I wanted in my next car. You know, for my kid's sake (glances left and right).
I felt a lot like that with Rust.
I felt a lot like that with Rust.
I find that a lot of people just pick wrong kinds of projects to dig their teeth into Rust with. It is a systems programming language. If you don't know much about it and set out to build a website, things are inevitably going to go south.
One of my first projects involved linked lists. Oh boy was that the right wrong project to start with.
I've never written linked lists the same way in other languages since.
Rust made me better in languages that aren't Rust.
I've never written linked lists the same way in other languages since.
Rust made me better in languages that aren't Rust.
Yeah, that's familiar. I chose for myself a project in which the data structure was a tree that should be generated randomly, but under some constraints. Also I tried to write it using functional paradigms, using many closures. I hit so many walls doing that that when it sort of worked, finally, I never wanted to touch Rust again.
Hah, yes. I thought I'd get started with Rust going through building some basic data structures. Linked lists were near the top of my list so I didn't get very far with that first approach XD
If you really meant this, and you ever want to learn Rust, you could do worse than begin with Aria's "Learn Rust With Entirely Too Many Linked Lists"
https://rust-unofficial.github.io/too-many-lists/
You can skip her explanation of why the Linked List is a bad first data structure, and get straight to doing, but if you have no idea why a very experienced programmer would think this data structure is terrible (so terrible she tried but failed to have it removed from Rust's Standard Library before Rust 1.0) you should read her whole PSA too.
https://rust-unofficial.github.io/too-many-lists/
You can skip her explanation of why the Linked List is a bad first data structure, and get straight to doing, but if you have no idea why a very experienced programmer would think this data structure is terrible (so terrible she tried but failed to have it removed from Rust's Standard Library before Rust 1.0) you should read her whole PSA too.
I didn't end my Rust learning with that. I did a bit of a deep dive into articles about linked lists in Rust out of curiosity before pivoting to more fruitful projects. My favourite "project" being last year's Advent of Code.
Actix and Axum are so easy. They're a drop in replacement for Golang or Flask.
I'd encourage people to start their Rust journey with little web services.
I'd encourage people to start their Rust journey with little web services.
Have you tried asking? The Rust reddit was a major reason I stop hitting my head against the wall.
In the past, `&str` was just so huge block for me (now I wonder why!) and instead of getting stuck just ask about it. I think was a stream of a few question on reddit that unblock Rust for me after like 3 months of going nowhere.
In the past, `&str` was just so huge block for me (now I wonder why!) and instead of getting stuck just ask about it. I think was a stream of a few question on reddit that unblock Rust for me after like 3 months of going nowhere.
Yes, I was on the Rust Discord for a while... without their help I wouldn't have even gone past the most basic things, so yeah, it did help... it was funny to see the huge stream of people asking the same questions over and over again :D.
After a short while, it gets really tiring... but like others are saying, now we have ChatGPT to ask and it never gets tired!
After a short while, it gets really tiring... but like others are saying, now we have ChatGPT to ask and it never gets tired!
These days you can just ask ChatGPT
Pick up Actix or Axum and clone() and unwrap() all day for your first month. Write some little web servers for fun. Sqlx is great for sql, and you can do some heavy hitting stuff like media streaming and transcoding as you get deeper into it. It's got good torch bindings for ML too.
Before long you'll be running the compiler in your head and rapidly churning out code.
Before long you'll be running the compiler in your head and rapidly churning out code.
A beginner should use expect instead of unwrap.
It makes you faster because you still don't have to handle errors but allows you to add context.
It makes you faster because you still don't have to handle errors but allows you to add context.
I suspect this is about experience.
I had experience with PHP, JavaScript, and Python, but when at first coding in Go it would take me as much as 10x as long. But with more practice it's now only about 2x as long as in other languages. Keep practicing ;)
I had experience with PHP, JavaScript, and Python, but when at first coding in Go it would take me as much as 10x as long. But with more practice it's now only about 2x as long as in other languages. Keep practicing ;)
I think my experience is actually the problem. I don't have enough patience anymore to spend lots of time trying to understand errors where I have zero idea why it's complaining, when I know the same thing in another language works totally fine the first time I try (and without bugs, it's mostly lifetime issues or the lovely borrow checker, which don't even exist in other languages).
But I do keep trying Rust, because the alternatives as I see it, C and Zig, have their own problems that are bigger (C's build tools and lack of package management, very weak type checking and unavoidable UB, and Zig's overall lack of maturity and consequently tooling).
By the way, I can write code very easily in Java/Kotlin/Groovy/Dart/JS/TS/Go/Lisp.
By the way, I can write code very easily in Java/Kotlin/Groovy/Dart/JS/TS/Go/Lisp.
> I don't have enough patience anymore to spend lots of time trying to understand errors where I have zero idea why it's complaining
I consider those bugs. Please file tickets for that. The errors should provide enough context for an uncaffeinated developer to understand what went wrong.
I consider those bugs. Please file tickets for that. The errors should provide enough context for an uncaffeinated developer to understand what went wrong.
ChatGPT has really helped me get over the impatience hurdle. I let it do all the tedious stuff like looking up error messages.
Yea, that's a common complaint coming from other safe languages where the safety is accomplished by runtime features (such as garbage collection) instead of compile–time rules.
I think that most programs should be written in easier languages than Rust, since most of the time the engineering cost of creating a system is higher than the cost of running it. You can rewrite it in Rust once your system is large enough that eliminating the garbage collector will save you a few million dollars a year. By then you’ll have a complete understanding of the requirements, and you won’t have to experiment to get it right. Use a language like Lisp, which is designed for easy and fast experimentation, to write the first version of your software.
I think that most programs should be written in easier languages than Rust, since most of the time the engineering cost of creating a system is higher than the cost of running it. You can rewrite it in Rust once your system is large enough that eliminating the garbage collector will save you a few million dollars a year. By then you’ll have a complete understanding of the requirements, and you won’t have to experiment to get it right. Use a language like Lisp, which is designed for easy and fast experimentation, to write the first version of your software.
>most of the time the engineering cost of creating a system is higher than the cost of running it.
And most of the time the cost of _maintaining_ the system is higher than the cost of creating it. This is where Rust truly excels, it makes it much harder to write any hard to find bugs.
And most of the time the cost of _maintaining_ the system is higher than the cost of creating it. This is where Rust truly excels, it makes it much harder to write any hard to find bugs.
Yes, I include maintenance in the cost of running the system. And I agree with you that a well–written Rust program usually has quite low maintenance costs.
In principle you should be able to approach zero maintenance costs with any language, but writing your system in Rust generally means you have abandoned complexities like garbage collection. Garbage collection speeds up development by an order of magnitude or more, but at the cost of having to monitor the performance of the GC, tune it as loads change and computers get more and more memory but don’t get any faster at accessing it, etc, etc.
Exceptions are another thing that speeds up development at the cost of maintenance down the road. You have to log the exceptions that are happening and monitor them to make sure that they are rare otherwise they’ll silently become more common over time as your program gets more complex. Meanwhile Rust’s explicit error handling really makes you think at every step about exactly what odd conditions your program might encounter. If you use Rust’s type system correctly, you can encode very specific information about exactly which errors are possible or impossible at every point in your system. It’s more work up front but it saves a huge amount of time down the road.
In principle you should be able to approach zero maintenance costs with any language, but writing your system in Rust generally means you have abandoned complexities like garbage collection. Garbage collection speeds up development by an order of magnitude or more, but at the cost of having to monitor the performance of the GC, tune it as loads change and computers get more and more memory but don’t get any faster at accessing it, etc, etc.
Exceptions are another thing that speeds up development at the cost of maintenance down the road. You have to log the exceptions that are happening and monitor them to make sure that they are rare otherwise they’ll silently become more common over time as your program gets more complex. Meanwhile Rust’s explicit error handling really makes you think at every step about exactly what odd conditions your program might encounter. If you use Rust’s type system correctly, you can encode very specific information about exactly which errors are possible or impossible at every point in your system. It’s more work up front but it saves a huge amount of time down the road.
> You can rewrite it in Rust once your system is large enough that eliminating the garbage collector will save you a few million dollars a year.
Never gonna happen.
Never gonna happen.
Why do you say that? We’ve all read articles from Cloudflare and Microsoft and others about rewriting services in Rust once it becomes obvious how much money they can save, so we know that it does happen. I’ve seen it happen at much smaller companies as well.
It would probably take several years to do a full rewrite of a complicated system, and there'd be subtle differences all over the place.
Then you don’t have good enough documentation or tests, and you probably tried to rewrite too much. You should rewrite that portion of your code where the performance is most critical, because that’s where you will save the most money.
Have you even worked with a big complicated legacy system whose authors have all quit?
Yes. A good example would be Firefox. Mozilla is gradually replacing core components of Firefox with replacements written in Rust. It is not cheap to do this without causing regressions, but they have a great test suite and they know that it will save money in the long run. It increases performance, decreases memory usage, and most importantly it greatly reduces the defect rate. They’ll probably never bother to replace _all_ of the C++ code with Rust, because a lot of it works well or isn’t security–critical. They’ve been doing this since Rust 1.0, with measurable improvements in every release of the last few years.
I'm glad I've been following rust since <1.0 when it was lot smaller (tbh because it was missing stuff), I don't know if I'd have the perseverance to start learning it today from scratch just because the depth it has. Admittedly having bit of C++ background smoothed the curve too.
I wasn't aware FullStory used Rust! That's good to know. I was worried I might have a hard time hiring folks in Atlanta with Rust experience.
The more Rust proliferates, the better. It's good at client, server, systems, and so many other things.
The more Rust proliferates, the better. It's good at client, server, systems, and so many other things.
I'm disappointed that you missed the opportunity for a well-placed pun there :)-
most fun I've had with a programming language in years
Rust is the first systems programming language since C++ I have seen pushed by multiple large tech companies.
Go was pushed primarily by Google
Swift was pushed primarily by Apple
C# was pushed primarily by Microsoft
I am seeing a push for Rust by Microsoft, Google, and Amazon.
In retrospect, it almost seems that Mozilla closing the Rust team was a good thing for Rust as a lot of the Rust developers ended up at other companies and Rust became more than just a Mozilla language.
Go was pushed primarily by Google
Swift was pushed primarily by Apple
C# was pushed primarily by Microsoft
I am seeing a push for Rust by Microsoft, Google, and Amazon.
In retrospect, it almost seems that Mozilla closing the Rust team was a good thing for Rust as a lot of the Rust developers ended up at other companies and Rust became more than just a Mozilla language.
I believe Rust evangelism spread to other companies long before Mozilla stopped incubating the language.
That is correct. These other companies were already employing people who worked on Rust in some capacity when all that happened.
Honestly all three languages are great in their own ways, but you're right in saying none of them really hit that low level "systems" niche.
I'm a big C# fan but I see very few use cases where I'd consider both.
I'm a big C# fan but I see very few use cases where I'd consider both.
The main reason is that Rust is the first new systems language in a long time. That no big players owned it helped as well.
Go and C# are not systems languages. Maybe a stretch goal at best.
Go and C# are not systems languages. Maybe a stretch goal at best.
As someone who once despised working with Rust pre-v1, I firmly believe Rust is the future.
Rust is actually more suited to those companies than the general public (small companies and individual programmers) so it makes sense they do push it hard.
Arguably Rust is great for small/single owner companies as well. It saves vast amounts of time in comparison to c/c++
Why would you say that is, or why do you think so?
I would argue Rust is definitely suited towards small companies and individuals for a lot of projects that C/C++ would’ve been used for before, even things like small audio units or plugins
I would argue Rust is definitely suited towards small companies and individuals for a lot of projects that C/C++ would’ve been used for before, even things like small audio units or plugins
Jonathan Blow puts it as the "cost of experimentation being too high" which I would agree with. Generally, as an individual or small group the limiting factor for you at times becomes time.
Sort of the philosophy where you design by programming instead of whiteboard or clearcut stuff. Less flexible design but more automatic correctness is worth it for big companies because projects involve millions of lines of code and thousands of people over the lifecycle.
It's sort of like writing microservices when you're an one man shop. The correct philosophy is monolith first - until you're doing something useful, don't obsess that much.
If you've got a clear vision of each project, or perhaps it's a larger scale project more similar to those in big tech, then perhaps Rust is best. But those kinds of projects typically don't even need C++/Rust. I use C++ for high performance experimental software.
I would like a C++ replacement also though, maybe through a design like Carbon where it's built above it. You could also then do stuff like making the borrow checker optional and with parts of the program instead, as a sort of finalization refactor. Combining the best of both worlds.
Sort of the philosophy where you design by programming instead of whiteboard or clearcut stuff. Less flexible design but more automatic correctness is worth it for big companies because projects involve millions of lines of code and thousands of people over the lifecycle.
It's sort of like writing microservices when you're an one man shop. The correct philosophy is monolith first - until you're doing something useful, don't obsess that much.
If you've got a clear vision of each project, or perhaps it's a larger scale project more similar to those in big tech, then perhaps Rust is best. But those kinds of projects typically don't even need C++/Rust. I use C++ for high performance experimental software.
I would like a C++ replacement also though, maybe through a design like Carbon where it's built above it. You could also then do stuff like making the borrow checker optional and with parts of the program instead, as a sort of finalization refactor. Combining the best of both worlds.
While true, the majority of development doesn't happen in systems languages but generally in garbage collected languages.
Rust has many design features that make it work well for larger teams.
Well that's not saying much. So does TypeScript. Those features that make it suitable for larger teams also make it a solid choice for smaller teams. It's hard to imagine a feature that benefits a large team much more than would benefit a smaller team but I'm open to an argument
The benefits of making illegal states unrepresentable, providing safe abstractions over unsafe boundaries, and high-quality built-in documentation scale quite nonlinearly to large teams is all.
Rust tries to be foolproof.
It is interesting that they have a day devoted to embedded using MicroBit v2.
The older Rust-Embedded Discovery book [0] also used Microbit but the later edition [1] suggests a STM32F3DISCOVERY. For RISC-V and Extensa fans there is also Ferrous Systems' Embedded Rust on Espressif training material [2] which has a coordinated board [3] that has been "cloned" by Wokwi [4].
0. https://docs.rust-embedded.org/discovery/microbit/index.html
1. https://docs.rust-embedded.org/book/index.html
2. https://esp-rs.github.io/espressif-trainings/
3. https://www.amazon.com/dp/B0B4FPV9FW
4. https://wokwi.com/projects/new/rust-esp32-rust-board
The older Rust-Embedded Discovery book [0] also used Microbit but the later edition [1] suggests a STM32F3DISCOVERY. For RISC-V and Extensa fans there is also Ferrous Systems' Embedded Rust on Espressif training material [2] which has a coordinated board [3] that has been "cloned" by Wokwi [4].
0. https://docs.rust-embedded.org/discovery/microbit/index.html
1. https://docs.rust-embedded.org/book/index.html
2. https://esp-rs.github.io/espressif-trainings/
3. https://www.amazon.com/dp/B0B4FPV9FW
4. https://wokwi.com/projects/new/rust-esp32-rust-board
For embedded Rust the biggest thing imho is that Infineon, a major microcontroller company, is officially supporting Rust https://www.infineon.com/cms/en/product/promopages/rust/
Don’t forget Espressif too.
My colleguage Andrew wrote the bare-metal part. I believe he picked the micro:bit board because it's readily available around the world. It also has a lot of fun sensors (microphone, rudimentary speaker, compass, ...). I'm sure there are other boards around, but so far people seem very happy with this board in our classroom training.
The only slight problem is the noise when 30 boards are powered on at once :-D They ship with an elaborate demo program which plays sounds and blinks the LEDs when you start it up.
The only slight problem is the noise when 30 boards are powered on at once :-D They ship with an elaborate demo program which plays sounds and blinks the LEDs when you start it up.
That makes sense. The first was great fun and v2 looks even better. I had written them off due to chip shortages but it looks like availablity is better now.
From https://google.github.io/comprehensive-rust/:
> This site uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. [Learn more] [Ok, Got it!]
No reject? :|
> This site uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. [Learn more] [Ok, Got it!]
No reject? :|
I've seen the same in many google pages (which I think is illegal under GDPR).Anyways, I use ublock origin to get rid of that.
> Android team at Google
I am partly joking but judging by the state of the last couple of Android versions, that doesn't sound as good as it used to be.
I am partly joking but judging by the state of the last couple of Android versions, that doesn't sound as good as it used to be.
Cool thing. I currently use ChatGPT to provide me some exercises as I get better at the language. This is more like a presentation that needs accompanying conversation from the presenter.
> I currently use ChatGPT to provide me some exercises as I get better at the language.
That's a good idea, thanks! I'm gonna do that too
That's a good idea, thanks! I'm gonna do that too
The dive into using it in AOSP is very cool
It's assumed that this book is accompanied by an experienced rust dev for a lecturer.
The posted link is to the GitHub repo, here's the link to the book:
https://google.github.io/comprehensive-rust/