It's a no from me. I'm sorry.
The README, though? That's the first thing I read about your project. Anybody familiar with LLMs is going to pick up that one wrote it in an instant. Surely you understand your own project well enough to write it in your own words, right? If not, what's even the purpose of the project in the first place?
So it looks like it restricts the memory management to 100% scope based. I expect that makes a lot of designs for programs not translate to it as well as they fit in Rust or Java (for example). There are a bunch more constraining design choices they list further down:
> - Nothing ever moves
> - ... A string, an array of strings, a record with variable-size fields and an array of those records are each one contiguous block with no pointer in it
I'll have to look a bit deeper to decide if it's feasible to write many things in this language.
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.
The distinction for goose is that it has fixed locations where the free must occur (function return, effectively), not that it doesn't have dynamic allocation (because it does have dynamic allocation)
People working on cortex m series chips still static alloc though. :D
Them and game programmers. Also the HFT people from my understanding.
The latter two are due to latency concerns.
Still though, it is something that I think more engineers should try out once or twice. Thinking about how buffers actually need to be is a useful exercise.
I do that for the Playdate: statically allocate most of the large structures and tables in global variables, and don't call malloc or free after initialization is done.
I also put some things on the stack, not so much because I need to dynamically allocate or free something, often it's because I get lower access latency to the stack compared to main memory (because stack lives inside ARM's tightly coupled memory).
Say you wanted to make a Node.js framework with callbacks that react to an event. The callback might be a closure that captured some of its surrounding variables. At that point, any of the captured variables are not trivially stack-allocated.
You might be able to do something similar to what Rust does with moving though.
The tldr is you had to preallocate a struct with anything you wanted captured ahead of time.
This avoids the dreaded undefined behavior, but it can still be pretty bad. For example, accessing a record that has been freed and re-used could leak sensitive information from one user to another. Granted that kind of bug is possible with any memory safe language, but this pattern is probably more like to be used in goose than languages with automated memory management.
But the benchmarks are tiny, and it’s likely that Goose was tuned on them.
So, I think I would read this as: Goose has competitive performance to C and Rust and I’ll take them at their word that it’s as memory safe as Rust
https://www.se.com/ww/en/download/document/998-2095-18-12-19...
https://news.ycombinator.com/item?id=49749113
I genuinely wonder how this style minimized the loss function or got the most upvotes in RLHF and yet is so universally hated that it gets flagged to death almost every time, and similar to Reddit. If I were to describe it, it's "snappy" and information-dense, without fillers. I dislike it too of course.
The dead summary itself was reasonably informative, I'd say.
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.
How does this help for long term values ?
Isn't this kind of the point of Java's Project Valhalla or am I just confused???
(Feels like it should probably say "1.16x as fast" or "1.16x the throughput" - or something like that.)
Goose is a straightjacket by comparison. 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.
I was thinking about making a language with same thoughts: Safer than C++ and faster than rust (and a 3rd thing: optimized for AI)
and you actually did it for me. Hooray!
Just the AI language optimization thing is missing..