Rust and Crystal: My Two Main Languages

Before I get into the post, here's a funny habit of mine: I tend to use two different things side by side for the same purpose.
macOS and Linux, Helix and Zed, Claude and Grok, and my left and right hands come to mind right away. (I'm ambidextrous, by the way.)

Programming languages are no different. I started with C/C++, went through a bunch of languages along the way, and these days I've settled on Rust and Crystal. I think this pair is a really attractive combination. So today I want to talk a bit about why I find these two so appealing together, and what I'm building with them.

Rust and Crystal

Both are compiled, typed languages, and both are very fast. When it comes to popularity, though, they've gone in very different directions. Rust started with a strong fan base and is now a thoroughly mainstream language. Crystal isn't that popular even within its own community. People sometimes call it a quiet village, but the users it does have are passionate.

There are a few reasons I picked these two as my main languages, but the core ones are simple: Rust's stability and popularity, and Crystal's syntax plus my personal attachment to it.

Productivity and Ecosystem

A language's popularity says a lot about its vitality and the strength of its ecosystem. That translates into productivity, and it helps a program stay maintained for a long time. Rust is already an excellent language in terms of what it did for stability and speed, but the solid ecosystem and popularity on top of that make it even stronger.

Seen that way, a popular language is being developed by the combined effort of many people, whether we notice it or not. For me, Rust is exactly what fills that spot. For stable collaboration, I really have no choice but to go with a popular language.

Love and Learning

So you might wonder why Crystal, which isn't popular, is one of my main languages. There are practical reasons, like syntax that feels familiar from Ruby (which I used a lot before), fast performance, and lightweight binaries. But at the bottom of it is personal attachment. I just like the language.

# Crystal code is pretty intuitive, right? :)
channel = Channel(Int32).new

3.times do |i|
  spawn do
    channel.send 10 * (i + 1)
  end
end

puts channel.receive

In the end, it's people who read, write, and use a language. To keep going on long-running projects, you need some attachment to the language. That's true of more than just languages, of course. It's what lets you keep doing the work you enjoy. In that sense, Crystal is a language I've put a lot of attachment into, and one I enjoy using. I think it's one I can keep using steadily as the years go by.

There's one more big reason. A weaker ecosystem actually helps a lot when it comes to learning. Since there are no libraries for niche features, I end up building them myself and understanding how they work along the way. I learned a lot from that.

Balancing Popularity and Quiet Power

So what I'm trying to say with this post is that when you're choosing a programming language, you don't have to stick to the popular ones.

Sometimes it's just as valuable to pick up a language that's still growing, join its community, and learn along the way. If you have the time, try using a popular language and a growing one side by side. You'll get more out of it than you'd expect :)