rust journey

Summary:

Just more syntax today.

Rust by Practice

• Learned that we can include snippets of code inside the doc comments and they would be run by the rust test command.

• 15: Comments and Docs

• 16.1: Formatted Output - println! and format!

• 16.2: Formatted Output - debug and display

• 16.3: Formatted Output - formatting

Summary:

I shouldn't slow down.

Mara Bos Book:

• Started Reading Chapter 4
  • work

Summary:

Continuing practicing the Rust Syntax. Nothing major. The "do something meaningful day is still in the future"

Rust by Practice

• Learned about "an inner lint attribute that allows the overflowing_literals lint".
• Sometimes the "usual behaviour" can be achieved using unsafe code. Rust wants to protect us.
• *mut i32 is a raw mutable pointer to an i32.
• If we want to use let u:U = T.into() or let u: U = U::from(T) we should do the: impl From<T> for U
• Learned about the TryFrom and TryInto that return a Result and can be use for conversions that might fail.
• We can shorten and extend the lifetimes with the transmute
• map has normal return inside the closure, and_then has Result return inside the closure.
• A single Cargo package managed by one Cargo.toml can contain multiple crate targets: at most one library crate from src/lib.rs, one default binary crate from src/main.rs usually named after the package, and additional binary crates from files in src/bin/*.rs.
• We can control the visibility of stuff with: pub(in crate::a)
• 12.1: Type Conversion - as
• 12.2: Type Conversion - from/into
• 12.3: Type Conversion - others
• 13.1: Result and panic - panic!
• 13.2: Result and panic - result and ?
• 14.1: Crate and Module - package and crate
• 14.2: Crate and Module - module
• 14.3: Crate and Module - advanced use and pub

Rest Day

Summary:

I think I have an idea of what I want to do. Understand concurrency good enough, so I can build my own primitive and publish it on crates.io. It must reach a 1000 downloads by the end of 2026.

Mara Bos Book:

• I wouldn't be able to write something like this on my own. But if now I am given a task to work with some data from different threads I would be able to do so without creating undefined behaviour.
• Finished Reading Chapter 3.
  • Work
  • Stuff that happens in different threads can be matched in different ways. If we are interacting with the same variables from different threads, that may create errors. To prevent that we can create happens-before relationships between different threads using "release-stores" and "acquire-loads".
  • Practically this can help with Lazy Initialization.

Watching Stuff

• The Cost of Concurrency Coordination with Jon Gjengset
  • If you have a lot of work use Mutexes, if you don't - don't. Cache miss would introduce a lot of overhead.
  • The left-right data structure is useful when we have a lot of short readers and not a lot of writers.
    • It is: Two copies of the data (l, r). Pointer points to the side all readers should read from. The other one is writer-owned.
    • When writer is done, the pointer switches to the other side.
    • Each reader has their own cache line. They just keep the counter of how many times they read the pointer. They do not need to talk to each other.
    • Reads are Wait and Lock free.
  • "Even the "lock-free" code can suffer from cache coherence".
  • Always remember CSE 142 and the Amdahl's law
  • Questions to ask yourself when you are choosing between Mutex, RwLock and left-right:
    • What is my read/write ratio?
    • How long is my critical section?
    • How many threads will content?
    • Do I need linearizability?

Summary:

I don't really want to speak about today. I am more aware about the ownership model, I am getting more comfortable with iterators and I know which method I should use when I work with Collections.

Rust by Practice

• 10.1: Generic and Traits - generics
• 10.2: Generic and Traits - const generics
• 10.3: Generic and Traits - traits
• 10.4: Generic and Traits - trait objects
• 10.5: Generic and Traits - advanced traits
• 11.1: Generic and Traits - string
• 11.2: Collection and Types - vector
• 11.3: Collection and Types - hash-map

EliteCode

• Solved the TTL Cache Problem. I made the assumption that we can go back in time, as the platform provided me with delta which is a signed integer. This means, that I cannot just delete the data that we know have expired. Otherwise, the major chunk of the work could be done by the tick function and we would keep the data field as having the only information.

Summary:

I wouldn't call today productive. I spent a lot of time writing code myself, diving into the world of concurrency, but nothing major. I did not generate anything significant on my own. And that is what is usually required at a workplace. I should focus more on that tomorrow. Switch from a "reading day" to "applying the knowledge day". Also I identified a couple of typos in the rust by practice repo, and I should edit them. At least in this way I can be useful to people. Also, throughout the whole day today I kept repeating the words of YouTuber GothamChess about actually finishing the courses. Just saying you learn something is not enough, you need to complete books/courses from start to finish. Yes, maybe the brute-force approach is not beautiful and elegant but it will yield a result. I sound like one of those motivation-centered online gurus right now :)

Rust by Practice

• I am getting into more interesting topics where the rust really shines, like pattern matching.
• Doing this exercises makes me a fast thinker. I learn how to identify an error quickly, edit the file in nvim, save it, switch to the browser, run the snip, see the compilation error, return to nvim, repeat. This trains my muscle memory and makes me a better terminal user.
• 8.1: Pattern Match - match, matches!, if let
• 8.2: Pattern Match - patterns
• 9: Methods and Associated functions

Mara Bos Book:

• I decided to make a new repo where I can execute each of the examples as: cargo run --example ch<num-chapter>-ex<num-example>-<num-example>. Because just sharing gists for the commented code, like I did yesterday is strange. I moved all the examples from Chapters 1 and Chapters 2 there. Here is the commit
• Finished Reading Chapter 2.
  • Work
  • I am comfortable with Atomics.
  • I can spawn threads in many different ways and use closures correctly.
  • I understand the idea behind compare_exchange method.
• Started Reading Chapter 3.
  • Work
  • Happens-Before Relationship can be achieved between the threads.
  • Compiler still has room for optimizations with Rust's memory model.
  • Wrote my first bit of unsafe rust.
  • Mutexes just use the Release-Aquire ordering to establish happens-before relationships.

EliteCode

• This is the project I found yesterday on /rust subreddit. I like the concept. Each of the problems: virtual file system, URL router, TTL cache can be its own project in separate repository. But setting everything up is so time consuming. I would rather use an online platform with tests. Nobody will use a rate limiter that I wrote, and I want (some day) for my GitHub to be a place where people go for code they can use. (Doesn't connect well with a new repo I created in a section above though :| )
• Today I worked on the Sliding Window Rate Limiter. The problem was marked as easy, so it was the obvious one to start with. My approach was simple, we have a number and we need to check in how many intervals it is already present. Intervals are sorted, and can be defined by one number, as windowMs is constant. If number of ocurences is above the specified threshold, return false, otherwise add an interval corresponding to the input number to the Data Structure. BTreeMap in Rust seemed like a right choice, as we want to be able to get a range of entries on-demand.
• You can see my implementation here.

Dutar

• Fix the bad logic I wrote for deleting the currently playing song from fs, so that it is removed from the queue.

Summary:

I wouldn't call today productive. I spend a big part of the day setting up the blog itself, so I didn't have a lot of time left for a proper learning session. I feel like I am stuck in some sort of a 'tutorial hell'. That stuff I am going through over and over is extremely obvious to others. But I think it is necessary to go over basics until they click properly.

Rust by Practice:

I add the key takeaways inside the commit descriptions.

• 6.1: Compound Types - string
• 6.2: Compound Types - array
• 6.3: Compound Types - slice
• 6.4: Compound Types - tuple
• 6.5: Compound Types - struct
• 6.6: Compound Types - enum
• 7: Flow Control

Mara Bos Book:

• Some progress Reading Chapter 2
  • notes
  • code