Literally every sentence dang has ever written on this site, that I've seen, is snarky.
> Yes, in the sense that if there's nothing interesting to say about a quote then there's no reason to copy it into the thread.
This one was both snarky and indignant. Indignant that anyone would post something dang doesn't like on his site, and snarky that the the original commenter hadn't conformed to norms of what positions are acceptable to utter here.
These are preference-based but you're pretending they're objective. I find _your_ comments to be full of snark and indignation more than any you respond to, but of course you won't agree. (But because you don't agree, that makes me objectively wrong, I know.)
"Tonal arguments are ways of, frankly, policing working class ways of communication, and covering them in elite preferences." - someone smarter than the average HN commenter.
The problem with this belief is that it implies that all of bigtech is massively overpaying for top talent who would happily stay on for pennies. While bigtech overpaying talent is more plausible than any other bigcorp doing so, it's still rather unlikely.
It is no coincidence that countries which need it least can unban it. Deindustrialization activists will focus their efforts on countries where the ban matters.
Wait until you realize that MCPs are just the APIs that we've failed to write before, and skills are just the documentation and simple CLIs we've failed to write before
Failure to read the room might explain why the tourists persist in the questioning beyond politeness, but not why they embarked on the quest to interrogate the worker to begin with.
My family does this and I can barely go anywhere with them for the embarrassment. Everything is an interrogation. They actually take delight in the waiter not knowing the answer to where the seafood was caught, and then lecturing them about the importance of knowing such things (this is the most common one they pull). That's not just failing to read the room.
We've been daily-driving this model for a few weeks and let me tell you, everything it does is a lot. Fast as fuck and it's actually not bad intelligence-wise for a fast model. It basically tries to make up for any intelligence deficit by just doing a lot, checking a lot, retrying a lot.
That's not to say I don't spend my days raging at it... a lot... but it's not that bad. It does tend to ignore completion criteria but it doesn't obviously degrade when being nudged like some models do.
Wait until you realize that the difference between path and query string is entirely arbitrary and decided by the server. Query strings should never have existed. They are an implementation detail of CGI webservers that leaked all over everything and now smells really bad.
You're drawing an equivalence between the wrong pair of things. I'm not saying that term=program; I'm saying that the type checker, qua `term -> context -> decision`, bound to a particular term, is a program `context -> decision`, and the other approach is also a program `context -> decision`. I guess it's defunctionalization, not "nothing", but a next-door neighbor of "nothing".
You have done no more to show an actual distinction in the approach than TFA and its linked blog post... It sounds like a naming thing to me. On one side we name the term/program as a term and see it as something checked by the kernel, and on the other you name the term/program as a program and see it as something executed by the runtime. What's the difference?
To be fair, lean wastes and leaks memory like a sieve, but this is almost all in the frontend. It has nothing to do with the kernel or the theorem proving approach chosen.
Well... effect programming using vtables. I think this is an emerging paradigm, but it is very early yet so it's difficult to define precisely.
My primary inspiration for the concept is theorem proving languages like Lean in which typeclasses ("interfaces" in the OOP terminology) are implemented using structures passed down as arguments ("vtables" in the OOP terminology) separately from any receivers (values of the type implementing the interface, which doesn't actually need to exist for Lean). Typeclasses (and interfaces) are an effect, albeit a simple and limited one. Lean can't express effects in their generality due to totality requirements, but the same mechanism would work perfectly well for effects too. As for the "vtable" aspect: the primary distinction in implementing typeclasses using exposed vtable passing is that the language does not in any way limit the programmer to zero or one implementations of a typeclass per receiver type(s) (cf. orphan rules in Rust, cf. compiling effect systems to witness-passing, etc.).
No, I'm saying it is checked and then discarded. (Or at least, discarded by the kernel. Presumably it ends up somewhere in the frontend's tactic cache.) That matches perfectly the metaphor, "rubs out earlier parts of proofs to make space for later ones".
The shared misconception seems to be in believing that because _conceptually_ the theory implemented by Lean builds up a massive proof term, that _operationally_ the Lean kernel must also be doing that. This does not follow. (Even the concept is not quite right since Lean4 is not perfectly referentially transparent in the presence of quotients.)
The author appears to have a serious misconception about Lean, which is surprising since he seems to be quite knowledgeable in the area.
Specifically, the author seems to be under the impression that Lean retains proof objects and the final proof to be checked is one massive proof object, with all definitions unfolded: "these massive terms are unnecessary, but are kept anyway" (TFA). This couldn't be further from the truth. Lean implements exactly the same optimization as the author cherishes in LCF; metaphorically, that "The steps of a proof would be performed but not recorded, like a mathematics lecturer using a small blackboard who rubs out earlier parts of proofs to make space for later ones" (quoted by blog post linked from TFA). Once a `theorem` (as opposed to a `def`) is written in Lean4, then the proof object is no longer used. This is not merely an optimization but a critical part of the language: theorems are opaque. If the proof term is not discarded (and I'm not sure it isn't), then this is only for the sake of user observability in the interactive mode; the kernel does not and cannot care what the proof object was.
Deceitful omission from TFA: the warning lights which the firefighter admits seeing override any tower authorization. Omitting this leaves a reader with several incorrect impressions:
INCORRECT: The truck was cleared to cross the runway.
CORRECT: The truck was forbidden to cross the runway due to the active conflict lights.
INCORRECT: Airport safety systems failed.
CORRECT: The only safety system relevant to the crash is the one which would actually alert the truck not to enter the runway, not the one that would alert the controller after the incursion happened (after all, the controller realized immediately what had happened). That system was, by the firefighters' own admission, working perfectly.
INCORRECT: The fault lies mostly with the controller.
CORRECT: While the controller made a bad error which contributed significantly to the accident, nevertheless, the proximal cause of the accident was the truck driver's failure to obey the mandatory direction given by the fully functioning runway safety system.
Zig is just doing vtable-based effect programming. This is the way to go for far more than async, but it also needs aggressive compiler optimization to avoid actual runtime dispatch.
> Yes, in the sense that if there's nothing interesting to say about a quote then there's no reason to copy it into the thread.
This one was both snarky and indignant. Indignant that anyone would post something dang doesn't like on his site, and snarky that the the original commenter hadn't conformed to norms of what positions are acceptable to utter here.