I like that you can’t default values on structs. Feels simple. You use the simple tools you have, good practice and common sense to accomplish stuff. Other people also starting doing it and it becomes best practice. You have a struct, you have member/associated functions and that’s it. Coming from kotlin with “class”, “data class”, “value class”, “sealed class”, “object”, “companion object”, “inner class”, “enum class” etc., each with it’s own quirks and perks… I really needed something that’s just a set of simple, powerful, building blocks, lol.

The task manager thing can be a virus. Some sort of a Bitcoin miner. I had this at my PC and I had to reinstall Windows. These things has gotten really insidious.

Windows OS doesn’t do it like that. It does this only when you’re truly AFK.

Neighbours (tv show) is only just ending now.

As a rust beginner I really appreciated all the small things covered, that I didn’t learn from the documentation / books. Thanks alot for this content. I love the 10 seconds thinking pauses for Jason to decide if a certain rust language feature makes him “uncomfortable” (concerned about concistency and safety) 🙂

I hope you do more Rust episodes in the future.

Assert on index before indexing a vector indeed might help the optimizer. Rust adds bounds checks on indexing, so if you do `vec[index]`, Rust will add panicking `index < vec.len()` bounds checks here. Now, if you did `assert!(index < vec.len());` yourself earlier, those automatic checks will be elided. So if you need to eg. loop over some values and do indexing in that loop, putting an assert before the loop is a good idea for optimization. Rust has also an unsafe `.get_unchecked(index)` method that works like indexing in C or C++ without any bounds checking, but most often when you know the value passed must be correct it’s just better in Rust to use the safe indexing and do the assert before.

Nomadic function is an std::function which moves around a lot.

I can really reccomend IntelliJ with the rust plugin, just works flawlessly for me.

It bothers me that you copied the original values instead of just setting them to std::usize::MAX originally and explicitly calling usize::wrapping_add in the Iterator implementation

Is partitioning into separate files not best practice in rust?

3:31:00 just create a let binding to the board returned by life.next()? and use mem::swap to put it into the life and get the other board out of it.

52:30 just make that closure return a result and use the ? within it and when calling it 😉

Rust anylezer is using all your cores if you do not configure it to use less

Can’t wait for part 3

This is a great series, thanks!

I really like this Turner/Turner combo: one of you is very skeptical and sharp, the other’s always very cheery and permanently smiling, which makes for nice interactions. I’m glad you guys got together on this.

self.x is great to enforce. It’s about time for a language with some nice, damn strict conventions.

There’s a rather loud background noise at times (at 3:10:50 for example), which slowly ramps up and then suddenly dies down. Is the mic picking up a computer fan?

I can sympathise with you from the other side about getting the struct field names and types the wrong way round. I’ve been writing some C++ recently for the first time in years, and I keep doing it the Rust way.
And those semi-colons after class/enum definitions. I forget those every time.

Any cast in C++ is codesmell?? I work with bare metal embedded code a lot, and see this VERY often. I’m not sure I see the issue. Some peripherals and IC’s have data types that are in various forms that the micro needs to handle, and that is often going to involve some sort of integer reformatting. IAR compiler doesn’t even warn you when you use reinterpret_cast in a constexpr assignment lol.

While Rust does solve some problems, the syntax is so unnecessarily cumbersome that I don’t think I’ll use it.

On the subject of unwrap at 1:13:00, Programming Rust has a good quote on the rare cases where unwrap() or .expect() is okay and sometimes even preferable that I think explains the usage quite well:
“That said, situations do come up where a Result value truly can’t be an
error. For example, in Chapter 18, you’ll see that the Write trait defines a common set of methods (.write() and others) for text and binary output. All of those methods return io::Results, but if you happen to be writing to a Vec, they can’t fail. In such cases, it’s acceptable to use .unwrap() or .expect(message) to dispense with the Results.
These methods are also useful when an error would indicate a condition
so severe or bizarre that panic is exactly how you want to handle it.
fn print_file_age(filename: &Path, last_modified: SystemTime) {
let age = last_modified.elapsed().expect(“system clock drift”);
…
}
Here, the .elapsed() method can fail only if the system time is earlier than
when the file was created. This can happen if the file was created recently, and the system clock was adjusted backward while our program was running. Depending on how this code is used, it’s a reasonable judgment call to panic in that case, rather than handle the error or propagate it to the caller.”

All of these IDE problems would be solved with the Rust plugin on Clion, which is must better atm lol

For c++ I decided to start using lambdas instead of macros in a library I’m coding right now.

I love this series! As someone mostly only familiar with Rust it gives me the chance to get some exposure to a bit of C++ thinking and terminology at the same time.

The video got trimmed out to only 2h… Where is the other 1h30?