Hacker News Reader

Comment by Pxtl | Hacker News Reader

Garbage collector FAQ isn't necessarily reassuring, since it seems to say "go through the same hoops other GC gaming platforms push you through". Obligatory Rust gaming comment goes here.

View on HN

This is the standard Go response to every complaint:

- no generics? You don't really need it.

- no operator overload? You are doin' it wrong.

- GC pauses are annoying? Man up and reconsider what you do.

I never read it like that at all.

To me it says be mindful when allocating memory. This is no more effort than having to manually allocate and free memory, but also has the convenience and safety of a GC to fall back on.

If I'm going to have to be mindful of the GC I'd rather just avoid a GC language altogether. An abstraction you have to be obsessively mindful of is worse than no abstraction at all.

Nobody said anything about obsessing.

When you write code you need to care about your allocations, whether you have a GC or not.

When you write code without a GC you need to be mindful of freeing memory. With a GC you do not.

So the GC relieves part of the burden of memory management, and that part is often the hardest part (particularly in concurrent systems).

This is not neccessarily true, e. g. in Rust you have code without GC, but the compiler makes sure that everything is freed.

If that is true, what's the trade-off? There are no silver-bullets so if their approach didn't involve some potential "deal-breakers" Go team (or the ecosystem) would probably have offered a Go clone of it. Would be curious what they're doing there in Rustland..

I've only just started learning Rust, but from what I understand, the trade-off is that the type system in Rust is much more complicated, and thus harder to learn. Pointers have a concept of "ownership" and "borrowing", which can be more difficult to reason about, whereas in Go, you don't have to think about it as much--pointers are just pointers. It also makes the Rust compiler more complicated, which mean slow compile times. One of the main design goals in Go was blazing fast compile times.

Rust compile times are not due to the borrow checker. They are primarily due to optimization.

Pooled allocations/deallocations via factory methods ala Ardor3D or what have you aren't too annoying at all.

Most games allocate everything they'll need upfront on level load, or at least try to. If you do the same here, you'll get the same benefits, but with the additional safety of a GC.

Reply on news.ycombinator.com