Yeah it's very clear at the bottom that it's created by AI. I think this is an interesting case where someone with some great ideas they never got to can actually implement them. I personally hate the Claude style, but just looking at the samples was enough to get a feel for the language.

right? man, I'm starting to really hate this kind of writing. Sure, use the llm to do the first draft, but at least, do a second pass and remove the stupid llm-isms

Yeah I hate the Claude writing style. It would be better with a cut down README. I suppose the point is that this was a latent idea that they got out there using these new tools, and that this would probably have not been done otherwise.

Embedded people are well used to this.

Dynamic memory management is a performance enhancement. It lets you more efficiently utilize memory vs static allocation at the cost of, well, lots of types of bugs.

You can always preallocate MAX_NUM_ELEMENTS * SIZE_OF_OBJECT for all your arrays. If someone tries to send you more objects then you have buffer space for you just reject the request.

Latency sensitive programs already do this, since memory allocation is rarely deterministic (although it can be in .NET and other similar languages). Likewise a bunch of destructors going off when an object is freed in C++ also takes a, practically, non-deterministic amount of time. (Really well profiles and controlled programs can make this deterministic if allocation patterns are always identical, but that is rarely the case.)

Of course having fixed sized buffers means you have to have protocols that are aware of size limitations. Most protocols now days assume infinite memory. Everything just fails, badly, when memory does run out.

After having worked in embedded for awhile I grew to deeply appreciate planning around memory limits. Really everyone should be doing it but almost nobody is.

You could write everything if you refactor to continuation passing style

What kinds of things do you think might not translate well?

u end up with stack based heap likes anyways

Usually strict aliasing.

As someone building a language with an LLM, it is exactly an exploration of curiosity. I have a lot of ideas, I don't always know how to implement them, and I certainly lack the time. The LLM can write the code, I can guide it, and I can learn what does or does not work.

Well it's their original idea and it's based on the Lobster compiler they wrote, so it isn't just a random person doing it. I'd say it's more like an expert language designer using a tool to explore an idea they otherwise wouldn't have time for.

Evergreen: https://randomascii.wordpress.com/2018/02/04/what-we-talk-ab...

(Feels like it should probably say "1.16x as fast" or "1.16x the throughput" - or something like that.)

116% would be 2x which will break the laws of physics. 16% is possible if you're not allocating heap memory, which I believe is the main selling point here.

My read: it's not the style per se, it's the association. People are just sick of AI slop and react badly to anything that smells like it.

The dead summary itself was reasonably informative, I'd say.

This style is deliberately trained by the frontier providers, not something that occurs accidentally. It is a manipulative style that is extremely effective against the general population. It utilises countless dopamine-inducing techniques used in clickbait headlines and Youtube thumbnails, and barrages the user with a wall of text that obfuscates everything it attempts to say, which is extremely useful for giving the appearance of intelligence; when you use a lot of sophisticated language and technical jargon, people won't understand you, but rather than assuming that you're stupid for writing something incomprehensible, they will instead give you credit and assume they can't comprehend it because it's too advanced for them, even if actually is incoherent.

It is only flagged on HN because it's been made against the rules, giving the minority who hate it the power to retaliate. It was only some months ago I was routinely getting downvoted every time I pointed out obvious bot accounts spamming a post per minute in blatant LLM-speak. Even now, LLM articles are still allowed and people upvote them to the top all the time.

> information-dense

Err, no. It absolutely is not. You could say that it's dense in technical language, but the style has mastered the art of saying a lot without saying anything at all.

If I am reading it correctly, the compiler creates N bump allocators per function (or possibly globally) - where N is (I'm guessing at this point) determined by liveness or similar.

A lot - title could probably use editing. The language has no heap, only stack memory, so the only deallocation is returning from a call stack frame.

[dead]

Project valhalla allows more things to be on the stack but doesn't get rid of the heap.

I suppose to be distinctive and have a "new idea", you sort of have to do that. Otherwise there's really no point in making a new language.

> I've never enjoyed languages that plant a flag on one mechanism and force users to adapt.

Well, the hardware designers have chosen one (or at most a small number of) mechanism[s] and implemented in silicon. The farther you diverge from their implementations, in terms of abstractions, language features, and the like, the more you will pay in performance. Your choice.

https://github.com/aardappel/goose/blob/master/samples/02_me...

It appears they got around that by making expanding and contracting data arrays builtin types the compiler impls. And it does this by creating what they call a "data stack" for each thing that needs to grow. To me it reads like "we have a builtin type that hides the heap allocation and does the free at the scope exit ", which is fine I guess as it keeps the nature of the language in tying lifetimes strictly to function scopes.

The AI optimization is to put it in distribution. So... make it look like python or js?