A little Rust

Jeff Foster
Apr 23 · 3 min read

Every so often, I like to dabble in a programming language to get exposure to a new way of thinking.

  • C++ introduced me to design-patterns (the classic GoF book) and the perils of memory-management (More Effective C++, Effective C++, Template Meta-Programming).
  • Lisp taught me the value of small pieces, little languages and (most importantly) macros.
  • Haskell showed me the virtue (and pitfalls) of laziness and showed me that higher-level abstractions can be super powerful!

It’s been ages since I picked up something new, so I’ve started taking a look at Rust. Why Rust?

Well, firstly it’s been gaining mindshare. Rust is increasingly commonly mentioned on the blogs I read, and it’s Stackoverflow’s most loved language for the last 5 or so years.

What makes Rust different? Like C++, it doesn’t have garbage collection, but unlike C++ it has a rich ownership model guaranteeing memory and thread safety. Memory safety makes Rust super attractive as a systems-programming language.

As a learning exercise, I ported over a previous project from Haskell to Rust. You can see the sort of output it makes below, and check the code out at https://github.com/fffej/learning-rust/tree/main/orbit.

Some random planets orbiting the “sun”

So, what’d I learn from this experience?

Rust has clearly had a lot more thought about developer experience than other languages (Haskell and C++ spring to mind). For example, if you pass a reference instead of a value, you get a handy message (compare this to C++ and getting a template parameter wrong, or Haskell’s foldable/traversable saga).

Ah-ha, so that’s what I did wrong!

In a similar vein, the documentation and surrounding ecosystem is super friendly to use (at least for the limited third-party packages I used).

Rust has an auto-format (rustfmt) which proclaims the one-true way to lay code out. It’s a small thing, but it’s just another thing that improves the DX.

Within the language, the typing features play towards my biases. After writing lots of code (and reading more), I prefer code that I can reason about locally. Rust’s semantics support this well since you have to explicitly specific mutability. The strong-typing means less unknowns when looking at a local bit of code.

What didn’t I like (with the caveat that means “I have no clue what I’m doing but I didn’t like this in the few days I spent writing code so don’t take it too seriously)?

“clippy” sounds like it should be a great idea, but it gave me false positives out of the box. I should have probably invested some time in setting some sensible defaults.

I didn’t find a nice way of composing functions (pipelines), but it seems that this can be done fairly simpler with macros. More for me to learn here!

Ingeniously Simple

Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore

If you have a story to tell, knowledge to share, or a perspective to offer — welcome home. It’s easy and free to post your thinking on any topic. Write on Medium

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store