No single feature of Rust is enough to justify the effort to learn it. Considered all together however, there is a compelling argument. My first introduction came from a pal I sat next to at start of 2025 who showed me a leaderboard of languages, ranked by speed from AWS. Rust was very near the top, just behind the likes of C and C++ only, and yet it had hardly appeared on my radar. Python and Java languished far down the list. From then on, the more I looked, the more I liked. Eighteen months on it would be my preferred language for any application.

Let me explain some of the most influental factors that guided me to it.

Performance

Performance has been an unfashionable driver for language selection. With ever more powerful CPUs, more hardware has been the way to guarantee performance. Java has been a safe-space for corporates who need code that is quick to write and can run anywhere. Any speed compromise was never difficult to justify. For me though, performance is a huge factor. The hardware I use is deliberately low powered, fanless and low cost. And yet my primary application is very response sensitive, serving content & dynamicaly building web pages. Writing code with this constraint encourages better code, less bloat, less energy consumption and a more sustainable application in the long term.

Memory Model

Although I started out doing C. I consider myself a 'lazy' developer when it comes to memory allocation & deallocation. I have been very happy to never think about it when using Java or Python. Writing multi-threaded, I/0 heavy applications in C or C++ however is a major challenge, which every single memory allocation & release on the developers shoulders. But Rust has a beautiful compromise, where scope is understood at compile time, unused refs are silently auto-dropped when out of scope and all variables have clear ownership. Borrowing temporarly changes owner, move completely hands variables to another scope and mutability is closely controlled.

Memory safety is a much-hyped benefit of Rust, and rightly so. Memory buffer vulnerabilties plague less memory-safe languages like C, which form the bedrock of open-source software. Rust's strict memory ownership model obviates these problems which have become increasingly open to exploitation with the advent of Al generated exploits. Taking this category of vulnerability off the table is a huge win.

Garbage collection, used by Java and Python, was the only game in town it came to safely & automatically deallocating memory. The occasional CPU hit was never a big enough issue for me to justify moving to a language with more explicit memory freeing. But having now adopted the Rust's elegant model it is simpler and leaves the developer in compelete control with an utterly deterministic memory management. Another niggle off the table.

WASM Web Assembly

Let me quote W3 spec

WebAssembly (abbreviated WASM) is a safe, portable, low-level code format designed for efficient execution and compact representation. Its main goal is to enable high performance applications on the Web, but it does not make any Web-specific assumptions or provide Web-specific features, so it can be employed in other environments as well.

As an early user of Java Applets, this seems like a very similar solution. And it is, with some key differences, which are well explained here. For me, as a back-end developer looking to write complex web UI functionality, my only option to date has been Javascript + React, both of which would be a significant learning investment. WASM now offers full web client functionality, for complex Uls for example with yew, in Rust. Building web Uls is now back in my wheel-house.

Code Brevity

Java has improved so much in recent years. The transformation it has undergone from class-based to more functional style programming has been impressive. To facilitate such a change in the same language is no easy task. Yet Java is still quite clunky, with class files mandatory as your de-facto basis for describing your application components. Groovy relaxes this, but at a performance cost. At first glance, the way that Rust co-locates related functions is confusing. It is certainly not class-based but it offers just the right flexibility without imposing too much, Structs come in functions share enough common state, encapsulating logic, enforcing privacy and keeping function signatures sane. And standalone functions are also completely at the core of the language - something very foreign to a Java developer. Coupled with flexibility offered by Result and Option for error handling, code becomes less bloated, types are implied and extraneous declarations are removed. This leaves code that is readable, type-safe and pleasingly compact.

Helix Editor

Developing code on low-power desktops or laptops puts the spotlight on the resources required by your development environment. During the later stages of building last big Java project, using Intellij, it became clear that it was too resource hungry to run on my desktop. In the end I bought a new laptop to finish off the project. Roll forward ten years, and Helix is a 100% Rust-built development environment that runs in the terminal. Very old school, but very good, if it works. My previous terminal based development experience has been with with vim with ctags, but it never worked well enough. Helix is a game-changer however, and is (he says holding back a tear), then natural successor of vi/vim I believe. Once the commands are learned (and I don't know them all yet), development tasks like renaming, refactoring, searching for references or declarations are straighforward. And all editor fundamentals are simple. integration with rust-analyzer via LSP means Helix has all the details of compilation issues integrated into the code. It is a marvel to behold.

Cargo

The entire package management ecosystem provided by Cargo is simply the best I have used. Cargo provisions every dependent library in source and compiles them all locally, seamlessly building the tree. Targets can be libraries, binaries and different architectures e.g WASM. There no competing build manager, which means Cargo has been improved and refined to work for all. As a recent Rust convert, starting in 2025, I can say that I found no shortage of libraries. There was everything I needed for JSON, XML, I/O, web services, Markdown, regex and more. Very often (but not always) there is one library that everyone uses e.g. serde for JSON. And the std libary is very small for Rust, very little is bundled, yet there is complete confidence in the open source options available. The famously fastidious Rust compiler is a net benefit eventually, but a very difficult element to master at the start. The result is that once your code finally compiles (!) it very often just works, with every error case and logic permutation clearly defined with behaviour understood.

AI

This has emerged a major reason since my Rust journey began. In that time AI-assisted development has come through as the de-facto way to write code. It is fast moving and still controversial for many, but it seems certain that almost all code will be written with the assistance of AI going forward. With this will come greater freedom in language choice, less dependent on the developers years of experience. This begs the question - which language would you write your application in if there were no constraints? For many, the answer will be Rust. Speed, memory safety, flexiblity, extensive libraries and accessible for (human) developers when needed, make it a natural fit for AI.