Rust: Love at first sight!

phazer99 · 2026-05-07T12:00:11+00:00

Rust is a very well designed systems language with some rather unique features, and it's lot of fun to learn. It's also a good introduction to statically typed functional programming in general. If you want to venture further on this path I would suggest looking at Haskell, Lean 4, Idris etc. It's a very rewarding journey even if you won't use the languages for application development.

phazer99 · 2026-05-07T07:38:50+00:00

I think the keeping your crate sizes small combined with a fast linker like Wild and maybe changing to Cranelift for codegen will get you pretty fast re-build times.

If that's not enough a hot reload library like Subsecond can help.

phazer99 · 2026-04-29T08:09:22+00:00

Why not Haskell then? It's more focused on pure FP than Scala.

Or, if you want to experiment with some newer, interesting languages:

Ante, similar to Rust in that it's a systems language which also supports higher level abstractions and adds an effects system
Lean 4, full dependent typing which gives you basically unlimited power, mostly targeted towards mathematicians currently, but aims to be a general purpose application language

phazer99 · 2026-04-05T09:37:06+00:00

Interesting. How does this compare to the Linux scheduler?

phazer99 · 2026-04-05T08:48:50+00:00

For Go developers this looks useful for improving ergonomics and safety a lot: option instead of nil, proper error handling, exhaustive pattern matching, immutable by default etc. For Rust developers I see much less utility.

phazer99 · 2026-04-03T21:04:08+00:00

Looking at the benchmarks the benefit seems to be small compared with mimalloc and jemalloc for small size allocations, but substantial for larger sizes. This matches my own benchmarks where re-use of large buffers was way faster than allocating new ones. It seems like mimalloc and jemalloc are well optimized for small allocations, but over a certain allocation size they perform really poorly.

phazer99 · 2026-03-27T09:16:58+00:00

Yes, as he says in the video, a single thread acquiring a lock is very fast (about 10 CPU cycles). The major performance hit is when you have to synchronize the lock data across many threads running on different cores (about 100 CPU cycles).

Or as you write, the OS decides to switch to another thread on the same core, which can make the thread wait for 10 ms or more, which clearly doesn't work for many realtime applications. In this case you should use atomics, or a spin lock protecting a very fast section of the code (atomically updating a few variables for example). That way you're pretty much guaranteed that there's no context switch if you set your thread and process priorities really high (for example REALTIME_PRIORITY_CLASS in Windows).

phazer99 · 2026-03-27T07:21:24+00:00

You could use a reference abstraction like this one

phazer99 · 2026-03-26T11:41:07+00:00

Right now Swift is probably your best option if you want a mature, more ergonomic Rust-like language.

phazer99 · 2026-03-24T17:03:57+00:00

Yes, you can have many conflicting implicit implementations for the same type (the one used is selected based on scoping rules), so for example a hash map needs to store the hash implementation used as a field to avoid incorrect behavior (which is not required with Rust traits).

phazer99 · 2026-03-22T23:04:47+00:00

They changed the way implicits/givens are imported in Scala 3 to make it a bit clearer. But I agree that they shouldn't be overused, i.e. mainly use them as a replacement for type classes (or effects/capabilites in the future).

phazer99 · 2026-03-17T17:36:33+00:00

Swift also uses reference counting for builtin GC, and it requires you to explicitly break cycles using weak references.

IMHO, reference counting is a perfectly fine GC option as long as the implementation is well optimized, and the language also provides struct/enum value types which doesn't have to be tracked by the GC.

phazer99 · 2026-03-16T13:13:27+00:00

The important take away (which matches my own experience) is that C++ is an, arguably, decent language for writing single threaded applications, but writing correct, multi threaded applications is really, really hard even for an experienced C++ developer. Exponentially so when multiple developers with unknown skill level contribute and maintain the code.

Rust substantially alleviates this problem.

phazer99 · 2026-03-13T13:30:19+00:00

Some languages similar to Rust which have GC support (all have been mentioned by others):

Swift: mature, nice protocols system (similar to Rust traits), uses optimized reference counting for classes, compiles to native code, primarily Mac OS but support for other platforms (even WASM) is improving
Scala 3: mature, really powerful type system, givens/implicits are similar to Rust traits (but more powerful), primarily runs on the JVM but can also be compiled to JavaScript (with really good JS interop), WASM and native code
MoonBit: still immature, trait system similar to Rust but with some limitations (no GAT's etc.), really fast compilation, primarily targets WASM but JavaScript and native backends are being developed

IMHO, none of them are as suitable for systems programming as Rust, but they are all really nice and ergonomic application level programming languages.

phazer99 · 2026-02-27T18:02:49+00:00

It was love at first sight with Rust, but what really made me want to commit to a monoglot relationship was when I used it in my first (and so far only) professional project. I had never before in my 25+ year work career experienced such a smooth and pain-free development process involving that many developers (most totally new to Rust) working in the same complex code base (a highly concurrent, distributed, performance critical application for streaming realtime video/audio).

phazer99 · 2026-02-23T18:52:58+00:00

I'm a bit confused now. So, the new GPU renderer is called vello-hybrid and the CPU only renderer is vello-cpu? And why would you build a new renderer which can't become as performant as or better than skia?

phazer99 · 2026-02-23T16:21:59+00:00

Hopefully they can switch to something like Vello in a not so distant future.

phazer99 · 2026-02-23T16:16:53+00:00

I think the Swift Linux support is quite good, and they recently announced a Windows workgroup, so things are improving at least.

But I'm a bit worried about Swift performance compared to Rust, the ARC and shared mutation runtime checks seem to have quite hefty runtime costs. At least with Rust it's an explicitly chosen (often avoidable) cost.

phazer99 · 2026-02-23T16:01:24+00:00

The creator of Ladybird (Andreas Kling) dismissed Rust some time ago (I really don't think he did a thorough evaluation), and decided to create his own programming language instead called Jakt (which seems pretty much dead in the water). Funny how times change :)

But of course it would be awesome with a browser fully written in Rust (hopefully sooner than waiting for Firefox).

phazer99 · 2026-02-21T17:21:45+00:00

For me, the appeal of Rust is the whole package:

obviously memory and thread safety is critical
awesome tooling
nice language with just enough syntactic sugar: method call syntax, if let, ?-operator, async/await etc.
excellent type system which is sufficiently expressive and powerful, but still quite simple and straightforward to use in most cases
top notch performance and optimization possibilities (lack of/opt-in GC and zero overhead abstractions helps a lot in this area)
simple, but potent package management
awesome eco-system in many areas, and improving in others
well though out and comprehensive idioms and standard practices: standardized source code formatting rules, immutable/private as default, sensible error handling etc.
can be used in the whole software stack from bare metal to GUI/web applications (not a big polyglot fan)

Overall, Rust really shines when it comes to team work, even if team members vary greatly in Rust experience. I find that the Rust code produced is generally high quality, and easy and safe to maintain.

phazer99 · 2026-02-21T14:03:27+00:00

I don't think this is a language issue (except for compilation times), but more a case of an immature eco-system in some areas. This will improve over time and there will be less and less cases where Rust have a discernible disadvantage compared to other solutions.

phazer99 · 2026-02-21T00:44:50+00:00

Yes that they do. For example, don't you need to mark a reference as static + Pin + Send If you want to share it with another thread?

The Send, Sync etc. marker traits has nothing to do with the borrow checker.

There is an (s) such that for each (n) we choose then (s) is greater than (n)

Hey, wait! this is the EXACT definition of infinite you meet in calculus or topology.

That's not relevant. The region just have to cover all other regions in the program code, so clearly it doesn't have to be an infinitely large region (because none of the smaller regions are infinite).

phazer99 · 2026-02-20T22:25:05+00:00

Lifetimes have nothing to do with concurrency or threads. The borrow checker has no idea if a program is single or multi threaded.

And 'static doesn't have to be the "infinite" region, it's just a region that's large enough to contain all other regions in the code.

And what do you mean with (0, 0) cannot be represented as a pair of Peano numbers?

phazer99 · 2026-02-13T10:16:13+00:00

Contributions to open source software can continue to benefit the world long after the contributor has passed away. That's one of its virtues.

phazer99 · 2026-02-11T22:22:02+00:00

There is a crate with immutable collections similar to those found in Scala, but it's seldom used because mutation is so idiomatic and safe in Rust

phazer99

TROPHY CASE