Skip to content

Latest commit

 

History

History
165 lines (142 loc) · 12.9 KB

README.md

File metadata and controls

165 lines (142 loc) · 12.9 KB
Raw

A repository for Linux_Club@UCU Rust course.

Contents

  1. Schedule
  2. Resources
    1. Cool Rust Apps
    2. Books
    3. Practice
    4. Other resources
  3. Vim integration guide

Schedule

Latex sources are available here

Resources

Cool Rust apps

  • nushell - An interesting new type of shell
  • dust - A more intuitive replacement for du
  • ytop - A super-fast top replacement
  • broot - Cool new tree (a lot more usable)
  • bat - Updated cat (with git integration and a lot more)
  • exa - Modern replacement for ls
  • fd - find alternative
  • alacritty - GPU-accelerated terminal emulator
  • MdBook - Book generator from Markdown docs
  • Rust Godot bindings - Super fast replacement for GDScript
  • i3status-rust - Fast i3status replacement
  • zola - A fast static site generator in a single binary with everything built-in
  • paru - A replacement for yay from its original creator, now in Rust and faster.

Books

Beginner level

  • The Rust Programming Language - A must-read that goes through almost everything you will ever need to learn about Rust. This is also its main downside, as it might get a little too boring and difficult, it's better to combine it with separate practice and exercises, and just take breaks from it. Is also often referred to by the community as 'the Book', due to its importance and quality.

Intermediate level

  • Rust In Action (WIP) - A semi-official intermediate book that's still in progress (although in its finishing stages).
  • Command Line Book - What follows are official domain-specific books on main topics you might be interested in. Better to read them when you actually need to work on respective topics rather than as your first intermediate books.
  • WebAssembly Book
  • Embedded Book
  • The Rust Standard Library - Some of the best programming language documentation ever. A logical continuation of the Book, both stylistically and practically. Don't read all of it though! You might just need to explore a couple of topics to understand how basic Rust documentation works, and then just read up on something when you need it/when you are having problems with it. Once again, Rust documentation is awesome, it allows you to jump to the source code immediately, since recently it allows you to nicely link to stuff, allows to quickly look up types etc.
  • Async Book - Rust introduced stable async/.await syntax in 2019, which is now used in many libraries (tokio, rayon), and allows for fearless and beautiful concurrency.
  • Roguelike Book - A nice intro to Rust through a simple game (also uses ECS!)
  • Learn Rust With Entirely Too Many Linked Lists - A head-on Rust book that does not fear difficult Rust memory stuff and implements a bunch of linked lists (which are their own thing with Rust's ownership system).
  • The Little Book of Rust Macros - A nice little collection of practical lessons on Rust macros.

Intermediate References

  • Rust Reference - THE Reference, describing everything humanity knows about Rust. Almost. Use it as a table book, as an encyclopedia, not as a regular book!
  • Rust Cookbook - Super useful and smart ways of achieving basic things in Rust.
  • Possible Rust - Guides, Patterns and discussions on what is possible in Rust.
  • Rust Language Cheat Sheet - THE Cheat Sheet to quickly remind yourself how an if-else looks like. And everything else too.
  • Rust Edition Guide - Rust has a 6-week update cycle, but every now and then Rust releases a new edition which brings together features over the last few years and introduces breaking changes. This is a guide that helps to understand when certain things were introduced in Rust. This isn't the most useful thing to you right now, but might help occasionally.
  • Cargo Book - What follows are little books on Rust toolchain, consult them if you want to understand Rust ecosystem better or if you want to contribute to it.
  • RustDoc Book
  • Rustc Book
  • Compiler Error Index - ALL of the possible errors the Rust compiler might throw at you. There are legends of people who have memorized all of it and have obtained the power of the whole galaxy (or just have never encountered another Rust compiler error, and who is to say which is better).

Advanced level

  • Rustonomicon - I am going to steal the official description: " This book digs into all the awful details that are necessary to understand in order to write correct Unsafe Rust programs. Due to the nature of this problem, it may lead to unleashing untold horrors that shatter your psyche into a billion infinitesimal fragments of despair."
  • O'Reilly's Programming Rust 2017 or 2021(WIP) - O'Reilly books are awesome as always, but you should probably wait till 2021 edition comes out, it's in the final stages.
  • Mastering Rust - One of the strongest general advanced Rust books.
  • Rust Performance Book - An interesting relatively low-level dive into performant Rust.
  • The Unstable Book - Often in Rust you'll have to resort to using unstable features, which are included with various flags. Recently a lot of these have been merged into the stable Rust, but this book still provides many useful ones with detailed descriptions.

Practice

Other resources

  • Rust Anthology - A semi-abandoned (I think) but nevertheless impressive collection of great Rust blog posts.
  • Rust Patterns - A collection of useful (and idiomatic) Rust patterns for the most popular use cases.
  • Idiomatic Rust - A collection of idiomatic and beautiful Rust. Worth checking out.
  • Rust Learning - A huge collection of various Rust learning resources. Too overwhelming though.
  • Awesome Rust - One of those 'Awesome language' repos, just a collection of Rust projects.
  • Rust Using Simple English - Rust is difficult enough on its own, there is no need to complicate it with difficult English, and this guide solves this!
  • Read Rust - A collection of interesting Rust blog posts.
  • This Week In Rust - Weekly newsletter on all things Rust: new blog posts, videos, conferences, features etc.
  • This Month in OSDev - Monthly newsletter on Operating Systems development in Rust
  • This Month in GameDev - Monthly newsletter on gamedevelopment in Rust
  • pretzelhammer's blog - What follows is a bunch of blogs that I found nice, by no means an exhaustive list. pretzelhammer writes super cool deep dive articles on Rust-specific stuff which makes people's heads boil.
  • phil-op blog - Philipp Oppermann's x86 Operating System Blog. The next best thing in the Internet after this repository web page.
  • fasterthanlime blog - A great blog on all things Rust.
  • ralf jung's blog - A blog from one of the most prominent Rust safety researchers out there.
  • Luca Palmieri's blog - An interesting blog from "Zero To Production In Rust" series' author.
  • tyler neely's blog - More of an advanced blog from an author of many popular crates.
  • Yoshua Wuyts's blog - Cool writing on (mainly) Async Rust.
  • Niko Matsaki's blog - Niko Matsaki is a longtime Rust maintainer (and a part of the compiler team), and reading his insights is eye-opening.
  • Aleksey Kladov's blog - A more of an advanced blog from one of regular rustc contributors, mainly about async and multithreading.
  • William Woodruff's blog - Pretty cool blog on low-level things and how they work with Rust, if they do (and whether they should).
  • Depth-First blog - A few interesting things here. Not that many though.
  • Armin Ronacher's blog - This guy created Flask and Jinja. And now he writes about Rust. What more do you need.
  • Stephen Marz OS blog - RISC-V OS Blog.
  • Carlos Galdino's blog - This blog has an interesting practical Rust file system implementation.
  • Shesh's blog - A nice blog going over some of the basic Rust things and teaching Rust for JavaScript devs.
  • Gankra's blog - An awesome intermediate/advanced blog on the intricacies of Rust's (often unsafe) groundings from the author of the Rustonomicon.
  • A Gentle Introduction to Rust - One of the many relatively short intro guides to Rust. This is one of the better ones.
  • Rust101 - One of the many tutorials I think has something going for it (and the blog is awesome too!)
  • A creative coding framework - Just something I hacked with for a while and it's super nice.
  • RustStarterKit 2020 - An interesting guide on things you might wanna consider using if you work with Rust in 2020+. Since Rust has a minimal standard library, it suggests a few popular math crates, utility crates that work with different file formats, devices etc., as well as a lot of algorithms/data structures implemented efficiently, networking/web stuff, asynchronous crates.
  • Are We Web Yet? - What follows are several websites tracking Rust progress on the way of becoming a usable language in a specific domain. This requires having a bunch of often difficult libraries and vibrant communities to support them. Makes it a little easier to know whether Rust is okay to use in a web/game/ml/gui context.
  • Are We Game Yet?
  • Are We Learning Yet?
  • Are We IDE Yet?
  • Are We GUI Yet?
  • Are We Async Yet?

Vim Integration Guide

My dotfiles with detailed instructions are available over here.

You don't have to use Vim of course, Rust has nice integrations for most of the popular IDEs, including VSCode, JetBrains, Emacs etc.