How to learn modern Rust - A guide to the adventurer.

Overview

How to learn modern Rust

A guide to the adventurer.

Table of Contents

Learn Rust deeply one step after the other

Rust is an incredible powerful programming language. It is fast, compiled, without a runtime and it brings new concepts of safety to programming.
It is the most beloved language for five years in a row in Stack Overflow users pool.
To learn Rust go through the following content in the listed order, the majority of the content is free.

  1. Why Developers Love Rust
    https://ibraheem.ca/posts/why-devs-love-rust/

  2. Video - Rust Crash Course - Rustlang
    https://www.youtube.com/watch?v=zF34dRivLOw

  3. Video - Introduction to Rust Part 1
    https://www.youtube.com/watch?v=WnWGO-tLtLA

  4. Video - Introduction to Rust Part 2
    https://www.youtube.com/watch?v=lLWchWTUFOQ

  5. Video - Rust for the impatient - No Boilerplate
    https://www.youtube.com/watch?v=br3GIIQeefY

  6. A half-hour to learn Rust - fasterThanLime Blog
    https://fasterthanli.me/articles/a-half-hour-to-learn-rust

  7. Videos - Microsoft Beginner's Series to Rust
    https://www.youtube.com/playlist?list=PLlrxD0HtieHjbTjrchBwOVks_sr8EVW1x
    GitHub Code
    https://github.com/microsoft/beginners-series-rust

  8. The Tour of Rust
    https://tourofrust.com/

  9. A Rust experienced developer teaches a C++ experienced developer (Jason Turner) about Rust, from zero.
    Jonathan Teaches Jason Rust - Part 1 - C++ Weekly
    https://www.youtube.com/watch?v=EzQ7YIIo1rY
    Jonathan Teaches Jason Rust - Part 2 - C++ Weekly
    https://www.youtube.com/watch?v=Y5-ZgxfQvpc

  10. The Rust Programming Language Book
    by Steve Klabnik and Carol Nichols, with contributions from the Rust Community
    https://doc.rust-lang.org/stable/book/

  11. Rust Language Cheat Sheet
    https://cheats.rs/

  12. Rustlings
    Small exercises to get you used to reading and writing Rust code.
    https://github.com/rust-lang/rustlings

  13. Videos - Intro to Rustlang - Tensor Programming
    https://www.youtube.com/watch?v=EYqceb2AnkU&list=PLJbE2Yu2zumDF6BX6_RdPisRVHgzV02NW

  14. Videos - Rustlang Project - Tensor Programming
    https://www.youtube.com/watch?v=-Jp7sabBCp4&list=PLJbE2Yu2zumDD5vy2BuSHvFZU0a6RDmgb

  15. Standard collections - std info and how to choose the correct collection
    https://doc.rust-lang.org/std/collections/index.html

  16. Trivia About Rust Types: An Authorized Transcription of Jon Gjengset’s Twitter Thread
    https://www.thecodedmessage.com/posts/trivia-rust-types/

  17. Video - Unsafe & FFI in Rust
    https://www.youtube.com/watch?v=LFFbTeU25pE

  18. Rust by Example Book
    https://doc.rust-lang.org/rust-by-example/

  19. Study carefully the methods of Option in the documentation, they are used in all Rust programs
    https://doc.rust-lang.org/beta/std/option/index.html

  20. Study carefully the methods of Result in the documentation, they are used in all Rust programs
    https://doc.rust-lang.org/beta/std/result/index.html

  21. Command Line Applications in Rust - Book
    https://rust-cli.github.io/book/in-depth/docs.html

  22. The Rust Standard Library documentation
    https://doc.rust-lang.org/std/

  23. Learn Rust With Entirely Too Many Linked Lists - Book
    https://rust-unofficial.github.io/too-many-lists/

  24. Rust Design Patterns - Book
    https://rust-unofficial.github.io/patterns/

  25. Effective Rust - Book
    https://www.lurklurk.org/effective-rust/

  26. The Rust Cookbook - Book
    https://rust-lang-nursery.github.io/rust-cookbook/

  27. The Cargo Book
    https://doc.rust-lang.org/cargo/index.html

  28. Guide trough of the Advent of Code 2020
    https://fasterthanli.me/series/advent-of-code-2020

  29. Rust API Guidelines Book
    https://rust-lang.github.io/api-guidelines/about.html

  30. The Rust Reference Book
    https://doc.rust-lang.org/stable/reference/

  31. The Rustonomicon - The Dark Arts of Unsafe Rust - Book
    https://doc.rust-lang.org/nomicon/

  32. The Little Book of Rust Macros - Book
    https://veykril.github.io/tlborm/introduction.html

  33. Writing Interpreters in Rust: a Guide - Book
    https://rust-hosted-langs.github.io/book/introduction.html

  34. Video - Cheaply writing a fast interpreter - Neil Mitchell
    https://www.youtube.com/watch?v=V8dnIw3amLA
    github
    https://github.com/ndmitchell/interpret

  35. Make A Language
    A series about making a programming language called Eldiro using the Rust programming language.
    https://arzg.github.io/lang/

  36. Engineering Rust Web Applications - Book
    https://erwabook.com/

  37. Programming Rust: Fast, Safe Systems Development 2nd Ed
    by Jim Blandy, Jason Orendorff

  38. Rust for Rustaceans: Idiomatic Programming for Experienced Developers
    by Jon Gjengset

  39. Refactoring to Rust
    by Lily Mara

  40. Practical System Programming for Rust Developers
    Build fast and secure software for Linux/Unix systems with the help of practical examples
    by Prabhu Eshwarla

  41. Hands-On Concurrency with Rust: Confidently build memory-safe, parallel, and efficient software in Rust
    by Brian L. Troutwine

  42. GDB: The GNU Project Debugger
    https://www.gnu.org/software/gdb/documentation/

  43. The LLDB Debugger
    https://lldb.llvm.org/

  44. Valgrind User Manual
    https://valgrind.org/docs/manual/manual.html

  45. The perf Linux profiler - Examples of use
    https://www.brendangregg.com/perf.html

  46. QuickCheck - QuickCheck is a way to do property based testing using randomly generated input.
    https://github.com/BurntSushi/quickcheck

  47. American Fuzzy Lop - A good fuzzer
    https://lcamtuf.coredump.cx/afl/

  48. Criterion rs - Statistics-driven Microbenchmarking in Rust
    https://github.com/bheisler/criterion.rs

  49. The Complete Rust Programming Reference Guide: Design, develop, and deploy effective software systems using the advanced constructs of Rust
    by Rahul Sharma, Vesa Kaihlavirta

  50. Creative Projects for Rust Programmers: Build exciting projects on domains such as web apps, WebAssembly, games, and parsing
    by Carlo Milanesi

  51. Rust High Performance: Learn to skyrocket the performance of your Rust applications
    by Iban Eguia Moraza

  52. Writing an OS in Rust Philipp Oppermann's blog
    https://os.phil-opp.com/

  53. The Rust Unstable Book
    https://doc.rust-lang.org/beta/unstable-book/

Text Processing in Rust

  1. Text Processing in Rust
    by Mihalis Tsoukalos
    https://www.linuxjournal.com/content/text-processing-rust

  2. Working with strings in Rust - fasterThanLime Blog
    https://fasterthanli.me/articles/working-with-strings-in-rust

  3. String continuations
    The backslash, the newline and the starting spaces will disappear.

println!(
    "... the {p}, by the {p}, for the {p}, \
    will never fall.",
    p = "people"
);

Will print: 
"... the people, by the people, for the people, will never fall."
  1. For ASCII Strings (value lower then 127) non UTF-8 strings, one can process much faster the string if it is converted to bytes and then compared to bytes.
let my_str = "Hello!".to_string();
for c in my_str.chars() {
    if c == 'l' {
        // Do something!
    }
}

// A faster implementation for ASCII characters would be.

let my_str_2 = "Hello!".to_string();
for b in my_str.bytes() {
    if b == b'l' {
        // Do something!
    }
}

// There is also a slice of bytes.

let my_str_3 = "Hello!".to_string();
let my_str_as_bytes_slice = my_str_3.as_bytes();

if my_str_as_bytes_slice[2] == b'l' {
        // Do something!
}
  1. Kibi - A text editor in ≤1024 lines of code, written in Rust
    https://github.com/ilai-deutel/kibi

  2. Rust substring processing
    My section below on it.

How Rust maps to memory and lifetimes annotations in Rust

  1. Video - Visualizing memory layout of Rust's data types - Sreekanth
    Incredible video!
    https://www.youtube.com/watch?v=rDoqT-a6UFg

  2. Video - Understanding Rust Lifetimes - Ryan Levick
    https://www.youtube.com/watch?v=MSi3E5Z8oRw

  3. Video - Crust of Rust: Lifetime Annotations - Jon Gjengset
    https://www.youtube.com/watch?v=rAl-9HwD858

  4. Implementing a HashMap in Rust.
    Video - Live-coding a linked hash map in Rust - Jon Gjengset
    https://www.youtube.com/watch?v=k6xR2kf9hlA

How to deal with Circular References and Ownership

The previous link demonstrated 3 ways to attack the problem:

1- Defer borrow checking to run-time, by using a reference-counted pointer (std::rc::Rc) to a std::cell:RefCell.

2- Centralize the ownership (e.g. all nodes are owned by a vector of nodes in the Tree), and then references become handles (indices into the a vector).

3- Use raw pointers and unsafe blocks to go around the rules of safe Rust.

Polymorphism in Rust

Rust Testing and TDD - Test Driven Development

Systems programming in Rust

Background in systems programming

  1. How to learn modern Linux
    https://github.com/joaocarvalhoopen/How_to_learn_modern_Linux

  2. Safe Systems Programming in Rust
    By Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, Derek Dreyer
    https://cacm.acm.org/magazines/2021/4/251364-safe-systems-programming-in-rust/fulltext

  3. The Linux Command Line, 2nd Edition: A Complete Introduction Illustrated Edition
    by William Shotts

  4. How Linux Works, 3rd Edition: What Every Superuser Should Know 3rd Edition
    by Brian Ward

  5. Operating Systems: Three Easy Pieces
    Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau
    http://pages.cs.wisc.edu/~remzi/OSTEP/

  6. The Linux Programming Interface: A Linux and UNIX System Programming Handbook
    by Michael Kerrisk
    Note: Read this book from cover to cover!

  7. System Programming Vol I and Vol II
    by Jin-Jwei Chen
    Note: Read this book from cover to cover!

  8. Dive into Systems
    by Suzanne J. Matthews, Tia Newhall, Kevin C. Webb
    https://diveintosystems.org/
    Note: Read this book from cover to cover!

  9. Linux Device Drivers, 3th Edition
    https://lwn.net/Kernel/LDD3/

  10. Linux Driver Development for Embedded Processors - 2th Edition: Learn to develop Linux embedded drivers with kernel 4.9 LTS
    by Alberto Liberal de los Ríos

  11. Computer Systems: A Programmer's Perspective 3rd Edition
    by Randal Bryant, David O'Hallaron

  12. Computer Networking: A Top-Down Approach
    by James Kurose

  13. The Illustrated Network: How TCP/IP Works in a Modern Network 2nd Edition
    by Walter Goralski

  14. C Programming: A Modern Approach, 2nd Edition
    by K. N. King

  15. Effective C - An Introduction to Professional C Programming
    by Robert C. Seacord

  16. CERT C Coding Standard - The 98 Rules for Developing Safe, Reliable, and Secure Systems 2nd Edition
    by Robert C. Seacord (Author)**

  17. Extreme C: Taking you to the limit in Concurrency, OOP, and the most advanced capabilities of C
    by Kamran Amini

  18. Programming - Principles and Practice Using C++ 2nd Edition, C++ 14
    by Bjarne Stroustrup

  19. C++ Crash Course: A Fast-Paced Introduction, C++ 17
    by Josh Lospinoso

Writing Compilers in Rust

  1. Crafting Interpreters
    by Robert Nystrom
    The book license is Creative Commons.
    https://craftinginterpreters.com/
    Lox Implementations
    https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations
    Crafting Interpreters in Rust - tdp2110
    https://github.com/tdp2110/crafting-interpreters-rs
    Crafting A Lox Interpreter In Rust, Part 1 - Diego Freijo
    https://www.diegofreijo.com/blog/rlox-vm-a-lox-interpreter-in-rust-part-1/

  2. Video Play List - Crafting Interpreters - Uncle Scientist
    https://www.youtube.com/playlist?list=PLib6-zlkjfXluRjBgK8grQH2IUSZjn-YN

  3. LISP interpreter in Rust
    https://vishpat.github.io/lisp-rs/

  4. Writing An Interpreter In Go
    by Thorsten Ball

  5. Writing A Compiler In Go
    by Thorsten Ball

  6. Compilers: Principles, Techniques, and Tools
    by Alfred Aho, Monica Lam, Ravi Sethi

Contributing to the Rust Compiler rustc

  1. Video - RustConf 2021 - Hacking rustc: Contributing to the Compiler by Esteban Kuber
    https://www.youtube.com/watch?v=9H9SO2u6Q20

  2. Video - rustc - A talk by Mark Mansi about the Rust programming language and compiler
    https://www.youtube.com/watch?v=68U8ZZ1EnEQ

  3. Video - Hacking on rustc - Negative literals in indexing expressions
    https://www.youtube.com/watch?v=OGihuce8rl8

  4. Rust Lang - Compiler Team
    https://rust-lang.github.io/compiler-team/

  5. The Rust Compiler - rustc
    https://github.com/rust-lang/rust

  6. rustc API docs - rustdoc documentation for the compiler
    https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/

  7. Zulip Chat - rust-lang
    https://rust-lang.zulipchat.com/

  8. Forum Rust Internals
    https://internals.rust-lang.org/

  9. Guide to Rustc Development - Book
    https://rustc-dev-guide.rust-lang.org/

  10. Video Play List - rustc lecture series
    https://www.youtube.com/playlist?list=PL85XCvVPmGQhOL-J2Ng7qlPvDVOwYpGTN

WebAssembly in Rust - WASM

  1. Rust and WebAssembly - Book
    https://rustwasm.github.io/docs/book/

  2. Write Your First WASM Module using Rust
    https://www.youtube.com/watch?v=nW71Mlbmxt8

  3. Getting Started with WebAssembly and Rust: A First Look
    https://www.youtube.com/watch?v=YHJjmsw_Sx0

  4. Crate wasm-bindgen
    Facilitating high-level interactions between Wasm modules and JavaScript.
    GitHub
    https://github.com/rustwasm/wasm-bindgen
    The wasm-bindgen guide - Book
    https://rustwasm.github.io/docs/wasm-bindgen/

  5. Project WASM Fourier
    Example of browser audio microphone data passed to Rust WASM module.
    Note: Really cool example to study and for example do APP's with audio processing on Rust.
    https://github.com/linanova/wasm-fourier

  6. Video - Rust + Yew + WASM + Canvas - Vers Binarii
    https://www.youtube.com/watch?v=7Smco8araSo

WebFrameworks in Rust - Similar to React Angular or Vue

Python extended with Rust and running a Python interpreter inside Rust

  1. PyO3 - GitHub
    https://github.com/PyO3/pyo3

  2. The PyO3 user guide - Book
    https://pyo3.rs/master/

  3. Python Extensions in Pure Rust with PyO3
    https://depth-first.com/articles/2020/08/10/python-extensions-in-pure-rust-with-pyo3/

  4. RustPython - A Python-3 interpreter written in Rust
    https://github.com/RustPython/RustPython

Rust with inline Python

In a program made in Rust, use a macro to insert inline Python and move easily data (variables) between the two.

// Example_1 

use inline_python::python;

fn main() {
    let who = "world";
    let n = 5;
    python! {
        for i in range('n):
            print(i, "Hello", 'who)
        print("Goodbye")
    }
}
// Example_2 
// Creates the data in Rust and plots the plot with inline Python with the lib matplotlib.

use inline_python::python;

fn main() {
    let data = vec![(4, 3), (2, 8), (3, 1), (4, 0)];
    python! {
        import matplotlib.pyplot as plt
        plt.plot('data)
        plt.show()
    }
}
  1. Crate inline-python
    Inline Python code directly in your Rust code
    https://crates.io/crates/inline-python

The inner workings and all the development steps of this project are beautifully explained, in detail, on this sequence of blog posts.

  1. Writing Python inside your Rust code - Part 1 - Mara's Blog
    https://blog.m-ou.se/writing-python-inside-rust-1/

  2. Writing Python inside your Rust code - Part 1A - Mara's Blog
    https://blog.m-ou.se/writing-python-inside-rust-1a/

  3. Writing Python inside your Rust code - Part 2 - Mara's Blog
    https://blog.m-ou.se/writing-python-inside-rust-2/

  4. Writing Python inside your Rust code - Part 3 - Mara's Blog
    https://blog.m-ou.se/writing-python-inside-rust-3/

  5. Writing Python inside your Rust code - Part 4 - Mara's Blog
    https://blog.m-ou.se/writing-python-inside-rust-4/

Rust on or for the Raspberry Pi

  • There are two modes of using Rust with the Raspberry Pi.
    The first one is installing Rust development tools on the Raspberry Pi it self, and the second one is installing on the PC and making cross-compilation to generate a executable that runs on the Raspberry Pi.

Developing on the Raspberry Pi and running Rust programs on the Raspberry Pi

  1. How to Get Started With Rust on Raspberry Pi
    https://www.muo.com/tag/getting-started-rust-raspberry-pi/

Developing on the PC and cross-compiling to run Rust programs on the Raspberry Pi

  1. Cross Compiling Rust for the Raspberry Pi
    It also explains a method to automatically coping the file to the Raspberry Pi after compilation.
    https://chacin.dev/blog/cross-compiling-rust-for-the-raspberry-pi/

  2. Cross compiling Rust for Raspberry Pi
    https://dev.to/h_ajsf/cross-compiling-rust-for-raspberry-pi-4iai

Raspberry Pi Bare Metal

  1. Github - Zoltan Baldaszti - Bare metal Raspberry Pi 3 tutorials
    https://github.com/bztsrc/raspi3-tutorial/

  2. Writing a bare metal operating system for Raspberry Pi 4
    https://www.rpi4os.com/

  3. Video Playlist - Low Level Devel - Raspberry Pi Bare Metal
    https://www.youtube.com/playlist?list=PLVxiWMqQvhg9FCteL7I0aohj1_YiUx1x8

  4. Video baremetal Rust Runs on everything, Including the Raspberry Pi - Embedded Rust Tutorial
    by Low Level Learning
    https://www.youtube.com/watch?v=jZT8APrzvc4

  5. Github - Operating System development tutorials in Rust on the Raspberry Pi
    https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials

Embedded Rust

  1. An Overview of the Embedded Rust Ecosystem - end 2020
    https://www.youtube.com/watch?v=vLYit_HHPaY

  2. Awesome embedded rust - Github
    Everything you need to know including drivers to connect external devices to the micro-controller.
    https://github.com/rust-embedded/awesome-embedded-rust

  3. The Embedded Working Group Newsletter or Blog
    https://rust-embedded.github.io/blog/

  4. Discovery Book
    Good starting point for MicroBit and STM32
    https://docs.rust-embedded.org/discovery/

  5. PlayList - Embedded Rust course - JaJakub - 2022
    https://www.youtube.com/playlist?list=PLL2SCPK5xSRWBPj-nKOVYIhxRw7C4kYeI

  6. Live streams with a good example of developing with Embedded Rust in STM32 BluePill
    Embedded Rust - Vers Binarii
    https://www.youtube.com/playlist?list=PLP_X41VhYn5X6Wwjnm0bRwI3n2pdaszxU

  7. Embedded Hardware Development with Rust - 2018
    https://www.youtube.com/watch?v=g25xsK3HKkE

  8. Embedded Programming is Getting Rust-y - end of 2021
    Embedded Computing Design
    https://www.youtube.com/watch?v=sOTx5324nKI

  9. The Embedded Rust Book
    Second fantastic book to read
    Generic for any type of chip brand.
    https://docs.rust-embedded.org/book/

  10. Workbook for Embedded Workshops - Book
    Using the Nordic nRF52840 Development Kit.
    https://embedded-trainings.ferrous-systems.com/

  11. The Embedonomicon Book
    Deep dive into the inner workings.
    https://docs.rust-embedded.org/embedonomicon/

  12. Video - How can we write the best device driver?
    https://www.youtube.com/watch?v=z9z74VpqO9A

  13. Video - RTIC - Real Time Interrupt driven Concurrency
    RTIC is a RTOS - Real Time Operating System.
    https://www.youtube.com/watch?v=saNdh0m_qHc

  14. RTIC Book
    Real-Time Interrupt-driven Concurrency.
    A very efficient preemptive multitasking framework that supports task prioritization and dead lock free execution.
    https://rtic.rs/1.0/book/en/

  15. Github - rtic-rs - cortex-m-rtic
    https://github.com/rtic-rs/cortex-m-rtic

  16. Video - Grepit about the Rust RTIC framework
    https://www.youtube.com/watch?v=sSJ-Md8nwIM

  17. Good RTIC project example
    Rust firmware for IR thermometer in STM32 with LCD - geomatsi - rust-ir-thermo
    https://github.com/geomatsi/rust-ir-thermo

  18. Video - Bare Metal Audio Programming With Rust - Antoine van Gelder - ADC20
    https://www.youtube.com/watch?v=udlK1LQ3f3g
    Slides
    https://flowdsp.io/talks/talk-adc20/#1

  19. Video - Building a simple logic analyser in Rust
    Rust Linz, September 2020 - Roland Ruckerbauer - Embedded Rust
    Board used stm32 compatible bluepill.
    https://www.youtube.com/watch?v=xY342ACNXFg
    Slides
    https://github.com/ruabmbua/rlogic/blob/master/presentation.pdf
    Github - ruabmbua - rlogic
    https://github.com/ruabmbua/rlogic

Embedded Rust crates and code size optimization

  1. Crate heapless
    https://github.com/japaric/heapless
   Arc         - Thread-safe reference-counting pointer backed by a memory pool
   BinaryHeap  - Priority queue
   IndexMap    - Hash table
   IndexSet    - Hash set
   LinearMap
   Pool        - Lock-free memory pool
   String
   Vec
   mpmc::Q*    - Multiple producer multiple consumer lock-free queue
   spsc::Queue - Single producer single consumer lock-free queue
  1. Crate ufmt
    A (6-40x) smaller, (2-9x) faster and panic-free alternative to core::fmt
    https://github.com/japaric/ufmt

  2. LCD 16x2 - Crate hd44780-driver
    Implementation of the embedded-hal traits for the HD44780, 16x1, 16x2 and 16x4.
    https://github.com/JohnDoneth/hd44780-driver

  3. Crate Embedded graphics
    It's a 2D graphics library that is focused on memory constrained embedded devices.
    https://github.com/embedded-graphics/embedded-graphics

  4. Crate flip-link
    Adds zero-cost stack overflow protection to your embedded programs.
    https://github.com/knurling-rs/flip-link/

  5. Crate defmt
    defmt ("de format", short for "deferred formatting") is a highly efficient logging framework that targets resource-constrained devices, like micro-controllers.
    https://github.com/knurling-rs/defmt/

  6. TOML compilation flag options to generate smaller code size

....

[profile.release.package."*"]
opt-level = "z"

[profile.release]
codegen-units = 1
debug = true
opt-level = "z"

Embedded Rust with STM32 BluePill - STM32F103

  1. STM32 BluePill in Rust - Project template and lot's of info
    This is the project template I use in my BluePill projects.
    https://github.com/joaocarvalhoopen/stm32_bluepill_in_rust__Template

Embedded Rust with Raspberry Pi Pico - 4 dollars board

  1. All relevant Info and a starting project Template.
    Where I have put all the info that I consider to be relevant for Pico development in Rust.
    Raspberry Pi Pico in Rust Proj Template with RTIC USB-Serial and UF2
    https://github.com/joaocarvalhoopen/Raspberry_Pi_Pico_in_Rust__Proj_Template_with_RTIC_USB-Serial_UF2

  2. Raspberry Pi Pico - rp-HAL
    https://github.com/rp-rs/rp-hal
    rp2040-hal - Examples
    https://github.com/rp-rs/rp-hal/tree/main/rp2040-hal/examples
    Examples for the board rp-pico.
    https://github.com/rp-rs/rp-hal/tree/main/boards/rp-pico
    Documentation
    https://docs.rs/rp2040-hal/latest/rp2040_hal/

  3. Site - rp2040 - Chip documentation
    https://www.raspberrypi.com/documentation/microcontrollers/

  4. Getting Started with Rust on a Raspberry Pi Pico - Part 1
    https://reltech.substack.com/p/getting-started-with-rust-on-a-raspberry

  5. Getting Started with Rust on a Raspberry Pi Pico - Part 2
    https://reltech.substack.com/p/getting-started-with-raspberry-pi

  6. Getting Started with Rust on a Raspberry Pi Pico - Part 3
    https://reltech.substack.com/p/getting-started-with-rust-on-a-raspberry-a88

  7. Oleg Eterevsky comment on the previous page - Slightly simpler setup. Instead of using a separate controller for handling the debug, he have just set up debug logging via USB serial port. This requires a bit more boilerplate (handling the USB interrupt and such), but is much simpler from the hardware perspective: you need to just plug in a single Pico board in your USB, flash it and you can immediately see the debug output.
    USB_Serial - repo
    https://github.com/eterevsky/rp2040-blink

  8. Crate usb-device - Experimental device-side USB stack for embedded devices.
    https://crates.io/crates/usb-device

  9. Way to easily Reboot the Pico to USB-PEN mode to program it
    You can have a easy reboot without needing to disconnecting and while pressing the boot button reconnecting the cable.
    Just add a switch from pin RUN to GND and while pressing the Boot Button press the Run Button and release the Run switch and them the Boot Button. It will enter the USB-PEN mode, that allows you to program by just coping the Rust or C binary from the PC to the Raspberry Pico micro-controller.
    See official documentation for details.

  10. PlayList - Rust Pico - Low Level Learning
    https://www.youtube.com/playlist?list=PLc7W4b0WHTAUAEAguiqpNa5H0QqXJIJI6

  11. Play List - Raspberry Pi Pico in C - Low Level Learning
    https://www.youtube.com/playlist?list=PLc7W4b0WHTAV6EYRVayb9c9dEsq-NeXAt

  12. PlayList - Intro to Raspberry Pi Pico and RP2040 - Digi-Key
    C/C++ and MicroPython
    https://www.youtube.com/playlist?list=PLEBQazB0HUyQO6rJxKr2umPCgmfAU-cqR

  13. In-depth: Raspberry Pi Pico's PIO - programmable IO - stacksmashing
    https://www.youtube.com/watch?v=yYnQYF_Xa8g

  14. Site - Raspberry Pi Pico
    https://www.raspberrypi.com/products/raspberry-pi-pico/

  15. Site - Getting started with Raspberry Pi Pico
    https://projects.raspberrypi.org/en/projects/getting-started-with-the-pico/0

  16. Book - Get Started with MicroPython on Raspberry Pi Pico
    https://hackspace.raspberrypi.com/books/micropython-pico

  17. Book - Adafruit - Getting Started with Raspberry Pi Pico and CircuitPython
    https://cdn-learn.adafruit.com/downloads/pdf/getting-started-with-raspberry-pi-pico-circuitpython.pdf

  18. Video - The Raspberry Pi Pico Review - $4 ARM Microcontroller
    https://www.youtube.com/watch?v=dUCgYXF01Do

  19. Video - Raspberry Pi Pico VGA video output using only resistors
    https://www.youtube.com/watch?v=RmPWcsvGSyk

Embedded Rust with ESP32

  1. esp-rs - Rust on ESP-IDF "Hello, World" template
    https://github.com/esp-rs/esp-idf-template

  2. Video - Embedded Rust: Wifi and I2C on a ESP32-C3 - Andrei Litvin
    https://www.youtube.com/watch?v=CXm7NdBBegk
    GitHub andy31415 - rust-esp32-c3-demos
    https://github.com/andy31415/rust-esp32-c3-demos/tree/oled_wifi

  3. ivmarkov - rust-esp32-std-demo
    A complex demo of ESP32 in Rust
    https://github.com/ivmarkov/rust-esp32-std-demo

Links

  1. Rust site
    A language empowering everyone to build reliable and efficient software.
    https://www.rust-lang.org/

  2. Song - Rust 2021 Edition
    https://www.youtube.com/watch?v=q0aNduqb2Ro

  3. Crate.io - The Rust community’s crate registry
    https://crates.io/

  4. Rust weekly news letter
    https://this-week-in-rust.org/

  5. The Little Book of Rust Books
    https://lborb.github.io/book/title-page.html

  6. Awesome-rust
    https://github.com/rust-unofficial/awesome-rust

  7. Awesome-embedded-rust
    https://github.com/rust-embedded/awesome-embedded-rust

  8. Rust Analyzer - User manual and short cut keys
    https://rust-analyzer.github.io/manual.html

  9. Jon Gjengset - Rust in depth Youtube channel.
    https://www.youtube.com/c/JonGjengset

  10. Tokio
    Tokio is an asynchronous runtime (async and await) for the Rust programming language. It provides the building blocks needed for writing network applications. It gives the flexibility to target a wide range of systems, from large servers with dozens of cores to small embedded devices.
    See the tutorials.
    https://tokio.rs/

  11. Best async and await introduction video.
    Video - Crust of Rust: async e await - Jon Gjengset
    https://www.youtube.com/watch?v=ThjvMReOXYM

  12. Video - Creating a Chat Server with async Rust and Tokio – Lily Mara
    https://www.youtube.com/watch?v=Iapc-qGTEBQ

  13. Tracing - Log tracing platform
    https://github.com/tokio-rs/tracing

  14. Actix Web
    Web Framework that's blazing fast, secure, asynchronous runs over Tokio and is "similar" to Flask of Python.
    Can process 650.000 request per second.
    https://actix.rs/

  15. Rocket
    Web Framework that's fast, secure and more "similar" to Django of Python.
    https://rocket.rs/

  16. Serde
    Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.
    https://serde.rs/
    https://crates.io/crates/serde

  17. BindGen
    Automatically generates Rust FFI bindings to C and C++ libraries.
    https://crates.io/crates/bindgen
    Tutorial guide.
    https://rust-lang.github.io/rust-bindgen/

  18. Hacking rustc: Contributing to the Compiler by Esteban Kuber - RustConf 2021
    https://www.youtube.com/watch?v=9H9SO2u6Q20

Rust Foundation

  1. Video - What Is Rust Foundation?
    https://www.youtube.com/watch?v=AI4lPN0BqGc

  2. Site - Rust Foundation
    https://foundation.rust-lang.org/

Rust Blogs

  1. pretzelhammer's Rust blog
    https://github.com/pretzelhammer/rust-blog

    1. RESTful API in Sync & Async Rust - pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/restful-api-in-sync-and-async-rust.md

    2. Common Rust Lifetime Misconceptions - pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/common-rust-lifetime-misconceptions.md

    3. Tour of Rust's Standard Library Traits - pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/tour-of-rusts-standard-library-traits.md

    4. Sizedness in Rust – pretzelhammer
      https://github.com/pretzelhammer/rust-blog/blob/master/posts/sizedness-in-rust.md

  2. fasterThanLime Blog - Amos Wenger
    https://fasterthanli.me

Rust Youtube Channels

  1. Channel Rust
    https://www.youtube.com/c/RustVideos/videos

  2. Channel Rust Foundation
    https://www.youtube.com/channel/UC0jzvznwtnsdXYIp415oC9g/videos

  3. Channel fasterthanlime - Amos Wegner
    https://www.youtube.com/c/fasterthanlime/videos

  4. Channel Jon Gjengset - Rust in depth Youtube channel.
    https://www.youtube.com/c/JonGjengset/videos

  5. Channel Tensor Programming - Intro to Rust
    https://www.youtube.com/playlist?list=PLJbE2Yu2zumDF6BX6_RdPisRVHgzV02NW

  6. Channel Tensor Programming - Rust Projects
    https://www.youtube.com/playlist?list=PLJbE2Yu2zumDD5vy2BuSHvFZU0a6RDmgb

  7. Channel Let's Get Rusty
    https://www.youtube.com/c/LetsGetRusty/videos

  8. Channel Uncle Scientist
    https://www.youtube.com/channel/UClnm0enwPt9iPWGZ5uh3Bfw/videos

  9. Channel Ryan Levick
    https://www.youtube.com/c/RyanLevicksVideos/videos

  10. Channel Tantan
    https://www.youtube.com/c/Tantandev/videos

  11. Channel Crazcalm's Tech Stack
    https://www.youtube.com/c/CrazcalmsTechStack/videos

  12. Channel Ferrous Systems GmbH
    Embedded Rust
    https://www.youtube.com/c/FerrousSystemsGmbH/videos

  13. Channel JaJakub
    Embedded Rust
    https://www.youtube.com/c/JaJakubYT/videos

  14. Channel Vers Binarii
    Embedded Rust
    https://www.youtube.com/channel/UCgLxnJi8BU476a3uZO29H4w/videos

GUI programming in Rust

  1. GTK4 - Unlocking the GNOME stack for Rust
    https://gtk-rs.org/

  2. Book - GUI development with Rust and GTK 4
    https://gtk-rs.org/gtk4-rs/stable/latest/book/

  3. Relm4 for GTK4
    https://github.com/AaronErhardt/relm4

  4. Speedrunning GUI development in Rust
    Hint: 1.2 seconds compilation technic.
    https://aaronerhardt.github.io/blog/posts/gui_speedrun/

  5. egui: an easy-to-use GUI in pure Rust
    Normal desktop GUI and WebAssembly written entirely in Rust, immediate mode.
    https://github.com/emilk/egui

  6. eGUI - Web Demo
    https://emilk.github.io/egui/index.html

  7. eframe - It's the official framework library for writing apps using egui
    https://github.com/emilk/egui/tree/master/eframe

  8. egui - 7a. Building a GUI app in Rust - Part A - creativcoder
    https://www.youtube.com/watch?v=NtUkr_z7l84

  9. egui - 7b. Building a GUI app in Rust - Part B - creativcoder
    https://www.youtube.com/watch?v=SvFPdgGwzTQ

  10. egui - 8. Building a web app in Rust - WASM - creativcoder
    https://www.youtube.com/watch?v=4MKcqR9z8AU

  11. Crate confy
    To maintain the state fo the APP in a config file. Serializes and deserializes automatically with Serde.
    https://github.com/rust-cli/confy

  12. Crate tracing
    https://github.com/tokio-rs/tracing

  13. pix_engine
    It's a cross-platform graphics & UI library for simple games, visualizations, digital art, and graphics applications. A kind of more simple Processing or p5.js but for Rust. Has a good collection of examples.
    https://github.com/lukexor/pix-engine

Audio in Rust

  1. RustAudio
    Free and useful Audio, DSP and music libraries written in Rust.
    https://github.com/RustAudio

  2. CPAL - Cross-Platform Audio Library
    Low-level library for audio input and output in pure Rust.
    Works aldo in WASM.
    https://github.com/RustAudio/cpal

  3. Rodio - Audio playback library
    MP3, WAV, Vorbis, Flac, MP4 and AAC.
    https://github.com/RustAudio/rodio

  4. dasp - Digital Audio Signal Processing in Rust
    https://github.com/RustAudio/dasp

  5. rust-portaudio - PortAudio bindings and wrappers for Rust.
    https://github.com/RustAudio/rust-portaudio

Faster Compilation - Linker times in Linux and Unix ELF

mold is optimized for Linux, zld only works on macOS. For production use, lld might be the most mature option.

mold is a high-performance drop-in replacement for existing Unix linkers. It is several times faster than LLVM lld linker
In the context of building a Relm4 for GTK-4 GUI application:
"With mold I was able to reduce my incremental compile times by factor 7 to only about 1.2 second. With this, it’s really fun to play with the code of the UI as you can see the result of your changes almost immediately." by the author of Relm4

  1. Mold
    https://github.com/rui314/mold
// After installing mold, all you need to do is add the
// prefix mold -run to the command you want to run.
// Most likely this will be:

mold -run cargo run
  1. Tips for Faster Rust Compile Times
    https://endler.dev/2020/rust-compile-times/

Machine Learning for Rust

  1. Taking ML to production with Rust: a 25x speedup
    https://www.lpalmieri.com/posts/2019-12-01-taking-ml-to-production-with-rust-a-25x-speedup/

  2. Machine learning in Rust using Linfa
    https://blog.logrocket.com/machine-learning-in-rust-using-linfa/

  3. Crate Linfa
    linfa aims to provide a comprehensive toolkit to build Machine Learning applications with Rust.
    Kin in spirit to Python's scikit-learn, it focuses on common preprocessing tasks and classical ML algorithms for your everyday ML tasks.
    https://crates.io/crates/linfa
    https://github.com/rust-ml/linfa

  4. Crate tch-rs
    Rust wrappers for the PyTorch C++ api (libtorch).
    https://crates.io/crates/tch
    https://docs.rs/tch

  5. Crate Rust TensorFlow
    TensorFlow Rust provides idiomatic Rust language bindings for TensorFlow.
    https://crates.io/crates/tensorflow
    https://github.com/tensorflow/rust

  6. Crate rust-xgboost
    Rust bindings for the XGBoost gradient boosting library.
    https://crates.io/crates/xgboost

Rust VSCode plugins

  1. rust-analyzer
    Code analyzer while editing
    https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer
    For better warnings in the same user interface, go into the VSCode settings > Rust Analyzer > Check On Save: Command and setting “clippy” instead of “check”.

  2. Better TOML
    .toml syntax hilight.
    https://marketplace.visualstudio.com/items?itemName=bungcip.better-toml

  3. Error Lens
    Better positioning of error messages in editor.
    https://marketplace.visualstudio.com/items?itemName=usernamehw.errorlens

  4. CodeLLDB - Vadim Chugunov
    Debugger plugin for Rust.
    https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb

  5. Code Spell Checker
    https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker

  6. Markdown All in One
    https://marketplace.visualstudio.com/items?itemName=yzhang.markdown-all-in-one

Rust Debugger

  1. How to Debug Rust with Visual Studio Code
    https://www.forrestthewoods.com/blog/how-to-debug-rust-with-visual-studio-code/

  2. Debugging Rust with VS Code
    https://dev.to/rogertorres/debugging-rust-with-vs-code-11dj

  3. CodeLLDB - Vadim Chugunov
    Plugin for VS Code
    https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb

Rust Error Handling

To define good error types that encapsulate other errors. In the case where you need to return from a function, multiple incompatible types, and you don't want to manually write conversion functions that implement the trait std::convert::From< > .

  1. Crate Anyhow
    Use Anyhow if you don't care what error type your functions return, you just want it to be easy. This is common in application code.
    https://crates.io/crates/anyhow

  2. Crate thiserror
    Use thiserror if you are a library that wants to design your own dedicated error type(s) so that on failures the caller gets exactly the information that you choose.
    https://crates.io/crates/thiserror

Tips and Tricks

GC for Rust - Garbage Collector

“Cases where one needs to maintain a complicated, dynamic graph “(with cycles)” are where a GC becomes useful. Similarly, if one is writing an interpreter for a GCd language, having a GC in Rust would simplify things a lot.”

Programming Parallel computers - Optimization guide C Plus Plus and Rust

  1. Programming Parallel Computers - In depth lectures notes
    https://ppc.cs.aalto.fi/

  2. Comparing Parallel Rust and C++
    https://parallel-rust-cpp.github.io/

  3. Crossbeam - Tools for concurrent programming
    https://crates.io/crates/crossbeam
    Crossbeam - Learning Resources
    https://github.com/crossbeam-rs/rfcs/wiki

  4. Rayon - It is a data-parallelism library for Rust
    https://crates.io/crates/rayon
    Video - Rayon: Data Parallelism for Fun and Profit — Nicholas Matsakis
    https://www.youtube.com/watch?v=gof_OEv71Aw
    Rayon: data parallelism in Rust
    https://smallcultfollowing.com/babysteps/blog/2015/12/18/rayon-data-parallelism-in-rust/
    Rayon docs
    https://docs.rs/rayon/latest/rayon/

  5. dpc-pariter - Parallel iterator processing
    https://crates.io/crates/dpc-pariter
    Adding parallelism to your Rust iterators with dpc-pariter
    https://dpc.pw/adding-parallelism-to-your-rust-iterators

  6. perf Examples
    See also the lecture.
    https://www.brendangregg.com/perf.html

  7. perf: Linux profiling with performance counters
    https://perf.wiki.kernel.org/index.php/Main_Page

  8. Systems Performance Enterprise and the Cloud 2nd Ed
    by Brendan Gregg

To install Perf on your Linux system you can do a simple package installation like apt-get if you are on a debian, then execute perf and it will tell you the package that you will have to install that is specific for your Linux kernel version. If your distribution automatically updates your kernel, you will need to download a new and correct version for your new kernel, and install it with your system package manager, ex: apt-get.

In the Rust .toml file add the 2 following lines, to add the debug symbols table to the Rust executable program file, compiled with --release flag:

[profile.release]
debug = true

To run Perf profiling on your Rust executable program. After that you can also use flamegraph.

perf report">
# Temporarily activate this flag perf_event_paranoid.

> echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid


# Record the executable program profiling data in a .data file.

> perf record -F99 --call-graph dwarf 


# To see the report use with Up/Down arrow keys, with "+"
# and with "a" to see the annotated assembly code with the Rust
# code correspondent code. The report will include the % of time in
# inside the function and in each group of assembly instructions.
# Press "tab" key in annotation mode to jump between hot spots.

> perf report

The Perf profiler has many command use the stat command to get the IPC – Instruction Per Clock Cycle, it's an average.

To know how much peak memory your executable program uses do:

> /usr/bin/time -v 

Note: There are 2 "time" executables and this is not the bash default time program. That's why you have to write the full path /usr/bin/time to execute it.

  1. The Rust Performance Book
    https://nnethercote.github.io/perf-book/title-page.html

  2. Guide to Optimization
    Achieving warp speed with Rust
    https://gist.github.com/jFransham/369a86eff00e5f280ed25121454acec1
    Cheap tricks for high-performance Rust
    https://deterministic.space/high-performance-rust.html
    Video - Optimizing Rust - Rust Oslo 2021-11-11 - Lily Mara
    https://www.youtube.com/watch?v=LQ2nIhj45vE
    Optimization - Making Rust Code Go Brrrr
    https://aspenuwu.me/posts/rust-optimization.html
    Profile Guided Optimization
    https://doc.rust-lang.org/rustc/profile-guided-optimization.html
    Optimizations: the speed size tradeoff
    https://rust-embedded.github.io/book/unsorted/speed-vs-size.html

Rust Optimization - Compilation modes and flags

The best way to optimize your code is to choose the right algorithm and the right data structures.

You can also apply several coding techniques that come from the underling knowledge of how the rust transforms your code structures in memory (stack and heap) and how they are executed, for example avoiding allocation, avoiding cloning large things that aren’t basic types and that are by nature cloned. (More info bellow.) You can do profiling to guide you through optimization, identifying the hot-spots to pin point you to the exact code your program spends that 90% of his time. And to allow you to see where you can shave it in the number of instructions that are executed at the same time and to increase your IPC – Instructions Per Clock cycle of your superscaller CPU. And then you can also mess around with compilation flags like the following, see https://nnethercote.github.io/perf-book/build-configuration.html :

[profile.release]
debug = true
  • LTO - Link-Time Optimization
    Link-time optimization (LTO) is a whole-program optimization technique that can improve runtime performance by 10-20% or more, at the cost of increased build times. In Cargo.toml.
[profile.release]
lto = true
  • Codegen Units
    The Rust compiler splits your crate into multiple codegen units to parallelize (and thus speed up) compilation. However, this might cause it to miss some potential optimizations. This will optimize it as a all, not dividing into more than one units. You have to benchmark it, because it can run faster or in some cases slower. In Cargo.toml.
[profile.release]
codegen-units = 1
  • Using CPU Specific Instructions - Compiling to native CPU features.
    It identifies and optimizes for the features of your CPU used in the compilation machine.
$ RUSTFLAGS="-C target-cpu=native" cargo build --release
[profile.release]
opt-level = z

Rust bounds check removal

This forum thread shows well some ways to remove bounds check without the need to do a loop for and a iterator, the case where bounds check are automatically removed, or without using the manual way get_unchecked().

I have put here some examples from the previous forum thread of bounds check removal with a simple assert. Imagine that you have a loop with a index array that the compiler can’t easily know that it doesn’t need to bounds check a easy way to ensure that the bounds check will be removed is with the introduction of an assert that will assure to the compiler it is safe. In this case the assert only makes one bounds check outside a loop and all the bounds checks inside the look will disappear.

// Instead of….
for i in array1.len() {
    println!("{} {}", array1[i], array2[i]);
}

// Do….
assert_eq!(array1.len(), array2.len());
for i in array1.len() {
    println!("{} {}", array1[i], array2[i]);
}
// This does three bounds checks
pub fn demo1(x: &[i32]) -> i32 {
    x[0] + x[1] + x[2]
}

// Whereas these two examples each only have one bounds check:
pub fn demo2(x: &[i32]) -> i32 {
    assert!(x.len() >= 3);
    x[0] + x[1] + x[2]
}

pub fn demo3(x: &[i32]) -> i32 {
    let x = &x[..3];
    x[0] + x[1] + x[2]
}
  • Removal of bounds checks in extreme cases.
    Rust has slice, array and Vec bounds checks for each indices.
    If you use iterators there will be no bounds check.
    But in the common case Rust uses LLVM, and LLVM does a very good job at removing the bounds checks that aren't needed.
    But if you need the fastest code implementation and want to remove bounds check, you can use get_unchecked() and get_unchecked_mut(), they must be inside a unsafe block.
let x = &mut [1, 2, 4];

unsafe {
    let elem = x.get_unchecked_mut(1);
    *elem = 13;
}
assert_eq!(x, &[1, 13, 4]);
// Normal performance: 84,694,933 ns/iter (+/- 7,412,836)

// This optimization:  41,440,947 ns/iter (+/- 752,463)   [x2 times faster]

fn bench_vec_of_vec_unsafe(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = vec![vec![0u8; n]; m];
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                unsafe {
                    *matrix.get_unchecked_mut(i).get_unchecked_mut(j) = 1u8;
                }
            }
        }
    });
}

Notes - General

  • Enum Option - Option.copied()
// y_copy is a new Option of the cloned char 'a'.
// x is Option<&T> and the y_copy is Option . 
let c: char = 'a';
let x: Option<&char> = Some(&c);
let y_copy: Option<char>  = x.copied();  // =>  Option
  • Trait Iterator - Iterator.copied()
    Example modified from std lib docs.
". // let v_copied: Vec<_> = a.iter().copied().collect(); // Copied is the same as .map(|&x| x) let v_map: Vec<_> = a.iter().map(|&x| x).collect(); assert_eq!(v_copied, vec![1, 2, 3]); assert_eq!(v_map, vec![1, 2, 3]); // Better and faster to just transform an array into a Vec. let v_copied_2 = a.to_vec(); assert_eq!(v_copied_2, vec![1, 2, 3]); ">
// Trait Iterator - Iterator.copied()
// Creates an iterator which copies all of its elements.
// This is useful when you have an iterator over &T, but you need an iterator over T.

let a = [1, 2, 3];

{
    // Vector of references &T , &i32
    let v_copied_ref: Vec<&i32> = a.iter().collect();
}

// Vector of copied items T , i32
let v_copied: Vec<i32> = a.iter().copied().collect();

// You should write the Vec type like this "vec<_>".
// let v_copied: Vec<_> = a.iter().copied().collect();

// Copied is the same as .map(|&x| x)
let v_map: Vec<_> = a.iter().map(|&x| x).collect();

assert_eq!(v_copied, vec![1, 2, 3]);
assert_eq!(v_map, vec![1, 2, 3]);

// Better and faster to just transform an array into a Vec.
let v_copied_2 = a.to_vec();
assert_eq!(v_copied_2, vec![1, 2, 3]);

Notes on optimization

use std::collections::HashMap;
use fasthash::murmur2::Murmur2_x86_64;

let s = Murmur2_x86_64::new();
let mut map = HashMap::with_hasher(s);
map.insert(1, 2);
  • But for a even faster HashMap or HashSet use,
    hashbrown - Faster drop in replacement for STD HashMap and HashSet, a Rust port of Google's high-performance SwissTable hash map.
    https://github.com/Amanieu/hashbrown
    Insert crate hashbrown into .toml file
// The fastest HashMap for Rust. HashBrown a drop in replacement for std HashMap.
use hashbrown::HashMap;
// In main do.
smartstring::validate();

{
   // In the scope, add the alias to replace normal Strings with SmartString.  
   use smartstring::alias::String;

   // When creating SmartString's from &str instead of doing:
   "blabla".to_string()

   // Do:
   String::from("blabla")
}

Rust substring processing

  • Rust string processing is kind of hard, because text in a UTF-8 world has many complex details, and Rust exposes all that power and all that complexity to you, the programmer. Sometimes it can be over whelming. Sometimes you only want to have a simple substring or a slice and you don’t mind to pay it’s cost, because you really need this feature and the Standard Library doesn’t help you a lot there.

  • Fortunately carlomilanesi made this code available to all
    https://users.rust-lang.org/t/how-to-get-a-substring-of-a-string/1351/11

  • But if you have to do many text operations based on the positions of chars inside a strings this isn’t a really good option, because you have to scan all the strings to the correct position, from the start, to have the string divided it into the correct boundaries of the chars. In this context, you would happily pay a up front cost of transforming the string into a Vec, Vec of chars with individual chars separated, and process it as positional chars with access cost of 1 and then, slice them, range them, append to them at the end (or if you need to append in the start or the middle paying the cost of copy to a new buffer, but you can do it if you need to). The following code is my expansion to the code of carlomilanesi. It will allow you to do it.
    You can find it also in my GitHub repository in…

  • SubStrings, Slices and Random String Access in Rust
    https://github.com/joaocarvalhoopen/SubStrings_Slices_and_Random_String_Access_in_Rust


. let mut vc = s.get_vec_chars(); println!("{}, {}, {}, {}.", vc[..5].to_string(), vc.to_string(), vc[3..8].to_string(), vc[3..].to_string()); // Reusing a String buffer from a Vec. let mut buf = String::new(); print!("{}, ", vc[..5].to_string_buf(& mut buf)); print!("{}, ", vc[..].to_string_buf(& mut buf)); print!("{}, ", vc[3..8].to_string_buf(& mut buf)); print!("{}.\n", vc[3..].to_string_buf(& mut buf)); // Random access to the Vec. for i in 0..(vc.len() - 2) { print!("{} ", vc[i..i+3].to_string_buf(& mut buf)); } println!(""); // Random modifications to the Vec. for i in (0..(vc.len() / 3) + 1).rev() { vc.insert(i*3, '#'); } println!("{} ", vc.to_string()); println!("{} ", vc.to_string_buf(& mut buf)); } // Output: // abcdè, abcdèfghij, dèfgh, dèfghij. // abcdè, abcdèfghij, dèfgh, dèfghij. // abcdè, abcdèfghij, dèfgh, dèfghij. // // abcdè, abcdèfghij, dèfgh, dèfghij. // abcdè, abcdèfghij, dèfgh, dèfghij. // abc bcd cdè dèf èfg fgh ghi hij // #abc#dèf#ghi#j // #abc#dèf#ghi#j">
use std::ops::{Bound, RangeBounds};

trait StringUtils {
    fn substring(&self, start: usize, len: usize) -> &str;
    fn slice(&self, range: impl RangeBounds<usize>) -> &str;
    fn get_vec_chars(&self) -> Vec<char>;
}

impl StringUtils for str {
    fn substring(&self, start: usize, len: usize) -> &str {
        let mut char_pos = 0;
        let mut byte_start = 0;
        let mut it = self.chars();
        loop {
            if char_pos == start { break; }
            if let Some(c) = it.next() {
                char_pos += 1;
                byte_start += c.len_utf8();
            }
            else { break; }
        }
        char_pos = 0;
        let mut byte_end = byte_start;
        loop {
            if char_pos == len { break; }
            if let Some(c) = it.next() {
                char_pos += 1;
                byte_end += c.len_utf8();
            }
            else { break; }
        }
        &self[byte_start..byte_end]
    }
    fn slice(&self, range: impl RangeBounds<usize>) -> &str {
        let start = match range.start_bound() {
            Bound::Included(bound) | Bound::Excluded(bound) => *bound,
            Bound::Unbounded => 0,
        };
        let len = match range.end_bound() {
            Bound::Included(bound) => *bound + 1,
            Bound::Excluded(bound) => *bound,
            Bound::Unbounded => self.len(),
        } - start;
        self.substring(start, len)
    }
    fn get_vec_chars(&self) -> Vec<char> { self.chars().collect() }
}

trait StringUtilsVecChars {
    fn to_string(&self) -> String;
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String;
}

impl StringUtilsVecChars for Vec<char> {
    fn to_string(&self) -> String { self.iter().collect() }
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String {
        buf.clear();
        for c in self.iter() { buf.push(*c); }
        buf
    }
}

trait StringUtilsSlices {
    fn to_string(&self) -> String;
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String;
}

impl StringUtilsSlices for [char] {
    fn to_string(&self) -> String { self.iter().collect() }
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String {
        buf.clear();
        for c in self.iter() { buf.push(*c); }
        buf
    }
}

fn main() {
    let s = "abcdèfghij";
    // All three statements should print:
    // "abcdè, abcdèfghij, dèfgh, dèfghij."
    println!("{}, {}, {}, {}.",
        s.substring(0, 5),
        s.substring(0, 50),
        s.substring(3, 5),
        s.substring(3, 50));
    println!("{}, {}, {}, {}.",
        s.slice(..5),
        s.slice(..50),
        s.slice(3..8),
        s.slice(3..));
    println!("{}, {}, {}, {}.",
        s.slice(..=4),
        s.slice(..=49),
        s.slice(3..=7),
        s.slice(3..));

    // Allocating a string from Vec.
    let mut vc = s.get_vec_chars(); 
    println!("{}, {}, {}, {}.",
        vc[..5].to_string(),
        vc.to_string(),
        vc[3..8].to_string(),
        vc[3..].to_string());

    // Reusing a String buffer from a Vec.
    let mut buf = String::new();
    print!("{}, ", vc[..5].to_string_buf(& mut buf));
    print!("{}, ", vc[..].to_string_buf(& mut buf));
    print!("{}, ", vc[3..8].to_string_buf(& mut buf));
    print!("{}.\n", vc[3..].to_string_buf(& mut buf));
    
    // Random access to the Vec. 
    for i in 0..(vc.len() - 2) {
        print!("{} ", vc[i..i+3].to_string_buf(& mut buf));
    }
    println!("");
    
    // Random modifications to the Vec.
    for i in (0..(vc.len() / 3) + 1).rev() {
        vc.insert(i*3, '#');
    }
    println!("{} ", vc.to_string());
    println!("{} ", vc.to_string_buf(& mut buf));
}

// Output:
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abc bcd cdè dèf èfg fgh ghi hij 
//    #abc#dèf#ghi#j
//    #abc#dèf#ghi#j

Macros in Rust

  1. Macro file visibility rules
    https://users.rust-lang.org/t/3-things-that-the-rust-standard-library-should-have/68825/11

  2. Macros for hashMap, hashset, btreeMap, btreeSet to look similar to Python
    Crate maplit
    https://crates.io/crates/maplit

1, "b" => 2, }; let map1: HashMap = convert_args!(hashmap!( "a" => "b", "c" => "d", )); let map2 = convert_args!(keys=String::from, hashmap!( "a" => 1, "c" => 2, ));">
#[macro_use] extern crate maplit;

let map = hashmap!{
    "a" => 1,
    "b" => 2,
};

let map1: HashMap<String, String> = convert_args!(hashmap!(
    "a" => "b",
    "c" => "d",
));

let map2 = convert_args!(keys=String::from, hashmap!(
    "a" => 1,
    "c" => 2,
));
  1. Macro for graph's
    See the following post from kaj, on the Rust user foruns.
    https://users.rust-lang.org/t/3-things-that-the-rust-standard-library-should-have/68825/9
# When you have the following dictionary Python code...

# Adjacency list of graph
data = {
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
}
// And you implement it in Rust like this...

let data = HashMap::from([
    (0, vec![1, 2]),
    (1, vec![0, 2]),
    (2, vec![0, 1, 3, 5]),
]);

// ...but you can instead implement it like this...

let data2 = graph![
    0 => 1, 2;
    1 => 0, 2;
    2 => 0, 1, 3, 5
];

// ...using the following simple Macro...

use std::collections::HashMap;

macro_rules! graph {
    [$($k:expr => $($v:expr),*);*] => {
        HashMap::from([
            $(($k, vec![ $($v),* ])),*
        ])
    }
}

Good way to learn about the topic of computers and programming

  1. Video - Computer Science - Crash Course
    https://www.youtube.com/playlist?list=PL8dPuuaLjXtNlUrzyH5r6jN9ulIgZBpdo

For a good challenge do the NAND To Tetris in Rust

  1. From Nand to Tetris
    Building a Modern Computer From First Principles
    https://www.nand2tetris.org/

  2. Video - Shimon Schocken: The self-organizing computer course
    https://www.youtube.com/watch?v=iE7YRHxwoDs

  3. Video - From Nand to Tetris Part I Course Promo
    https://www.youtube.com/watch?v=wTl5wRDT0CU

  4. Free Course - Build a Modern Computer from First Principles
    From Nand to Tetris (Project-Centered Course)
    https://www.coursera.org/learn/build-a-computer

  5. Free Course - Build a Modern Computer from First Principles
    Nand to Tetris Part II (project-centered course)
    https://www.coursera.org/learn/nand2tetris2

All my other guides

Have fun

Best regards,
Joao Nuno Carvalho

You might also like...
Rust-clippy - A bunch of lints to catch common mistakes and improve your Rust code

Clippy A collection of lints to catch common mistakes and improve your Rust code. There are over 450 lints included in this crate! Lints are divided i

Rust-battery - Rust crate providing cross-platform information about the notebook batteries.

battery Rust crate providing cross-platform information about the notebook batteries. Table of contents Overview Supported platforms Install Examples

A Rust-based shell script to create a folder structure to use for a single class every semester. Mostly an excuse to use Rust.

A Rust Course Folder Shell Script PROJECT IN PROGRESS (Spring 2022) When completed, script will create a folder structure of the following schema: [ro

Rust Imaging Library's Python binding: A performant and high-level image processing library for Python written in Rust

ril-py Rust Imaging Library for Python: Python bindings for ril, a performant and high-level image processing library written in Rust. What's this? Th

A full featured, fast Command Line Argument Parser for Rust

clap Command Line Argument Parser for Rust It is a simple-to-use, efficient, and full-featured library for parsing command line arguments and subcomma

Docopt for Rust (command line argument parser).

THIS CRATE IS UNMAINTAINED This crate is unlikely to see significant future evolution. The primary reason to choose this crate for a new project is if

Quickly build cool CLI apps in Rust.

QuiCLI Quickly build cool CLI apps in Rust. Getting started Read the Getting Started guide! Thanks This is only possible because of all the awesome li

A minimal CLI framework written in Rust
A minimal CLI framework written in Rust

seahorse A minimal CLI framework written in Rust Features Easy to use No dependencies Typed flags(Bool, String, Int, Float) Documentation Here Usage T

▁▂▆▇▁▄█▁ Sparklines for Rust apps

rspark ▁▂▆▇▁▄█▁ Sparklines for Rust apps. Rust port of https://github.com/holman/spark Usage Add this to your Cargo.toml: [dependencies] rspark = "0.2

Comments
  • URL needs updating

    URL needs updating

    1. **Why Developers Love Rust** <br> [https://ibraheem.ca/posts/why-devs-love-rust/](https://ibraheem.ca/posts/why-devs-love-rust/) writings changed to posts.

    I actually tried to push a PR for this, but couldn't get it working, don't know if it's permissions on your repo, or if I just screwed up. :)

    Oh, yeah, excellent resource-list you've created, thanks.

    opened by CrawfishPress 1
  • tflitec crate can be added to

    tflitec crate can be added to "ML for Rust"

    tflitec can be added to "Machine Learning for Rust" section. It is a safe Rust wrapper of TensorFlow Lite C API supporting x86_64 and ARM (iOS, Android).

    Disclaimer: I am the author of the crate.

    opened by ebraraktas 0
  • shameless self-promotion of my talk for experienced C++ programmers approaching Rust

    shameless self-promotion of my talk for experienced C++ programmers approaching Rust

    I wrote this talk partly in response to watching the two-part series with Jonathan and Jason Turner, because I felt like some really important questions came up in their video without getting clear answers, particularly around the differences in how move semantics works in C++ vs how it works in Rust. Maybe this could be a useful addition to the list? https://www.youtube.com/watch?v=IPmRDS0OSxM

    opened by oconnor663 0
Owner
João Nuno Carvalho
Hi, I’m a software engineer - computer science and electronics. I develop in many programming lang. I do command line, GUI and Web, Machine Learning and others.
João Nuno Carvalho
visual guide for writing Intrinsics(SIMD)

wasm-pack-template A template for kick starting a Rust and WebAssembly project using wasm-pack. Tutorial | Chat Built with ?? ?? by The Rust and WebAs

Ric Li 1 Apr 6, 2022
A list of crates with snippets used by me to learn more about Rust.

my-rust-examples This is a list of crates used by me to learn Rust. How to execute You can use a dependency called cargo-play: cargo install cargo-pla

Ronald 0 Jan 3, 2022
dua (-> Disk Usage Analyzer) is a tool to conveniently learn about the usage of disk space of a given directory

dua (-> Disk Usage Analyzer) is a tool to conveniently learn about the usage of disk space of a given directory. It's parallel by default and will max

Sebastian Thiel 1.6k Sep 22, 2022
An open source artifact manager. Written in Rust back end and an Vue front end to create a fast and modern experience

nitro_repo Nitro Repo is an open source free artifact manager. Written with a Rust back end and a Vue front end to create a fast and modern experience

Wyatt Jacob Herkamp 23 Aug 26, 2022
mdBook is a utility to create modern online books from Markdown files.

Create book from markdown files. Like Gitbook but implemented in Rust

The Rust Programming Language 10.7k Sep 29, 2022
exa is a modern replacement for ls.

exa exa is a modern replacement for ls. README Sections: Options — Installation — Development exa is a modern replacement for the venerable file-listi

Benjamin Sago 19.3k Sep 24, 2022
Cold Clear 2 is a modern Tetris versus bot and a complete rewrite and evolution of Cold Clear.

Cold Clear 2 Cold Clear 2 is a modern Tetris versus bot and a complete rewrite and evolution of Cold Clear. It implements the Tetris Bot Protocol for

Mark Carlson 24 Aug 25, 2022
Modern file system navigation tool on Unix

monat -- Modern file system Navigator 简体中文 Introduction monat is a Unix shell auxiliary command focusing on the navigation of the file system, especia

Pavinberg 8 May 10, 2022
A simple, modern fuzzy finder tool to run examples in a Cargo project.

cargo-rx cargo-rx is a simple, modern Runner for Examples in a Cargo project. This crate provides a single executable: rx. Basically anywhere you woul

Ritvik Nag 12 May 3, 2022
Rust-advent - Learning Rust by solving advent of code challenges (Streaming live on Twitch every Monday)

Rust advent ?? ?? Learning Rust by implementing solutions for Advent of Code problems. ?? HEY, we are live-streaming our attempts to solve the exercis

Luciano Mammino 17 Sep 12, 2022