I Tried Every Hot Programming Language

In this post, I'll make an attempt to compare GoLang, Zig, and Rust. And why Rust wins this comparison (for me).

Story Time!

I wrote 3 of my projects in GoLang, Zig & Rust. These projects are sufficiently big to get a good idea about the language fundamentals, shortcomings, and whether there's a problem with the language, the framework, or the ecosystem.

TIP: feel free to jump to TLDR section to just get the damn answer.

GoLang

I started building developer tools a few months back, initially with GoLang.

The first one was a basic database management & migrations utility (dbdaddy) and I genuinely had fun working with GoLang.

Even though this was my very first attempt with GoLang building something more serious than Advent Of Code & 1 billion row challenge problems, I was surprised that it took me less than a week to get proficient at it.

Zig

All this while, I was dabbling with Zig on the side (nothing too serious). I heard about Redis changing their license to a "technically non-open-source" license.

And I thought to myself: how hard can it be to build a new open-source redis in zig?

Fast-Forward 2 months later: damn.

The basic idea behind "GbCache" was an LRU-based in-memory cache but the actual source of truth was to be saved on disk along with features like notifications for specific key/value changes caused and obviously TTLs assigned to keys.

It is impressive how explicit Zig is, which makes it all the more simple and easier to work with.

I started GbCache from the perspective of "if it were to go HyperScale™ tomorrow, can it handle the load?"

This perspective drove me to rule out GoLang because if I am unable to reason with extreme certainty about the memory allocations, I won't have complete control over the speed.

Doing things from this perspective is a really great learning experience because suddenly you start seeing all the points in your program that might blow up, run out of memory or may become a bottleneck —the hot paths in your code.

Due to Zig's explicitness, I was sure of exactly where & when I am allocating memory.

But... Zig is NOT a memory-safe language at the end of the day and I am a guy with skill issues the size of Everest.

enters rust

In the last 2 years, I've tried and rage-quit on Rust 3 times. Coming from a JavaScript background where we have a bajillion gb ram in our macbook m69 maxes, I never really understood why Rust had those rules, and going in with the hype was probably a bad angle to look at it from.

Even though I rage-quit several times, Rust was still in the back of my mind, its weird syntax, frustrating memory rules, and mind-boggling lifetimes.

But something hit me while writing Zig... I already was keeping track of all these memory rules and lifetimes but as a mental overhead.

I started noticing patterns and boilerplate in my Zig code trying to do what Rust already does.

Rust

While building the CLI client for SFS (SFW name - "Simple File Storage") I decided to give Rust another try.

This time around while going through the rust book, I started to feel the "why" of it all.

The most fundamental thing that I love about Rust is the ownership & borrowing-based mental model of memory.

Even though this model of owned & referenced memory is imaginary, it is a convenient mental model to reason about and incurs less overhead over my head.

As opposed to the classic mental memory model that languages like C & Zig incur on your head. Have to track individual memory allocations & their lifetimes in my head? no thanks!

TLDR

GoLang

• FAST (like your 5 MAUs are gonna need it lmao)
• reliable
• stupid simple, language is never standing between you & your goal
• great ecosystem of packages

Zig

• BLAZING FAST
• stupid simple

Rust

• BLAZING FAST
• reliable
• great ecosystem of packages

All Of Them

• amazing error handling

If you're an everyday normal mo— backend engineer and like doing numbers on their sprint performance, your best choice is probably GoLang.

"but my company doesn't use GoLa—"
"leave the company, leave it, use the right job for the tool. leave the company."

To me, GoLang is like an arranged marriage where you never feel that rush in your heart but it never lets you down, it's your ride-or-die companion and you can bet your whole life on it.

But my friend if you are looking for that rush keep reading on!

Rust Puran

bu— but i want that rush... i want to feel my heart explode on catching a mere glance at their ey-syntax... i want to feel like i am in heaven when I'm with them and in hell when I'm not...

Let's have a quick look at an example of multi-threaded safety in Rust.

use std::thread;

fn main() {
    let mut counter = Box::new(0); // 32-bit integer allocated on the heap
    let mut handles = vec![];

    for _ in 0..10 {
        let handle = thread::spawn(|| {
            *counter += 1; // trying to edit the value
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap(); // WAITING FOR ALL THE THREADS TO COMPLETE
    }

    println!("Result: {}", *counter);
}

We have a heap-allocated value and there are 10 threads trying to modify it independently.

This code is unsafely accessing the counter variable as all the threads will try to modify counter simultaneously.

In other languages, similar code will happily compile and run.

If you have worked in a multithreaded environment before, your first thought might be to use a "mutex" to prevent race conditions in updating the counter variable.

But it's easy to miss little things like this in a big codebase due to human error.

Rust won't even let this program compile.

由于所有权和借用规则，编译器会检测到你counter在 for 循环第一次迭代中的第一个线程中进行可变借用……到目前为止还好……第二次迭代也想并行进行可变借用counter？不安全！引发编译时错误！！。

引用或“借用”其所有者的值，并意图对其进行变异/修改，这被称为“可变借用”

src/main.rs|8 col 36-38 error| cannot borrow `*counter` as mutable more than once at a time `*counter` was mutably borrowed here in the previous iteration of the loop

在这种情况下，其他语言根本不会报错。检查正确性是你的责任，而 Rust 可以避免这种情况。

像这样在语言中传播的结构可以帮助你避免（经常）搬起石头砸自己的脚。

结论

这取决于！

我真的希望有一种语言可以解决这个问题，即使 GoLang 非常接近这个答案，但它仍然取决于你的用例，最重要的是你的团队。

对我来说，使用 Rust 是一种乐趣（现在，谁知道呢......呵呵）

TigerBeetle的人们尝试了Zig，并且对此很满意。

Primeagen 对Zig更加满意。

对于 Jarred Sumner 来说，Zig很好，他在Zig中写了Bun。

Mitchell Hashimoto（HashiCorp 背后的人）正在用Zig编写ghostty，这是一个速度极快的术语——

...
​
​

等待...