HN user
Hilarious. It is absolutely a logical défense: our societal order and its relative fairness don’t emerge from the void.
Otherwise a victim defending himself is the same as the person assaulting?
Perpetrator: you just stabbed me OMG!
Victim: you were going to rape and kill me
Perpetrator: sorry that’s just whataboutism and definitely not a logical defence. Your actions can be judged on their own merits, regardless of who presents the arguments.
I never understood how people referred to or understood “whataboutsim”.
I personally understand it not as a diversion but as a critique of the moral higher ground implied by the first accusation. Said differently: keep your own house in order.
I wouldn't disaree on the ergonomics: a powerful but unusable tool is... useless!
Though ignoring all the PL lessons for the sake of "pragmatism" is just plain ignorance.
Rust has a quite solid theory backing. Zig has nothing interesting really: it's "vibe coded" by someone who was doing game dev or something like that.
From a PL Theory perspective, Zig is vibe-coded.
Not sure why people use it.
I was wondering WTF was happening.
This was past month:
516 + 518*n
516 n=0 count=4454
1034 n=1 count=318
1552 n=2 count=129
2070 n=3 count=56
2588 n=4 count=35
3106 n=5 count=14
3624 n=6 count=6
4142 n=7 count=4
4660 n=8 count=6Because it’s supposedly open?
The main advantage of PeerTube and alike is that they keep the “professional content creators” and their crappy content away.
Because of their unique monetisation feature.
The Pi compression algorithm is better.
The important properties of the logarithm are structural: we usually do not care about units or bases, except when carrying out an actual numerical computation.
As developed in the article, informally, but somewhat sufficiently, the change of base formula shows that the choice of base is largely irrelevant: different bases give equivalent logarithms up to a constant factor.
The Taylor expansion of exp gives a more intrinsic and general definition of the exponential function. This allows exp to be generalised structurally to many algebraic settings, provided the relevant convergence conditions are met: for example, the complex exponential and its many possible logs, the matrix exponential, and so on…
I think sooner rather than later, AI will replace CEOs.
You’re absolutely right to push back on this.
Sometimes it’s not just about the Ys but also the Qs.
Enterprise programs*
Photoshop?! Where we’re going, we don’t need photoshop.
I assumed new projects but I just realised that I didn’t write it.
But still disagree: we have cbindgen.
I would say modern c++ written by someone already familiar with rust will probably be structured in a way that's extremely easy to port because you end up modeling the borrow checker in your brain.
I can't stress out how much important this sentence is. I would even remove the "familiar with rust" part.
Anyone who still thinks it's good to use C/CPP on modern hardware where Rust support is available and good: please print the sentence above and post it all over your place.
Imagine you read a value from stdin and parse it as:
Maybe Int
So your program splits into two branches:
1. Nothing branch: you failed to obtain an Int.
There is no integer to use as an index, so you can’t even attempt a safe lookup into something like Vect n a.
2. Just i branch: you do have an Int called i.
But an Int is not automatically a valid index for Vect n a, because vectors are indexed by Fin n (a proof carrying “bounded natural”).
So inside the Just i branch, you refine further:
3. Try to turn the runtime integer i into a value of type Fin n.
There are two typical shapes of this step:
* Checked conversion returning Maybe (Fin n)
If the integer is in range, you get Just (fin : Fin n). Otherwise Nothing.
Checked conversion returning evidence (proof) that it’s in range
For example: produce k : Nat plus a proof like k < n (or LTE (S k) n), and then you can construct Fin n from that evidence.
(But it’s the same basically, you end up with a “Maybe LTE…”
Now if you also have a vector: xs : Vect n a
… the n in Fin n and the n in Vect n a are the same n (that’s what “unifies” means here: the types line up), so you can do: index fin xs : a
And crucially:
there is no branch in which you can call index without having constructed the Fin n first, so out-of-bounds access is unrepresentable (it’s not “checked later”, it’s “cannot be expressed”).
And within _that_ branch of the program, you have a proof of Fin n.
Said differently: you don’t get “compile-time knowledge of i”; you get a compile-time guarantee that whatever value you ended up with satisfies a predicate.
Concretely: you run a runtime check i < n. _ONCE_
If it fails, you’re in a branch where you do not have Fin n.
If it succeeds, you construct fin : Fin n at runtime (it’s a value, you can’t get around that), but its type encodes the invariant “in bounds”/check was done somewhere in this branch.
Well I never advocated the latter, so please. And my logic is very sound, better than yours. :)
I was replying to "the US does not get to decide who can have a nuclear weapon and who does not". As much as I agree with that... my previous comment.
We're not talking about a nuclear program.
As much as I agree with you. Iran is signatory of the NPT with all its consequences.
Instead of letting more countries develop these weapons, we should work on denuclearizing all countries, starting with the US and Russia and their insane arsenals! And maybe build a unified international legal framework for civilian nuclear developments and applications from energy to medical outside of the "security council's" ferule!
A nuclear war cannot be won, thus never fought!
The next generation will include another processor to offload the inference from the RISC V processors used to offload inference from the host machine.
What core type theory is C3 actually built on?
The blog claims that @pool "solves memory lifetimes with scopes" yet it looks like a classic region/arena allocator that frees everything at the end of a lexical block… a technique that’s been around for decades.
Where do affine or linear guarantees come in?
From the examples I don’t see any restrictions on aliasing or on moving data between pools, so how are use‑after‑free bugs prevented once a pointer escapes its region?
And the line about having "solved memory management" for total functions::: bravo indeed…
Could you show a non‑trivial case where @pool eliminates a leak that an ordinary arena allocator wouldn’t?
Could you show a non‑trivial case, say, a multithreaded game loop where entities span multiple frames, or a high‑throughput server that streams chunked responses, where @pool prevents leaks that a plain arena allocator would not?
Ah I see, it’s a solution too!
I don’t really understand your point there.
Sound type systems are equivalent to proof systems.
You can use them to design data structures where their mere eventual existence guarantee the coherence and validity of your program’s state.
The basic example is “Fin n” that carries at compile time the proof that you made the necessary bounds checks at runtime or by construction that you never exceeded some bound.
Some languages allow you to build entire type level state machines! (eg. to represent these transactions and transitions)
Just create dummy wrappers to make a type level distinction. A Height and a a Width can be two separate types even if they’re only floats basically.
Or another (dummy) example transfer(accountA, accountB). Make two types that wrap the same type but one being a TargetAccount and the other SourceAccount.
Use the type system to help you, don’t fight it.
Another masterclass from the DODGY department.
The purpose of these institutions is to fund research, which is not necessarily profitable.
I'm pretty sure Rosenblatt was criticized back then for his non-tangible stupid ideas, and why the hell was his research was funded to begin with.
Particle on steroids.
No mention of the Cantor set (and its variants) indicator functions?
The author is DJB.
I’ll try to not be dismissive of the labour, though it’s kind of funny (or actually natural) that the heavy lifting libraries that only a few can actually write are open and free, while the shallow wrappers that everyone can write are paid and closed.
Decades ago we were calling out these software and now it’s the norm.
Another example along the line: I wanted to extract a frame from a video on iOS, it’s impossible with the built-in tools (screenshot aside) and found that someone built a paid app only for that.
I tell you where we’re heading, we’re screwed.
I did just that actually to:
* build a codegen for Idris2 and a rust RT (a parallel stack "typed" VM)
* a full application in Elm, while asking it to borrow from DT to have it "correct-by-construction", use zippers for some data structures… etc. And it worked!
* Whilst at it, I built Elm but in Idris2, while improving on the rendering part (this is WIP)
* data collators and iterators to handle some ML trainings with pausing features so that I can just Ctrl-C and continue if needed/possible/makes sense.
* etc.
At the end I had to rewrite completely some parts, but I would say 90% of the boring work was correctly done and I only had to focus on the interesting bits.
However it didn’t deliver the kind of thorough prep work a painter would do before painting a house when asked for. It simply did exactly what I asked, meaning, it did the paint and no more.
(Using 4o and o1-preview)