Rust 1.99

I don’t know why, but I really like Rust.

I like it, I did start trying to learn it, and at a point I got blocked and I couldn’t work further a kind of wall where my mind was not able to figure out how to do it in Rust. I was lost, couldn’t find my way. I was looking online to see that the answer doesn’t work with my version of Rust … And I gave up.

Few years later, I want my revenge.

Why Rust. I find it very elegant but Pascal and Go are also very elegant. What I like most in Rust is that it looks like the high level language, while being a very low level one. You write like one can write in javascript while being able to manipulate and allocating memory (like in C) but much more securely.

I also like the link with the web and the ability to build up part of your code in Rust and WASM it for the web. (My first attempt at learning Rust: https://github.com/scips/wasm-game-of-life)

Finally I’m the kind of guy who don’t hesitate to add in a C program a small ASM block to speed up part of the code for Real Time Programming. I had a lot of issue, memory issue, limit case, overflow, divide by 0… that I had to deal with. I’m glad I want through this because it helped me a lot to learn clean and safe programming. That’s probably what I found the most interesting, working with immutable items as much as we can, creating a totally predictable system.

Let see where this will lead us.

#newskillnovember

It’s just a pretext, but I needed some kick to start it again. So let start New Skill November!

One Rule: Don’t use AI!

So my go to will be to take a book, read-it, learn, try stuff…

I plan to update this Article with updates from my learning.

5 November

Here is the book I’m reading: https://doc.rust-lang.org/book/title-page.html I took a PDF version of the book.

Chapter 01

First surprise: Rust has a guaranteed backward compatibility. Just specify the edition in Cargo.toml and you are in.

So I’m learning Rust 2024 and not Rust 1.99 🙂

7 November

Trying to finish chapter 01, working late and after work, doesn’t help the learning of new skills. Let’s learn in the morning!

cargo is a “best practice tool” it helps generate code organisation and generic files (TOML) and automatically .git … but for some reason not in my case. Probably he detected I’m already inside a git repository … will need to deep dive there.

There’s a place for everything, and everything is in its place

It seems that cargo check is the tool to run in a file watcher continuous testing environment.

$ cargo build --release
   Compiling hello_cargo v0.1.0 (/Users/scips/Workspaces/Rust/RustBook/Chapter_01/hello_cargo)
    Finished `release` profile [optimized] target(s) in 0.77sCode language: Bash (bash)

$ ls -alh ./target/release/hello_cargo
-rwxr-xr-x@ 1 scips  staff   425K Nov  7 10:05 ./target/release/hello_cargoCode language: Bash (bash)

425 Kb ? For a “Hello, world!” … I found out there is a #![no_std] version: https://zenn.dev/zulinx86/articles/rust-nostd-101 that explain why the basic build takes a full floppy disk to have an “hello world” and how to write a very small hello world (useful for embed code)

fn main() {
    println!("Hello, world!");
}

Code language: Rust (rust)

I deep dived into the aarch64 assembly language too much, now I can write to memory and do syscall… absolutely not what I wanted to learn … let’s move one

Chapter 02

Mutable and immutable variable ! I’m really curious on how they do that as a variable is just a pointer to a memory spot.

And “::new” is a common name for a function that makes a new value of that type e.g. String::new().

Which means it’s a convention but one can create a Whatever::magic() that will create a new value and break the convention. Need to investigate that later.

Because the Cargo.lock file is important for reproducible builds, it’s often checked into source control with the rest of the code in your project.

I like this way of thinking, it’s really conceived for collaboration: code best practice, hints, standard directory structure, convention in naming and in code practice…

by the way just found out that syntax highlighting wasn’t working because of the VCL Dark Theme … switched back to Dark+

For random number generation the book is stuck to version 0.8 of rand:: crate.

In 0.10 use: https://docs.rs/rand/latest/rand/fn.random_range.html

    let secret_number:i64 = rand::random_range(1..=100);Code language: Rust (rust)

Range writing is quite strange but OK:

$[1;100]$ is. written 1..=100, which means $[1;100[$ should be like 1..100 or 1..=99.

The doc is embedded on demand ? cargo doc --open The doc is embedded on demand !

I just write a code and the doc is generated (but empty) for my code too and the included library aligned with each version of the library … powerful !

Shadowing ?

let mut guess = String::new();
let guess: i32 = 32; //...Code language: Rust (rust)

Chapter 03

by default, variables are immutable.

Here we go!

How does RUST ensure data are immutable in memory or at compile time ? https://dev.to/amritsingh183/a-complete-guide-to-rust-ownership-lifetimes-and-memory-management-4j2a has part of the answer.

What the H… Saturating_add : https://doc.rust-lang.org/std/intrinsics/fn.saturating_add.html

Ensuring that 255+1 = 255

Nice but I would have loved a kind of meta around +

let mut x: u8 = 255;
x.saturating_add_signed(1); // x == 255Code language: JavaScript (javascript)

let mut x:8 = 255;
#[saturating_add]
x = x + 1;Code language: PHP (php)

But this would be less readable I think with the #[xxx]

Another option would be to have type it the type itself:

let mut x: saturated_u8 = 255;
x = x + 1; // x = 255Code language: JavaScript (javascript)

But it would have needed non native type.

I’m the kind of guy who used too much operator redefinition in C++ and that was relying to much on the side effect of if (x) … when x was an integer.

Unicode

let I_love_rust: char = '❤️'; // won't work
let I_love_rust: char = '❤'; // will work
// and this will work without snake_case warning :P
let ilove_rust: char = '❤';
println!("What I think of Rust so far: {}", ilove_rust);Code language: JavaScript (javascript)

To do

To investigate later