Rust Is Slowly Winning Me Over
Approximately 85% of my career as an engineer has been spent writing Python. Outside of SQL, Bash, and a few other DSLs, Python has been my primary tool for building systems, prototypes, and production services.
Another 10–15% of my work has involved C++. Despite the rise of many newer languages, C++ remains a go‑to choice for robotics and other performance‑critical systems where tight control over memory and execution speed is essential.
At one point in my career I also spent some time writing Go. While I appreciated its simplicity and the strong ecosystem around cloud infra, it never became a language I truly grew fond of.
Type System
One of the reasons I deeply admire C++ is its strict type system. When a program I wrote compiles successfully, I am usually about 90% confident that it behaves correctly. That confidence is very different from what I feel when working in dynamically typed languages such as Python, where I often don’t fully trust the code until I manually walk through the execution flow I just implemented.
When Python finally introduced type annotations, I became an early adopter. To this day, I try to cover my code with type hints whenever it makes sense. I don’t apply them fanatically, but I do use them consistently for function arguments and return types, and occasionally for non-obvious class members where the additional clarity helps both the reader and the tooling.
Discovering Rust
For a long time I was looking for a programming language that would give me several things at once: the speed of native code, strong guarantees from the type system, and ideally no garbage collection. For some of my personal interests - especially efficient inference on edge devices - predictable performance and memory control matter a lot.
C++ checks almost all of those boxes. However, like many other developers, I was frequently frustrated by how difficult simple things can be in C++. The language is incredibly powerful, but that power often comes with significant complexity. Eventually I decided it was time to give Rust a serious try.
For years I joked with friends who enthusiastically praised Rust. At some point it almost became a running meme: whenever someone said a piece of software was great, the explanation was simply that "it was written in Rust." Ironically, I now feel like I am slowly becoming one of those people.
Rust gives me many of the things I was looking for: modern tooling, a strong type system, no garbage collector, and clear abstractions. At the same time it provides the kind of low-level control that is important for my work and hobbies, especially when building systems that need to move data efficiently to and from GPUs.
Networking and Libraries
Rust is a popular choice for building network applications. While the language provides built‑in support for asynchronous programming through the async/await syntax and the Future abstraction, it does not include an asynchronous runtime in the standard library.
Tokio is the most widely used asynchronous runtime in the Rust ecosystem. It provides the task scheduler, I/O drivers, timers, and utilities required to build fast, reliable, and scalable network applications using Rust’s async/await model.
Rust is also a strong choice for building web services. Although the language provides the async syntax and Tokio supplies the runtime and I/O primitives for network communication, developers usually rely on higher‑level libraries to structure HTTP services and REST-style APIs.
Axum, developed within the same GitHub organization as Tokio, is one of the most popular web frameworks in the Rust ecosystem. Axum is an HTTP routing and request‑handling library built on top of Tokio and Hyper, designed with a strong focus on ergonomics, modularity, and type safety.
Rust’s ecosystem continues to evolve rapidly, and discovering these libraries made me realize that Rust is not just a language for systems programming—it is also becoming a powerful platform for building modern, high‑performance services.
In short, after years of working mostly with Python and C++, Rust feels like a language that finally combines the safety, performance, and developer experience I had been looking for.