I would throw the entire docs out and write it from scratch in your own words. I get that we live in an era where the machine writes most/all of the code, and I can accept that. What I need, to even consider using and extending this project, is some understanding of what part of the design is yours and what part is accident by Claude. I can't get that from reading Claudese.

And ... you made Lobster lang, Cube2/Sauerbraten 3d shooter and voxray/voxile and lots of other cool things.

https://strlen.com/

What does this mean (from your link):

> Nested data stays inline. 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. A record that is 160 bytes and an allocation in C++ is 29 bytes and none in Goose.

I’m having trouble parsing that last sentence.

> Threads that share nothing. A worker is compiled as a separate program with its own memory, and flat values cross typed queues as a memcpy. Data races, locks, atomics and memory orderings do not exist in the language.

how to perform this copy without atomics?

do the workers run as threads or processes?

also you claim it's faster than rust and c++. but for certain kinds of software it's certainly (and substantially) slower, right?

I have my own language I'm working on in private and it's nice to see other people coming to the same conclusion on region based memory. I was heavily influenced 7 years ago from learning from HandmadeHero and the community around it, and so I made that memory model one of my goals from the start, and it is indeed possible to get very fast programming with it when you make it your default, and when you make the language able to statically analyze it more.

That is about where our similarities end, though, since I'm doing quite a lot of other stuff in the midst as well (much heavier type stuff, fully incremental, retargetable, reflection, integer range tracking, blah blah blah), and the more goals you have, the complexity blows up exponentially. I do think that the region based memory part alone is worthwhile to have as a language feature, so I applaud your pragmatism. I like your syntax for returning through call stacks, too.

There are other languages that do this, though. Did you look into any of the others? Or ones like Odin which give you the configurable bump allocators and scratch space as well? Mainly I'm curious about your opinions of prior art.

I will take a better look at Goose some time later when it's not late at night. Just wanted to drop by and thank you for creating Treesheets. I haven't given its more advanced features the use they deserve, but I love it as a note-taking application for anything that complexity-wise sits between a short outline in a plain text file and a ton of Markdown in something more advanced like Obsidian. And for, of course, any tabular data.

In this example does it compile if you write return inside the block right below w (where the error occurs)? https://github.com/aardappel/goose#safe-references-no-annota...

Hows the compile time? Do you have a number or is it similar to another language?

You noted AI creating a large amount of this code base with yourself directing it. Do you have a process that keeps you sane while doing this over such a large codebase?(especially for a brand new concept and implementation) [Obviously congrats and can't wait to read through to have deeper questions!]

Way off topic, but I enjoyed Amiga E. And, I reckon you're one of a handful of people I would take seriously when they say, "I made a new programming language."

You might want to update https://strlen.com/language-design-overview/ at some point.

Where does the language stand in the array-of-structs vs struct-of-arrays choices? Does it offer an annotation to choose that like in Zig?

Given we are getting to the point where coding agents write most of the code, what motivates you to create a new programming language? Follow up: do you build these languages keeping humans in mind, or are these meant to be used by AI agents?

Is this like forcing the escape analysis of the compiler to be perfect, by making it explicit in the programming language?

I'm wondering what kind of architectural corners this forces the programmer into ... have you found any so far?

Interesting, I'll play with it. In the "Why Goose" section there is a mistake I guess : "Faster than C++ and than safe Rust, while memory safe."

What happens if the memory is freed in a different order to allocation? Does the language disallow that? Or does it get allowed but mean the stack can't shrink?

How are you deciding how many stacks to use?

What are some use cases (if any) that the language is not suitable for?

Do you consider Goose to be a replacement for Lobster, or do they fill different niches?

First, Congrats on the release!

Do you know if Goose is the first time something like this has been done?

Why was it named Goose?

If you had no other obligations and todos getting in the way, what's the first thing you'd rewrite in Goose yourself?

(And why isn't it Amiga E?)

Why are you pretending that John is endorsing your project?