upvote

points

by weinzierl15 hours ago |
comments
upvoteby Aardappel12 hours ago|
next
[-]
Goose has no "unsafe" feature, and no undefined behavior, and is fully memory safe.

It is obviously has a lot of potential to be very fast.

It even does pretty good on DX. There is no borrow checker to fight. Algorithms that need indices in Rust are strongly typed references in Goose. Generally pleasant easy to read and write code.

The biggest thing against DX may be exactly where performance comes from: you need to think a bit on where to store your data :)

reply
upvoteby groundzeros20158 hours ago|
parent|
[-]
> and no undefined behavior

Where is the behavior specified?

reply
upvoteby vanderZwan14 hours ago|
prev|
next
[-]
Well, "safety" is a lot of things so you have to be a bit more specific than that about your use-cases. And I can't really answer it either way - I think WvO has to chime in about that himself - but I can point to some things that might give you some idea of what to expect. Here's what WvO wrote a few weeks ago when he shared Goose on twitter:

> Goose: my latest programming language. Safer, faster and less memory than Rust/C++ for algorithms where tightly packed, flat data structures matter.

> It can represent more kinds of data structures as flat, pointer-free bytes than any language I know.

https://xitter.cf/wvo/status/2107979660558766351

So one way to answer might be: how often do you reach for unsafe when using Rust? If you don't I guess Rust is safer. If you do… it gets trickier.

As for UB, I guess you could try looking through the spec and/or the reference? Like, the code is mostly generated by Claude after WvO wrote a specification. If it were anyone else I'd be worried, but given WvO's cv I actually suspect that means the spec leaves basically no ambiguity.

However, Goose compiles to C. Does that by definition mean UB sneaks in, or is there a "UB free" C subset? I don't write C, so I don't really know.

reply
upvoteby jibalt4 hours ago|
parent|
next
[-]
Certainly there's a UB free C subset ... everything specified by the C Standard or designated as implementation-defined is UB free by definition.

UB in C potentially destroys the universe so C programmers do their best to avoid it. A backend that generates C code is a lot more easily constrained than arbitrary manual code. While it's conceivable that a C backend could produce UB code, it would be a severe bug and isn't likely. It most certainly isn't "by definition" ... that suggests some serious conceptual error.

reply
upvoteby weinzierl13 hours ago|
parent|
prev|
[-]
I guess my question is if you can trigger UB in regular Goose and if you can, would it be considered a bug. I realize that this doesn't necessarily have a simple yes or no answer but I still think it'd help to know if Goose is more on the C++ side or the Rust side.

The complete omission of UB in the README could be one of two things. Either that the topic is not important or that it is considered a given and not worth mentioning.

reply
upvoteby vanderZwan13 hours ago|
parent|
next
[-]
Hmm, well the benchmarks always use an explicit "faster than idiomatic C/C++ and safe Rust". Similarly it also notes that in theory you could write equally fast C/C++ (since Goose compiles to C), but it would be an unreadable, unsafe mess.

Note also the fact that e.g. array indexing has bounds checks without escape hatches for the programmer, but the compiler can elide quite a few of them, and the language has tools to help the programmer write code that is guaranteed to be check-free.

I think that suggests the ambition is to compete with Rust in the domain of combining safety with not compromising on performance.

reply
upvoteby jibalt4 hours ago|
parent|
prev|
[-]
Goose has no undefined behavior.
reply
upvoteby adastra2212 hours ago|
prev|
[-]
Goose is written by a game developer. They tend to concern themselves with C++'s niche.
reply