I had to test it. That is wild.

The other person has to be asleep and hears it as a whisper in their dream.

I can pause time in order to write as much code as I want without interruption.

Isn’t it part of some secret Pokémon lore that humans are Pokemon? Someone made a video on YouTube about it a few years ago.

I started doing this and have never looked back. We also keep the next loaf in the freezer, so we always have bread.

This was a great blog post. I love Rust and Bevy, but I can definitely see why you made the switch.

The primary issue with your decision to use Rust/Bevy, for me, was that you were taking on the task of getting others to work in a difficult language for novice developers. I would never suggest Rust as someone’s first language, coupling that with a regularly-changing library like Bevy.

I would love to know what the pros and cons were between Unity and Godot. If you were going to switch to C# anyway, Godot seems like the next logic choice to me, so I’m curious about what your team’s evaluation was for that engine.

I leave mine in the trunk and have only walked into the store without them twice. Not forgetting them before walking into the store and putting them back into the trunk after unloading them is the hardest part.

Exactly. The functions of the super trait are also required when implementing the child trait’s functions, as you would expect from inheritance.

Basically, you can generalize your trait types into their parent (super) traits for situations when functionality is specific to those supertrait objects.

As an example, if you have a trait CanBark and it is a super trait for the trait IsDog, you can coerce your references of &dyn IsDog into a &dyn CanBark. You can then work with other trait types that share a super trait.

trait CanBark {
    fn bark(&self);
}
trait IsSeal: CanBark { }
trait IsDog: CanBark { }

fn bark_as_group(barkers: &Vec<&dyn CanBark>) {
    for barker in barkers {
        barker.bark();
    }
}

let spot: &dyn IsDog = get_spot();
let seal: &dyn IsSeal = get_seal();
let barkers: Vec<&dyn CanBark> = Vec::new();
barkers.push(spot);  // coerced
barkers.push(seal);  // coerced
bark_as_group(&barkers);

At least, I hope this is possible now. If it’s purely “you can return a coerced type from a function”, that is less useful.

Wow, that trait feature is great. I’ve been eagerly waiting for that one for a long time. Thank you to everyone who made that possible.

When I learned Python I thought that not having a statically typed language was the way to go, but then it just became an issue when I was trying to ensure that everything was at least something like what I was expecting. Going back to statically typed languages even harder with Rust has been a dream. I love it.

This is very interesting. Are there similar options for Unity?

deleted by creator

That would be cool, seeing RGB GOL cells moving outward. Maybe instead of 0 or 1 brightness you could just round it for the cell’s purposes, maybe having a const float for flexibility: if it’s greater than threshold then it’s “on”.

That’s awesome! What are your thoughts on keeping the colors of your face as they naturally are and as the GoL algorithm acts on the pixels, you blend the colors together?

I just started using vim binding seriously a year ago and using vim generally to work with code. I’m so grateful for his (and everyone else’s work) on this product. I can only hope that my software can make such an impact on the world.

Can you please elaborate on how, when using Rust, we can avoid needing to debug our JS code? I am very interested and hope that I didn’t misunderstand you.

From my experience JS is primarily used to manipulate the DOM. I haven’t looked into it, but if you’re correct that WASM cannot manipulate the DOM then your question, to me, is tantamount to “Why aren’t people using forks to eat soup?”.

I would love a staticly-typed, compiled language to come along and replace JS. If anyone is aware of how I can write Rust in place of JS, please let me know. For now, I suffer/enjoy JS.

When I see a RIGHT JOIN I just shake my head and wonder “Why?”. That said, I can’t remember the last time I saw one.

I need to move away from using inheritance in my Python. I’ve been using Rust exclusively for the past year and it’s definitely going to affect how I write code in other languages.