11,087 karma · joined May 9, 2009
For example, you might have an “x” in some inner loop within a function. Then later on, you’d add an “x” earlier in the function, not realizing that that name was used down below. Suddenly the inner loop is referencing that new variable, and there was no way to tell other than the surprising ways your code would suddenly malfunction.
What might work well is a lint rule to error if a loop expression ends an actual function declaration (i.e. not an inline callback), and the function doesn’t explicitly define a return type. I think that catches almost every bad case, aside from the odd memory leak in really unusual edge cases.
The other big one, which unfortunately Civet seems to be doing too, is implicit return combined with “everything is an expression”. You can have one of those, but not both. With both, it’s far too easy to write loops intended to be statements, and which accidentally turn into gigantic multi-dimensional array returns which can’t easily be optimized out by the compiler. Fortunately, this would be only mildly inconvenient to work around with a lint rule that forces explicit return in all functions.
And that’s frustrating, because the place where a make alternative could really shine is not in making the syntax for specifying scripts nicer, but in figuring out how to design the dependency APIs so that you aren’t almost guaranteed to get them wrong in subtle ways.
Proper receivers use a phase-locked loop to “lock on” to a carrier, rejecting any weaker interference on nearby frequencies.
In the analogy, suppose you’re decoding a signal from a flashlight over the entire color spectrum, but sunlight shines through the leaves of the tree, adding a slight green noise component to what you see, while the flashlight is actually red. You’ll erroneously interpret the signal as slightly yellow.
We don’t have anything like the PLL in our eyes, so the analogy breaks down here. In the equivalent scenario with an actual FM signal, that slight “green” component would not affect the received signal (or it would affect it to a much lesser extent).
That’s the hallmark of an analogy. It gives the general idea, but breaks down if we interrogate it in too much detail.
If you’re looking for “type in some English text and get fifty lines of code written”, Cursor’s chat is the best I’ve tried. But I’m not a fan of that workflow, so take my opinion with a grain of salt on that.
Now replace “addition” with modular multiplication, and “division” with the logarithm, and you have the trick behind DH. Swap out addition for this weird operation that involves jumping around elliptic curves, and you have the trick behind ECDH (admittedly, the fact that that jumping around thing works as a group operation is still pretty magical).
What I like about this way of thinking about it is that you can fully implement the key exchange in terms of integer addition, and the fact that it lets you pass around secrets in a world without “division oracles” seems pretty mundane.
This may become increasingly the case as models get smarter, but it’s often not the case right now. It’s more likely to be a few lines of code, a bunch of testing, and then a bunch of prompt tweaking iterations. Even within a vendor and model name, it’s a good idea to lock to a specific version so that you don’t wake up to a bunch of surprise breakages when the next version has different quirks.
I read somewhere (maybe in Thinking, Fast and Slow?), that formulas like this can actually be surprisingly effective, even though the units don’t make sense, because they encode an intuition but prevent you from putting your finger on the scale when applying it, by mixing in other biases. IIRC, the studies on this found that trying to tune these formulas by adding in weights tended to make them worse, which is especially surprising.
I’ll have to see if I can dig up the reference on this.
My biggest worry is that we end up with a dangerous superintelligence that everybody loves, because it knows exactly how to make every despotic and divisive choice it makes sympathetic.
One of the things that makes that problem interesting is that during training, “what the model is good at” is a moving target.
But this seems to be varying the intensity of each character as well, which means you'd only be able to display the result on a full color display in the first place.
I agree that as a blanket statement “gzip is enough” is not technically correct, but I think it’s largely correct in spirit, in that people tend to reach for minification by default, without really thinking about what they’re gaining.
If minifying saves you 200 KB overall, for example, and you expect your average user to have a 200 Mbps connection, you’re saving a grand total of 8 ms on page load, which is an imperceptible difference on its own. In exchange, you’re getting worse debugging, and worse error reporting.
Is it? It’s probably more obscuring from an LLM’s perspective, assuming the LLM has seen enough rot13 text during training. Spaces and punctuation are untouched by rot13, unlike base64, which means that word and sentence boundaries will still be denoted by tokens that denote those boundaries in plaintext.
And again, I have to ask: why? Why would you think that putting tons of time and effort into tricking the model into repeating memorized code is going to be a better investment than just using it normally to implement the functionality you want?