I had a hard time learning rust at first. I didn’t quite know where to start, I focused on the wrong resources and lost some time. Here are my suggestions about everything you may need in order to learn and work with rust: where and what to learn, how to properly install the compiler, what tools you need and how to use them.
That’s not the topic of this article 🙂 I’ll assume you have a basic understanding of what it’s meant for, but are not quite sure where to get started.
I’ve learnt a lot of languages since I started programming, ~15 years ago. I’ve had the opportunity to use them both for personnal projects, out of curiosity, or in a professional setting, where the constraints are different. I guess I can consider myself an experienced developer.
Often, when it comes to learning a new language, things are easy: I simply pop a REPL or some sample hello world project, grab some documentation, and start messing around. I wrote a Brainfuck interpreter in Ruby a few hours after I started reading about the language, because the langage is very close to python, which I already knew.
Things in Rust didn’t work like that for me.
Like many, I tried to jump at writing code and faced a lot of walls. The compiler gives detailed explanations about where I did mistakes, but sometimes I didn’t understand what was wrong.
When learning rust, you don’t simply need to learn how to do things. You need to understand why you do them like this. And it will question a lot of your bad habits as a developer. Like using mutable variables when you don’t need to (it’s way more tricky than it sounds), extensively checking for errors (you really have no idea how terrible you are. Yes it’s hard, yes it’s not fun, but if you won’t to be in real control of what’s happening, yes, you should deal with all the errors your code may throw !), dealing with return values (not using one throws a warning in rust).
Rust enforces the principle of least privilege, and you’ll most likely notice (via trial and error) that it’s not something you’re used to. And that you don’t do it as much as you think you do. It’s pretty frustrating to feel like the code you usually write is bloated with mistakes, but this deeper understanding about how code should behave will help you and you code grow.
Once you understand why things work the way they do in Rust, it’s time to broaden your horizons.
Browsing through the code of popular crates will also help you understand some idiomatic code patterns. Plenty of them are on Github.
These resources cover a lot of ground but you may need help in order to understand some things. The Rust Playground will let you share and execute a code sample, so that’s easier for someone else to understand and debug or fix the piece of code you’re stuck with.
You can ask for help on stackoverflow, or Reddit but there is also the rust-beginners IRC channel on irc.mozilla.org. A lot of friendly people there.
A small overview about how to properly install rust and some dependencies that can be useful.
Contrarilly to many tools, you don’t install the rust compiler right away when you get started with rust: instead, you first install rustup, a rust compiler version manager. That’ll allow you to install multiple versions of rust, and switch between them at will. Some libraries, like clippy (it’s a rust linter) expect you to use the nightly build, while most of the time, you may want to use the latest stable release, so you may need to be able to switch between language versions.
Once you have installed rustup, you can install a new build of the language. For instance, here I install the latest nightly build:
You can see that I have two build toolchains setup: the stable and the nightly. The active one is the stable. So without more details, cargo run will execute thing with the active toolchain, but I can change it:
cargo is rust’s package manager. You’ll use cargo for a lot of things (on the rust book, for instance). Among other things, it can:
Thanks to cargo, you can easily get started with continuous integration of a platform like Travis-CI. For instance, you may want to run the tests every time a commit is pushed on a branch on github, in order to see if said branch breaks the project.
Travis-CI’s got some explanations regarding how to do that.
In a complex project, you may need a debugger in order to understand why things do not work the way you thought they were (no, printing stuff to the console is NOT a good habit).
You can use gdb (or better, rust-gdb, in provides more context). Instead of running your project with
Then, the application will run inside the debugger and you see what is happening. Here are some more info about getting started, and here is an useful list of how to’s) to get you started with gdb.
Out of the box, some things are missing: I’ll give you detail about how to properly and automatically format your code, how to lint and setup code completion.
There is not rust fmt like there is in Go. I think go fmt is fantastic, because it puts code style of out the equation. I find the talks about code style useless and boring, and I’ve found go fmt to be an amazing way to get that out of the way: in Go, the code style is part of the language.
There is no such thing in rust, but there is rustfmt. It’s a tool that enforces a given code style.
The you can reformat a source file or directory:
racer is a code completion tool. It’s super useful if you don’t want to have to browse the documentation every other second.
It relies on the rust source code to provide this information, so we need to download it before installing racer:
Then, you’ll need to setup racer in your IDE. I use atom, and there is an atom-racer package.
If you use rustup, you’ll need to provide 2 information in the settings of the rust-atom package:
I’ve also had an issue with flickering in Atom, because of the frequent creation of a temporary file. I solved it thanks to this page. Doesn’t sound solid, but that’s OK for now.
That’s it ! I hope this article gave you some ideas about where to get started learning rust, and what are the tools you may need. It’s a long road, but the landscape is worth it.
See a typo ? You can suggest a modification on Github.