My time with Rust

My time with Rust started back circa 2012. Then, I was learning Golang and was attending local Go meetups. A few years later, I had created my first open-source project written in Go called emotes2emoji.

emotes2emoji is a small project that converts git commit strings like :) and :( into emojis, and would hook itself into your git hooks, so when you make a git commit, it would convert them. The project was inspired by Zach Holman’s Bubs project. This was also well before Lefthook was in existence but I always did see the end-point of this project to eventually be something akin to Lefthook.

I had some complaints about Go that many people share and is arguably one of the biggest contentions in programming. Error handling.

Back when I was working for an org called ProQuest, I saw that some engineers from Mozilla were working on this “Rust” language and it intrigued me, especially since I was writing Java a lot back in the day, and I was growing tired of it. So, I set out to learn Rust… Big mistake.

Like many others, I read a few chapters in the Rust book, did some exercises on my own, then stopped. A year later, picked Rust back up again, read the same chapters and a little extra, then stopped learning Rust again.

This cycle repeated again and again. The learning curve for the language is famously non-linear. I liked the idea of the borrow-checker, the concept of ownership, and the aggressive compiler, but I loathed dealing with them. It felt like years until I truly understood what these concepts really are exposing (and to this day, I still don’t completely understand them).

I took it upon myself to force myself to learn it by participating in the Advent of Code challenges every year, and naturally - every year I fell off. I was able to pass the first few days, but the algorithmic problems in those challenges were too difficult to implement in a language that I was still not yet competent in (not to mention, algorithmic problems aren’t my favorite. I understand the fundamentals behind them, but I personally find they take far too long to implement). Mind you, this was before the age of AI and agentic programming. Browsing good ol’ StackOverflow, and trial-and-error were my bread and butter like any other programmer. When AI did enter the scene, I continued attempting the Advent of Code challenges, but with the intent of not using AI unless I was having a specific issue and I couldn’t troubleshoot my way out of it.

I learned a lot about Rust and how to write it semi-proficiently through the Advent of Code exercises, but it wasn’t until I landed a job that allowed me to spread my wings and force me to learn, understand, and write Rust.

Fast forward to 2025, after my employment ended at GitLab and I landed a job at Arrive AI - being the only Senior Software Engineer on the team, I took the plunge to implement our core applications in Rust, including an embedded system that sits on NVIDIA Jetson devices (or others), and a network intelligence center web application, all written in Rust.

Luckily, by that time, the ecosystem had already evolved tremendously. There were crates already available for embedded devices like embassy, and web crates like diesel and axum. While working for Arrive AI, I decided once again to focus my attention to learning Rust the old-fashioned-way by reading the book. With once difference — learning from the Rust book from Brown.edu.

As of writing this post, I still have not completed the entirety of the book, but I will say I learned a lot more about the language and can finally use it somewhat proficiently - for me it’s just writing idiomatic Rust that is the difficulty. What I write the first time, sure it works, but it’s far from pretty or what one would consider idiomatic rust.

Enter - AI. At Arrive AI, after I created some boilerplate code, with some hand-written markdown documents, I used ChatGPT (web version) to go module-by-module and help me plan some features. I still wrote the Rust code by hand, but with a lot of help on the planning aspect from ChatGPT. I like to think I know Software Design and Architecture very well, so I would feed into ChatGPT what I think good design would be - bounced ideas off of ChatGPT, and it would return back to me some ideas, some Rust code, and naturally some AI slop. The first few months of writing Arrive OS and our NIC was hand-written, with the assistance of GitHub Copilot.

A few months go by and our team tried out Cursor. It was a huge change, because this was the first time I had seen the ability of AI to interact with our code directly. It had context of the code, so it could make much better decisions. Around this time, I decided to see what it was capable of, and it was able to write better Rust code, but I still had to review it - especially since I have a keen sniffer for code smells. It would re-write existing functions, or place something somewhere where it didn’t belong.

I now have a total of around 1.5 years of programming Rust and I can say that is has made me a better programmer. Before I start programming in any language, I’m already thinking about memory movement, ownership, what might borrow which. Learning Rust has made me think about where things go and what actually owns which variable. Before, with my experience in Java, Python, Ruby, etc - it was easy to brush those things off. Especially with Ruby and Python. You can pass variables all over the place, and not really pay any mind to where that memory actually resides. But with Rust, now when I look at code, I can get a rough idea of where some piece of memory resides, whether it be on the Stack or Heap and how much space it takes up. Many of these fundamental computer science concepts I never quite understood nor had to care about, but with Rust, it has made me a better programmer. Now when I write TypeScript/Python, my brain has been trained to think the deeper questions. Who actually owns this thing? Where is the memory being allocated? How much data is it taking? Is it performant?

This brain re-training I think is what people, including myself, talk about they say that Rust is hard, or when they start the book and never finish it. Most of us programmers are locked in our own ways of doing things. We use the same web browser - we use the same IDE - the same tools; We use whatever is most comfortable to our workflow. Rust is a bull in a China shop to this notion. It forces you to re-train your brain and as long as you’re resistant to that, you’ll likely start and restart your Rust learning journey again and again and again.

You start to realize that the compiler, while annoying, really is trying to help you. It also serves as a security blanket for me at this point. I know that if it compiles, it works. In my experience with other languages, especially scripting languages, I don’t find out something doesn’t work until later down the road, and usually found during runtime. If the compiler passes, you know your program at least runs. Take C++ for example - now I’m sure better compilers/libraries help with fixing some of these safety issues - but I recently was doing more C++ (I learned C++ back in version C++03) and was pleased with the new language features of C++26. But even with C++26, there are things that the compiler just didn’t care about.

// example.cc
#include <iostream>

using namespace std;

int main() {
    char* input;
    cin >> input;
    cout << input << endl;
    return 0;
}

Take this example - it’s a ridiculous example but it helps prove my point. This is valid C++. Compiling this with g++ example.cc -o example would pass with flying colors, and produce the binary.

Run the binary, and you get:

{input something here and hit enter}
test
[1]    57692 bus error  ./example

This particular example is no doubt a skill issue, but the fact that this passes compilation is what I take issue with now that I’ve been using Rust. It has also been expressed ad nauseam online about the memory safety and compiler and why myself, and no doubt others, love Rust. The ability to catch so many issues at compile time is incredible.

This sentiment may change in the future. I have started tinkering with other languages like Zig. I do like Zig, and by no means will I say one is better than the other. They both have their uses and I will likely use them both - I will still use other languages like Python, TypeScript, Shell, etc for other things. Rust isn’t the magic bullet that we all seem to be craving, but for me - it is quenching my thirst for a low-level general purpose programming language that I can employ for developer tooling, website backends, system daemons, and embedded systems. I just need to keep reminding myself to keep writing it by hand and not letting AI take over my code lest I can’t recognize my code anymore. AI is a supercar; don’t go full throttle. Otherwise it’ll get away from you. Gradually put your foot on the pedal. And never stop writing code by hand, otherwise your skill will atrophy.