“A language that doesn’t affect the way you think about programming, is not worth knowing.” Alan Perlis“

¹⁾

Not much happened last week. Lots of work work I guess. I finished the snake tutorial. Still don't get it.

I found this APP called rustlings. Its a bunch of small exercises that help teach the language. Going through those over the weekend should hopefully help.

I made these small sketches

The top half is super letter linker and the bottom is super text twist. They both have some similar parts. I think that super text twist could be a good proof of concept and then I can turn it into letter linker by adding the “Linking” and level generation shtuff.

I tried to ecs-ify super letter linker. but you know. ^{2) 3)}

Oh yea and I set up Neo vide why?? cause it looks cool..

⁴⁾

I also setup a new path folder on my E: drive and then added a bash command to startup nvide.exe

At some point it would be cool to add it to my right click context menu to open up neovide at a given location.

Ownership in rust is the set of rules on how memory is managed

ownership also makes rust safe. Take a look at this insane chart

basically Instead of having a garbage collector which will effect performance, or needing to keep track of memory yourself ⁵⁾. Rust has some basic rules around borrowing that are checked during compile time. It inserts its own clean up code during compile time. This works because it is so fucking anal about everything jesus.

⁶⁾

Stack: The stack stores values in a linear way. It puts the data in the order it receives it and removes them in the opposite order. This is knows as last in first out⁷⁾

Think of a stack of plates: when you add more plates, you put them on top of the pile, and when you need a plate, you take one off the top. Adding or removing plates from the middle or bottom wouldn’t work as well! Adding data is called pushing onto the stack, and removing data is called popping off the stack

The wonderful people at the RustDocs

All data on the stack MUST have a knows fixed size at compile time

Heap: The heap is less organized. You request space. The memory allocator finds you some thats big enough and gives you a pointer to it ⁸⁾. Since the pointer is always of a fixed size, you can store that in the stack.

Think of being seated at a restaurant. When you enter, you state the number of people in your group, and the staff finds an empty table that fits everyone and leads you there. If someone in your group comes late, they can ask where you’ve been seated to find you.

the wonderful wonderful people at the RustDocs

Pushing to the stack is faster ↔ allocating to the heap is slower because it has to find memory rather than just popping it on top

Reading values from the stack is faster, the computer knows how much to jump to the next memory location ↔ Reading form the heap is slower as the computer⁹⁾ has to take the pointer and find it in the heap.

The computer would rather work on data on the stack as it is so much faster and cooler.

When your code calls a function, the values passed into the function (including, potentially, pointers to data on the heap) and the function’s local variables get pushed onto the stack. When the function is over, those values get popped off the stack. umm if you don't know… now you know the wonderful wonderful people at the RustDocs

1. Each value in Rust has a variable that is called its OWNER
2. There can be only one OWNER at a time
3. When the OWNER goes out of scope, the variable is dropped