Rust - notes

Table of Contents

Installation

https://doc.rust-lang.org/cargo/getting-started/installation.html

curl https://sh.rustup.rs -sSf | sh

IDEs for Rust

  1. Install rust-rover IDE.
    1. Use Jetbrains toolbox to install it.
  2. Install the rust-analyzer plugin for VSCode to be able to run programs quickly.

Tools that I tried with no luck

  1. Install the rust plugin for IntelliJ idea to be able to run programs quickly.
    1. The plugin doesn’t seem to be available anymore.
  2. Eclipse Corrosion: https://projects.eclipse.org/projects/tools.corrosion
    1. Stay away from this. This is crashing the entire system.
  3. RustDT Eclipse plugin: https://github.com/RustDT/RustDT
    1. Did not work for me. It complained that something is missing.

Dead code

https://doc.rust-lang.org/rust-by-example/attribute/unused.html

Questions

Are modules analogous to Java packages?

Documentation

The installation of Rust also includes a copy of the documentation locally, so you can read it offline. Run rustup doc to open the local documentation in your browser.

The main function

The main function is special. It is always the first code that runs in every executable Rust program.

let statement and variables in Rust

https://doc.rust-lang.org/stable/book/ch03-01-variables-and-mutability.html

We use the let statement to create variables.

e.g.

let apples = 5;
let mut guess = String::new();

constants

https://doc.rust-lang.org/stable/book/ch03-01-variables-and-mutability.html

shadowing

https://doc.rust-lang.org/stable/book/ch03-01-variables-and-mutability.html

String type

https://doc.rust-lang.org/stable/std/string/struct.String.html String is a string type provided by the standard library that is a growable, UTF-8 encoded bit of text.

Associated function

The :: syntax in the ::new line indicates that new is an associated function of the String type. An associated function is a function that’s implemented on a type, in this case String. This new function creates a new, empty string. You’ll find a new function on many types because it’s a common name for a function that makes a new value of some kind.

Variables and Mutability - immutable by default

In Rust, variables are immutable by default. To make a variable mutable, we add mut before the variable name:

let apples = 5; // immutable
let mut bananas = 5; // mutable

Variable references

The & indicates that the argument is a reference, which gives you a way to let multiple parts of your code access one piece of data without needing to copy that data into memory multiple times. References are a complex feature, and one of Rust’s major advantages is how safe and easy it is to use references. Like variables, references are immutable by default.

Rust has a number of types named Result in its standard library: a generic Result as well as specific versions for submodules, such as io::Result. The Result types are enumerations, often referred to as enums, which can have a fixed set of possibilities known as variants. Enums are often used with match, a conditional that makes it convenient to execute different code based on which variant an enum value is when the conditional is evaluated.

The purpose of these Result types is to encode error-handling information.

Result’s variants are Ok and Err. The Ok variant indicates the operation was successful, and inside Ok is the successfully generated value. The Err variant means the operation failed, and Err contains information about how or why the operation failed.

Values of the Result type, like values of any type, have methods defined on them. An instance of io::Result has an expect method that you can call. If this instance of io::Result is an Err value, expect will cause the program to crash and display the message that you passed as an argument to expect. If the read_line method returns an Err, it would likely be the result of an error coming from the underlying operating system. If this instance of io::Result is an Ok value, expect will take the return value that Ok is holding and return just that value to you so you can use it. In this case, that value is the number of bytes in the user’s input.

If you don’t call expect, the program will compile, but you’ll get a warning.

Core principles of Rust language

  1. Memory safety without garbage collection - https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
  2. Concurrency without data races - https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
  3. Abstraction without overhead - https://blog.rust-lang.org/2015/05/11/traits.html

References

  1. https://docs.rs/sum_type/latest/sum_type/
  2. https://doc.rust-lang.org/std/boxed/struct.Box.html
  3. https://doc.rust-lang.org/std/boxed/
  4. https://tonyarcieri.com/a-quick-tour-of-rusts-type-system-part-1-sum-types-a-k-a-tagged-unions

Tags

  1. Rust - why learn the language
  2. Rust - Boxing and Unboxing
  3. Rust - cargo commands
  4. Rust - Standard library and crates
  5. Rust - Standard IO
  6. Rust - Traits
  7. Rust - Embracing Functional Programming Patterns
  8. Zero Cost Abstractions
  9. Rust - creating a project

TODO

  1. Ownership node: https://blog.skylight.io/rust-means-never-having-to-close-a-socket/
  2. benefits of the language
  3. current state of frameworks
  4. use cases
  5. rewriting enterprise applications using Rust

Resources to learn Rust

  1. The Rust Programming Language
    1. https://doc.rust-lang.org/book/title-page.html
  2. Jeremy Chone on YouTube: https://www.youtube.com/c/JeremyChone
    1. Jeremy has some great free content and is easy to get in touch with on his Discord if you have questions.
    2. His content is dense.
  3. Jon Gjengset on YouTube: https://www.youtube.com/c/JonGjengset
    1. Insanely good
    2. Crust of Rust playlist: https://www.youtube.com/playlist?list=PLqbS7AVVErFiWDOAVrPt7aYmnuuOLYvOa
    3. A very good Rust YouTube and mentor.
    4. One reason why Gjengset is such a hero. He obviously enjoys the language, and prefers it, but he also has things he doesn’t like and critisizes.
  4. fasterthanlime on YouTube
    1. https://www.youtube.com/@fasterthanlime
  5. Comprehensive Rust
    1. I found this “Comprehensive Rust” course made by the Android team at Google that looks really good.
    2. It seems to be good and it has exercises along the way
    3. https://google.github.io/comprehensive-rust/index.html
  6. Learn Rust with Rustlings
    1. https://www.youtube.com/watch?v=G3Vr-yswlaU
  7. Once you get to intermediate level, check out Rust Atomics and Locks. There is a print version that you can buy but there is also a free version on her website.
  8. https://medium.com/@luishrsoares/list/mastering-rust-programming-06763d788b6e
  9. https://www.linkedin.com/in/luishsoares/recent-activity/articles/
  10. https://docs.rs/sum_type/latest/sum_type/
  11. https://doc.rust-lang.org/std/boxed/struct.Box.html
  12. https://doc.rust-lang.org/std/boxed/
  13. https://tonyarcieri.com/a-quick-tour-of-rusts-type-system-part-1-sum-types-a-k-a-tagged-unions

Interesting projects

https://github.com/CleanCut/invaders/tree/main

Links to this note