rzmmm

An alternative is to write data abstractions (encapsulation, abstract data types, etc. LLM really avoid those).

Well, the statement can be the 500k line part if it's generated with an LLM. But I think some people miss the point of Lean when they use LLM like that.

And rust...

I'm pretty sure one reason is to influence public opinion about LLM regulation. Open-weights models cannot be restricted as effectively and they want to ban those for obvious reasons.

It also depends how leakproof the abstractions are. Goto statement and if-statement might both compile to similar jump instructions in assembly, but it's abstracted away. Similarly dynamic dispatch can abstract the branching so it can be ignored.

I think it provides best bang for buck when the annotation is "obviously correct" but the implementation is complex.

For example if you are trying to prove that your new sorting algorithm yields sorted list for all inputs.

If there is as much annotations as there is code, then testing is better tool for the job than verification.

I use Java for hobby projects, I think it's design choices make it a nice minimalist language for "classic OOP" style: dynamic dispatch, encapsulation etc.

Nowadays a lot of code is written with mostly procedural style with some functional characteristics, I wouldn't use Java for that.

Almost no myopia in hunter-gatherer populations. I don't view it as "disease" but it's not physiological state either.

Isn't it obvious? Web scraping and even scanning written books is at record levels because the data is so useful for training. They are using every byte of user data.

It does work, at least in my experience. The challenge may be cheap for your n-of-1 but keep in mind the scraper bots are crawling number of domains with very high concurrency.

It's remarkable how stable 20-30% show HN concentration is after late 2022, for the extended stats.

Interesting. To me it seems there are bunch of special cases where ketone monitor can be big help.

Reading these comments it seems that meta-discussion of AI is the most hot button topic of all in HN.

Well you need some substrate which can be metabolized into sugar, such as carbohydrate or protein.

You can write raw sql and use the "describe" clause in script, and then generate code with the result. This gives full db-backend-frontend type safety with raw sql queries

This just shifts the legal responsibility to you.

It can also be a personal preference for minimalism vs. maximalism. Or many other things.

The implementation of the kernel is relatively trivial, it's an intentional design choice.

It depends. In music for example it's often question whether the artist has been exposed to the original work. In that spirit, small language models are less likely to infringe copyright.

It was not really a traditional rewrite. More like transpilation. Still impressive

I don't like the copy paste. Rather use lower-level abstractions for the UI if I know I have to make modifications.

You need to understand the bits you are trying to prove, but not the full proof. It's more like reading haskell types than math, even though the vocabulary is heavily inspired by math.

Is there benefit of using this branded type over just encapsulating the raw string in a private variable in closure or class? This feels a bit like forced nominal typing. The Email type doesn't have to be a string, it can be encapsulated so that invalid Emails are not representable.

Over the last couple months I've seen the debt multiplication in some OSS projects. It's like premature aging of a codebase.

"before Bison version 1.24, Bison-generated parsers could be used only in programs that were free software."

https://www.gnu.org/software/bison/manual/html_node/Conditio...

Likely just that they err on the unnecessary error handling than missing error handling. They likely penalize runtime errors harshly in the training

There are codebases out there with enormous amounts of duplication, filled with implicit dependencies. You just haven't encountered them to appreciate good abstraction.

The author has huge online following, and influence over developers. I don't doubt the author is genuinely interested in this, but the employer definitely is supporting this too.

Bingo. Dozen LLM-prototypes and then a manmade final patch which is merged.

This is mainly for performance and memory layouts, it would not have improved safety guarantees of java.