From Elixir to Rust to Go: How I Found My Third Language 🚀

Every developer has that language journey—the one that shapes how they think, code, and build. For me, it started with the classics (Java ☕ and Python 🐍), and then wandered into some exciting territories: Elixir, Rust, and eventually Go.

This is the story of how I ended up falling in love with Go as my third language.

🎓 University Days: Elixir Experiments

Back in university, we dove into functional programming, and that’s when I first met Elixir.

At first, I was fascinated 🤩. Everything was about immutability, recursion, and message passing. The syntax felt clean, the concurrency model was mind-blowing, and the idea of building fault-tolerant systems on top of the Erlang VM made me feel like I was touching some kind of programming magic ✨.

But as much as I enjoyed learning Elixir, it stayed mostly in the classroom. Outside of assignments and experiments, I didn’t see it pop up much in projects or industry work around me. Elixir planted important seeds in how I think, but it didn’t stick as my daily driver.

🦀 Rust: Just for Fun

After uni, curiosity got the better of me, and I gave Rust a try.

Rust was intimidating at first. The compiler felt like a strict teacher 👩‍🏫 constantly reminding me about ownership, lifetimes, and borrowing. Honestly? It was frustrating sometimes 😅. But once I started to “get it,” I couldn’t help but admire how well-designed the language was.

Rust taught me a lot about how memory really works under the hood. Writing code in Rust made me feel powerful 💪—like I was in complete control of performance and safety.

Still… it didn’t feel natural for the kind of projects I wanted to build. I wasn’t writing systems software every day. For quick services, tools, and APIs, Rust often felt like using a sledgehammer to push a nail. Amazing language, but not the right fit for me.

🐹 Go: Love at First Compile

Then came Go.

At first glance, Go didn’t look as “fancy” as Elixir or as “hardcore” as Rust. But once I actually started writing in it, everything just clicked 💡.

What I loved right away:

Goroutines → Concurrency made simple.
Fast compilation → No more waiting forever to test small changes.
Readable code → Anyone could jump in and understand what I wrote.
Pragmatism → It wasn’t about being clever, it was about getting things done.

Go felt practical. I wasn’t wrestling with theory or fighting a compiler. Instead, it felt like the language was working with me, not against me. And unlike Elixir, Go was everywhere—companies, open source projects, tooling. It just fit.

📚 How I Studied Go

Once I decided Go was worth diving into, I went all in.

I started with the excellent book Learning Go, 2nd Edition from O’Reilly, which gave me a solid foundation.
Then I sharpened my skills through the Exercism Go track 🏋️, solving exercises and getting feedback from mentors.
Now I’m at a crossroads: I want to build something real with Go to showcase my skills 💡. The only “problem”? I have too many ideas! Choosing one project to focus on is the next big challenge.

It feels exciting though—like standing at the edge of a playground full of possibilities. 🎢

🌱 Where I Am Now

Looking back, each language shaped me in different ways:

Elixir → taught me to think in functions and embrace immutability.
Rust → taught me to respect memory and safety.
Go → taught me to ship fast, simple, reliable software.

Today, Go proudly takes the spot as my third language, right after Java and Python. It’s not the flashiest, but it’s the one that feels like home. 🏡

✨ Final thought: My journey through Elixir and Rust wasn’t wasted—it made me appreciate Go even more. ✨