I can confirm, I’ve never used a non memory managed language, and the Rust borrow checker is a massive kick in the teeth

But, the more i consider it from the perspective of memory, and pointers, the borrow checker makes a lot of sense

Especially when storing references inside structs, and how mutability affects references

I actually figured out i could fix a re-mutable borrow error by performing the two mutable operations in separate for loops

Blue cheese is intentionally inoculated with mold. Specifically penicillium mold that is perfectly safe to eat.

If a cheese “naturally” develops mold, there’s a good chance it could be harmful, so don’t eat that

The SoC on the motherboard has a special EDL mode

This is kinda like the SoC’s pre-bootloader, which loads the bootloader and can be used to flash a new bootloader

EDL mode is locked behind vendor specific certs/keys, so it’s unaccessible to the device owner

Fiber?

I just did a quick search for coffee nutrition facts, and all resources say 0g of fiber

Assuming you’re using a paper filter, only water soluble particulates will end up in the coffee

And, water soluble fiber tends to be a thickening agent (porridge, Psyllium husk)

On what plane of existence is coffee a good source of fiber?

Quality work will always need human craftsmanship

I’d wager that most revolutionary technologies are either those that expand human knowledge and understanding, and (to a lesser extent) those that increase replicability (like assembly lines)

Sometimes you forget to verify if your assumptions are true

I just have a spell checker enabled in vscode

So helpful for dynamic languages that can’t detect undeclared variables (looking at you JS)

I was reading Crafting Interpreters. After adding function calls and stack frames, i tested my implementation with the Fibonacci script at the end of the chapter

I spent about 2 hours debugging my call stack, and even tested the script in Python

Only to realize that Fib(3) is indeed 2

I’m not sure that’s their intended design. Old pull-tab cans actually had a ring for you to pull them off (similar to “easy open” soup cans of today)

I’d imagine that as the tab shrunk and changed from pull to a lever action, the “ring” was left as a vestigial design (as a form of skeuomorphism)

That’s the only reason i don’t think this is real

This is genius

The market is cyclic with each boom and bust.

We’re experiencing the beginnings of a bust.

Here’s a good video on these topics

https://youtu.be/LXUw0xSib-g

If you do that, you lose formatting and comments every time you load the source from disk

As much as this hurts, yeet; as an alias throw; is hilarious

Sanity checks

Always, always check if your assumptions are true

• am i even running the function?
• is this value what i think it is?
• what is responsible for loading this data, and does it work as expected?
• am i pointed at the right database?
• is my configuration set and loaded in correctly?

Only eggs can sustain me

I’m more talking about theory than practical.

I’ve not developed anything in C/C++, so I don’t know practical uses for a double pointer, aside from multidimensional arrays, or arrays of pointers

My point was that, conceptually, pointers to pointers is how most complex data structures work. Even if the C representation of said code doesn’t have a int** somewhere

The distinction is meaningless in the land of Opcode’s and memory addresses

For example, a struct is just an imaginary “overlay” on top of a contiguous section of memory

Say you have a struct

struct Thing {
  int a;
  int b;
  Thing* child;
}

Thing foo {}

You could easily get a reference to foo->child->b by doing pointer arithmetic

*((*((*foo) + size(int)*2)) +size(int))

(I’ve not used C much so I’ve probably got the syntax wrong)

Mostly because at the lowest level of computing (machine code and CPU instructions), pointers are the only method (that I know of) of any kind of indirection.

At the lowest level, there are 2 types of references:

• CPU registers
• memory addresses (pointers)

Every higher level language feature for memory management (references, objects, safe pointers, garbage collection, etc) is just an abstraction over raw pointers

Pointers themselves are really just abstractions over raw integers, whose sole purpose is to index into RAM

With that in mind, pointers to pointers are a natural consequence of any kind of nested object hierarchy (linked lists, trees, objects with references to other objects, etc)

The only other kind of indirection would be self-modifying machine code (like a Wheeler Jump). But the computing world at large has nixed that idea for a multitude of reasons

I already despise tipping. This sounds like a nightmare

I like transactions to be transactional. Tipping adds a completely unnecessary social and “uncertain” component to payment.

I don’t want to factor in service and other objective nonsense, every time i pay for something

Tipping should be outlawed (or rather, tipping should not count towards minimum wage)