there's intuitively an argument via continuity (something something intermediate value theorem) where you show that no matter the time scale you cannot stop commits from being lost. this does not mean higher durability is useless, just that it exists "on the set R" rather than the set {true,false}

an example is something like WAL+synchronous=NORMAL in sqlite. intuitively this gives consistency, but you weaken durability, i.e. you might rollback. but i think of it like this: if a crash occurs, and you lose the last 1 seconds of commits, is that different than losing the last 0.1s? or 0.0001s?

I can't believe the wholesome chungus Coca Cola Corporation would betray my values on art and labor? ah well, at least this response won't be cynically exploited by other corporations looking to make money, too

nah bud if you think that pull quote conveyed any meaning whatsoever, you clearly don't really know how electricity works

bullshit is still bullshit even if it agrees with you

probably not good that all of social media has taught us that Being Wrong, But Smarmy About It is somehow a substitute for knowing or understanding things. or makes it OK to draw vaguely valid conclusions from totally specious reasoning (that can, how conveniently, fit in a post)

you also need to understand how units work too, i suppose. in any case there's plenty of prior art to draw from here for making that argument without embarrassing yourselves

also ignores the elephants in the room like "fork is broken with multithreading" but we all just sort of sweep that one under the rug and pretend it isn't real until you get a bug report that someone running Tru64 Unix found out your `#ifdef __OLD_GARBAGE__` codepath was actually buggy or whatever

also even in TYOOL 2025, unix desktops in particular still regularly hit weird OOM backpressure conditions that practically result in your system grinding to a halt anyway. like, what are we even doing here. none of this shit works well even after all this effort

the other use cases are things like fuzzers or things that actually want COW snapshot semantics but fork is too blunt and clumsy of a hammer for this stuff, too. you should be able to simply create a frozen process in userspace like a microkernel and "fill up" a process, then launch it

the use case for 99.9% of fork() calls is completely handled by posix_spawn(3). but at the same time, fork() basically requires overcommit to work properly. this is an extremely bad trade off in practice

yeah i think so, but on Oltorf between 1st and Lamar it's gotten incredibly bad again as it's a major road in that area. what's irritating is it was pretty bad for like 9mos, then they seemed to be done, now they're tearing up everything again. maybe i'm just baffled more than anything

i've been vibing out some side projects in my monorepo and it's amazing how even with only 5-8 sentences of prompt how good they are at "Implement this exact API, by looking at this spec." implemented an entire Bazel-compatible build caching server (~4kLOC) in like 2 hours

west oltorf man. this shit is getting insane