erase the context, perhaps? Deny access to Gemini associated with that google account? These kinds of pathological AI interactions are the buildup of weeks to months of chats usually. At the very least, AI companies the moment the chatbot issues a suicide prevention response should trigger an erasure of the stored context across all chat history.

The deadpan irony is on point. Something it seems the Norwegians have perfected.

Another one of my favorite examples of this (an ad for Oslo tourism): https://www.youtube.com/watch?v=8vhD59ac7nw

The Javazone videos were legendary too, very similarly Norwegian and very similarly overproduced: https://www.youtube.com/watch?v=RnqAXuLZlaE

I think a city should feel a little hard to get

I mean that's fine I guess. But the best deadpan Norwegian sketch is kammelåså: https://youtu.be/s-mOy8VUEBk

My breakfast recipe this morning, thanks to this article:

- 1/4 c. milk

- 1/2 c. flour

- 4 eggs

- 1/3 c. sugar

- some salt

- cinnamon

- cloves

- nutmeg

- poppyseeds

Did the first two cakes without baking powder, turned into something between a crepe and a tortilla. Did the last two cakes with baking powder and they were just a very squishy pancake.

As others have mentioned, SPICE is the traditional answer to that question. But SPICE feels more like a macro-assembler for circuits.

One project that comes to mind for high-level programming style circuits-as-code:

https://github.com/atopile/atopile

Show HN: https://news.ycombinator.com/item?id=39263854 More recent HN thread: https://news.ycombinator.com/item?id=44548449

Probably not much: the requirement is exact equivalence of program inputs to outputs, and as such the agents are performing very mechanical translation from the existing C++ code to Rust. Their prompts aren't "implement X browser component in rust", they're "translate this C++ code to Rust, with these extra details that you can't glean from the code itself."

Iverson's point is more regarding semantics than syntax, though. The only mention of syntax suggests its better for it to be simple (presumably so that the semantics are closer to the surface). Every programming language is a notation for describing computation; notation is a catch all for all three levels: orthography, syntax, and semantics. APL is interesting because it not only uses an unconventional syntax, but also an unconventional orthography (obligate usage of special symbols), and its semantics are different as well from most languages (array programming). Iverson's point is that APL as a notation is valuable for making the structure of certain computations obvious, and that this point generalizes across programming languages.

GingerBill's article is making a narrower claim: that semantics are what determines a good notation usually, not syntax.

> Iverson's point is that APL as a notation is valuable for making the structure of certain computations obvious,

Yes, very much so, where as usual, there are local maxima where each notation excels at representing some problems nicely and is awkward for others.

Breadboard is an excellent name for this project: it tells me that I can snap preexisting components (analogous to ICs) onto a grid and make connections (analogous to wires) between them.

Context, as always, is everything. I don't think that anyone is mistaking Peter Thiel for one of the elves of Valinor.

It is never wrong to be considered untrusted. It is only occasionally right to be considered trusted. Especially in zero-risk relationships that is the default on the anonymous internet.

Being considered neutral is different from being explicitly considered untrusted.

“can” has multiple meanings in English. It can express both epistemic (describing the world accurately as is) and dynamic (describing the capabilities and attributes of an object) modes. If used epistemically, then parent’s phraseology makes perfect sense since his epistemology makes no claim about an object’s variability across time.

It depends on the language, paradigm (or lack thereof), quality/accuracy of the names.

My work’s codebase is 30 years of never-refactored C++. It takes an exceptional amount of focus and thinking to get even a cursory understanding of anything a particular method or class does or why it’s there.

But for languages like C, I agree with you (as long as function pointers aren’t used abused).