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
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
I mean, you just need to look at the conflicting files, fix up the code, then stage those changes and pop a new commit
There’s no “special” merge conflict resolution commit “type”
As for fixing the code itself, I usually look at what changed between both versions, and then re-author the code such that both changes make “sense”
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:
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’m sorry Dolores, I must not tell lies”
As a software dev, i like having 3. Gives me space to see
Or having multiple vscode windows and a browser
I also move windows around using the keyboard (win + left / right), and the task switcher (alt + tab)
Did someone actually find a backdoor in Recall, or is this just the usual “M$ is evil” posting?
(Either way, fuck Recall Security Exploit Centrap)
Proton / wine is modern day magic
Most Windows only steam games work out of the box (you do have to enable it in the right click menu > Compatibility options, per game)
Games that use Anti-cheat aren’t likely to work (it depends on the Anti-cheat used and how it’s configured)
ProtonDB is a good resource for checking if/which games work, or fixes and workarounds
You can use proton or wine on non steam games, but that requires additional setup that I’m not familiar with