Hacker News Reader

Comment by vatsachak | Hacker News Reader

I think that people hyperoptimize for no reason though. How many applications are there that require no GC? I feel like you can write the no-gc code in Rust and then just use it from the C ABI from any GC language.

View on HN

Embedded systems benefit substantially from decreased GC, especially in the context of non-relocating collectors (as with Go) in machines without memory management units. The problem is not the overhead, it is the effect of memory fragmentation.

The OP article here is nice because it allows selective enforcement of allocation free code. If you have code that has some discipline about heap allocation such as having all small allocations then you are OK on the fragmentation front.

Real time Java is doing just fine with PTC and Aicas still in business.

GC in Java is the best in world with a lot options and knobs that allows to tune to particular application requirements. Still some trading platforms using it disable GC and just ensure enough memory is available so memory leaks during the trading hours would not matter before the application will be restarted.

Just like plenty of C and C++ deployment scenarios have special purpose memory allocators, or forbid memory allocations other than at startup.

Yet one still needs to account with processes like MISRA to account for safety.

Isn’t writing Go for embedded systems kinda like eating soup with a fork tho? This language was designed to write multithreaded asynchronous code to power microservice meshes.

If it's within like 90% of your targets and it's a far easier development experience, but you need to optimize a small bit to fit in the budget, tools like this can be fantastically useful. Rewriting the whole thing in, like, C, complete with a coroutine stack, would be a hell of a lot more work than "avoid allocations here".

There are commercial products using Go in embedded systems already, via TinyGo and TamaGo compilers.

Even ESP32 is much better than any MS-DOS PC, we have to update our understanding of embedded platforms, not everyone is writing Assembly or C dialects to PIC like microcontrollers.

I worked on a project with a network server written in Go with soft realtime requirements. In theory Go should be very good fit for it especially given GC tuning towards low latency, not throughoutput. In practice the latency spikes from GC were bad and there were no good options to resolve those given the deployment constrains and the amount of third-party libraries used.

This is a viable approach for many scenarios. Uniffi is a tool/library from Mozilla that makes this a lot easier across platforms.

After a few rounds of this though it might end up seeming like it's not worth the hassle and it's easier to build the whole application in Rust.

Lifetime and smart pointer hell is real though.

Once you internalize it it's really not a problem. That's why I said "after a few rounds of this".

I've been writing Rust for a year and change professionally, also as a hobby, and even though I love it, it's really annoying to choose the allocation model and lifetime model at every step.

For example,

- A field in a struct cannot borrow another field so now you'd have to create two structs. I guess you could write an impl to borrow that field instead of storing the borrow.

- In simulation software I wrote I found that mimalloc does just as good as bumpalo (within 5%) so carrying a bump everywhere was useless. Not really a rust issue but rather a loss of faith in manual memory management for me.

- Eventually over time you start adding Arc<Fn(Blah)->Foo> everywhere and Box, Arc and friends start coming in. But you can't have cyclical references there so you have to use Weak. And you have to use OnceCell or LazyCell or LazyLock for things that should run at start time.

Rust is really great for the crates, but ...

For applications which are not absolutely performance critical and cannot* be stated pretty easily in linear logic + clone + drop you can get away with Haskell

Switching out the entire ecosystem, libraries, tooling; rewriting the entire codebase; learning the new language and its idioms; and then giving up the unknown benefits of the previous language that the new language lacks (for Go->Rust this could e.g. be compile times)—generally, trading known downsides of a language for unknown downsides of another—is a huge undertaking and therefore very unlikely to ever be worth the hassle.

I agree. If the use-case requires no GC then Rust or Zig or C++ is a better fit.

I don't see much point in choosing a language just to bypass it's features.

Coming from an environment in which we extensively use mixed codebases (C++ and Python) to combine performance and ease of prototyping, one of the pain points is that there is almost always some impedance mismatch between the lifetime/ownership models of the two languages. When something goes wrong here, it's usually a real pain to debug and resolve, and often the resolution involves imposing constraints from one language onto the other (e.g. C++ that would idiomatically use unique_ptr instead needs to use shared_ptr because unique_ptr is essentially impossible to completely capture in Python).

Given the issues involved in mixing languages, there can be cases where sticking with one "good enough" GC'd language and having to write a few performance-sensitive parts in very unidiomatic form to minimize/eliminate GC work is preferable.

I feel like that may be more of an issue with how Python's C API is designed, leaking basically most of its internals, and then having to remember to manage (increment/decrement) Python objects correctly.

I don't think that's the problem, at least not directly for us. The immediate interface between the languages is handled by a binding layer (e.g. pybind11 or nanobind), but that rarely lets you fully express object relationships (something that would be more possible without the binding layer) so it is very easy to either not capture ownership (and thus the C++ object is destroyed out from underneath you) or express a cycle that cpython can't understand (and thus the C++ objects are never destroyed and can leak a significant amount of memory). Explicit manual control would avoid that, but at a level of work that would be prohibitive of having extensive bindings in the first place.

Go really sucks at calling into C code.

Nah, for all Go design decisions that I usually complain about, CGO is actually rather nice.

It feels quite similar to using C++ on .NET via C++/CLI.

There is some cargo cult against CGO, I could not care less.

It's fine if you're only targeting one OS with maybe a small handful of architectures. Doing anything cross platform is terrible.

I thought C was a cross platform language.

Maybe the syntax is, but setting up the compiler and build system and linkers is very much not, especially for cross-compilation.

One of Go's major selling points is cross-compilation to other OSes and architectures is incredibly simple and fast, and _the same short build command works across every OS._

I maintain a CGO app that targets Windows macOS and multiple Linuxes and oh boy the build system is probably more complex than the app itself at this point.

I started coding with Timex 2068, developed for embedded in a past life, thus I fail to see how complicated doing a simple cross compiler in C happens to be.

I also have developed C and C++ native libraries for Tcl, Python, .NET, Java JVM/ART (JNI), Node.js.

Yeah I think this is a case of an old timer not having the perspective of the younger generation

`GOOS=windows go build ./...` versus all the jank you have to do with C is just not at all comaprable

Try to do that for a Windows UWP, iOS, Android or z/OS application, in pure Go.

Yes it is super easy, in a few selected workflows of Linux, BSD, Windows, macOS, everything else is just as "complicated" as regular C cross compilation.

Good thing I don't write code for those platforms! :P

Calling C functions is not free, compilation becomes a lot more difficult, Go tooling is not as helpful. Signal handling is still a mess. It works in the happy path where the FFI is not on the hot path.

I think it is more a skill issue than anything else.

Yes, marshaling has a visible impact, hence why one should think how to actually make it happen, not much different from using FFI in any other programming language, there is always an impact over staying in the same programming language.

Compilation being harder, only if the developer is not acquainted with C, which seems to be something harder to learn nowadays.

Signal handling is a mess even in pure C, especially since all UNIX implementations added threading support.

Go makes signal handling harder. Further, there is no FFI call overhead in Rust, C++, Swift. It isn’t marshalling, a function with no args will still incur an overhead.

Because Rust, C++ don't have a GC, while Swift does have a GC (RC is a GC algorithm) it was designed to be compatible with Objective-C runtime, thus C.

Having to swap stacks has not much to do with GC.

Reply on news.ycombinator.com