My Journey with Rust: a CTO's story
Meet the next expert in our Rust interview series – the Co-Founder and CTO of a cybersecurity company.
In 2025 Rust celebrates its 10th birthday, which makes it the perfect moment to celebrate both the language and the people around it. Our Rust interview series shares perspectives from community leaders who are shaping the Rust ecosystem.
Our next expert is the Co-Founder and CTO of a cybersecurity company.
When did you first come across Rust, and what was your first impression?
My first contact with Rust was around 2016, while I was still at university. What I thought back then was roughly: “Nice, but the ecosystem is too unstable and changes too quickly – I’m not ready to commit to it seriously. I’ll stay with C++, my main language at the time and the one that paid my salary.” So I set Rust aside for a few years, checking in on it now and then and keeping an eye on where it was heading, but that was all.
Was there a moment when you thought, “Wow, Rust is amazing”? Which features or capabilities of Rust gave you that feeling?
It happened when I rewrote one of my pet projects from C++ into Rust. What impressed me wasn’t so much programming without segfaults as how convenient the tooling in the Rust ecosystem was. After the fragmented, awful C++ ecosystem, it was a truly incredible experience. Just think: in a “native” programming language, you can add dependencies in a matter of seconds and they simply work! No more adventures with assorted C++ dependency managers, working around their quirks and reading separate build docs for every project’s dependencies – in practice all of that is exhausting. Rust lets you reuse other people’s work quickly and painlessly wherever you need it. And on top of all that, your applications still perform at roughly C++ level – it’s simply wonderful!
In what ways has Rust changed how you tackle programming challenges?
That depends on how you define a “programming challenge” :) If you mean competitive programming contests of various kinds or things like Advent of Code, I don’t do those – I find other things far more interesting. When it comes to solving my own problems, I like Rust because it hardly creates any challenges of its own – most of the time I’m wrestling with my actual problem, not with issues in the language and / or its ecosystem.
If you could add one new feature to Rust, what would it be, and how would developers benefit?
I’d love to see something like Zig’s “comptime” in Rust. I believe it would make getting into compile-time programming in Rust much easier. Today we have macros, which many people in the community dislike – and they have solid reasons for that. Richer compile-time programming, in turn, could serve as a strong foundation for static reflection in the language, which has lots of interesting uses – for instance, writing serializers/deserializers efficiently in a readable, Rust-like way rather than the frightening macro way.
I realize that language designers may find it hard to fit this feature into Rust and that it could clash with existing parts of the language. Still, I’d be curious to see it, at least as an experiment.
What’s your favorite programming meme?
Whenever I hear someone going on and on about AI and nothing but AI without understanding the technology, a certain video starts playing in my head. And of course, saying “blazing fast” sarcastically ;)
Which tools and libraries do you depend on in your work as a software developer?
Well, I don’t really work with Rust as a “software developer” – my current role is somewhat different, which shapes my answer a little :) That said, my Rust projects typically use these libraries:
- Tokio (we’d be lost without it),
- Clap,
- Serde,
- Anyhow,
- Axum.
As for tools – I don’t use much apart from the standard Cargo tool, although for my project on profile-guided optimization (PGO) I relied heavily on cargo-pgo.
Outside Rust-specific tooling, I often reach for:
- ripgrep to work with logs,
- Docker for containers,
- Linux perf to profile.
Tell us about a situation where Rust made a big difference in a real-world project.
I’d rather talk about Rust’s impact on the industry as a whole than on one particular project. Having come from the C++ world and working in cybersecurity, I’m really glad to see how Rust has lifted the topic of memory safety (a crucial part of the broader security field) to an entirely new level across the industry. Before Rust, we largely treated memory bugs in C and C++ as a given – a required offering to the Gods of Performance. We knew it was bad, yet we somehow put up with it, creating numerous utilities to partly mitigate the problem: all sorts of static analyzers, sanitizers, etc. Rust proved to the industry that an industrial-grade programming language can automatically eliminate most – if not all – such problems, and do so in a way that is very convenient for the programmer. That, in turn, encouraged the community to take advantage of it and build new, more secure versions of applications. It also took the memory safety discussion within C++ itself to a whole new level. Both I personally and we as a cybersecurity company are very happy about this. I believe that over time we’ll see the real results of this paradigm shift in massive projects like the Linux kernel. It won’t happen quickly, but it will happen in the end.
How has the Rust community influenced your path as a programmer? Are there any memorable interactions or stories of support you’d like to share?
My dealings with the Rust community have been positive almost without exception – it’s hard to pick out any single “best” one. I’d like to thank the Rust compiler development team for the enormous effort they put into making the Rust compiler such a joy to work with from a developer’s perspective. In connection with my PGO project, I want to thank Jakub Beranek for his work on making the Rustc compiler faster, for building the “cargo-pgo” utility, and simply for answering my questions – talking to him was always a pleasure.
Did anything funny or embarrassing happen to you while you were learning Rust?
I have an amusing story about writing multithreaded code back when I was sharpening my Rust skills.
For one pet project, I had to use the AWS SDK for one of their services, AWS Gamelift. There was no Rust SDK, and I didn’t feel like writing Rust bindings for their C++ SDK, so I decided to rewrite the SDK in Rust quickly. Luckily, the SDK was open source and fairly small, so the job didn’t look all that hard.
I finished fairly fast and put the SDK on GitHub. Some time later, though, someone approached me on GitHub with a bug report – it turned out I could cause a deadlock inside the SDK! Sure, I know full well that Rust doesn’t guard against errors like that, but I had a little laugh to myself about “fearless concurrency” – even with Rust, it pays to be a bit “fearful” :)
What would you tell someone who is just getting started with Rust?
Whether you’re taking your very first steps in programming or you’re a seasoned programmer who decided to pick up Rust, don’t be afraid to contribute to open-source projects!
I regularly see similar questions on the Rust subreddit, and each time I feel like replying: “Check which Rust projects you’re using right now and try to make them better!” If you don’t use any yet – try some! It only looks difficult. Once you start with serious intentions, you can get involved very fast. Many projects tag issues with labels such as “good-first-issue” – look at those first. If there aren’t any, never hesitate to reach out to the project’s authors and ask: “I’m new to Rust and I use your project – I’d like to help make it better. Could you tell me where to begin? Thanks!” I promise you’ll nearly always get some pointers on where to start. In the beginning these will probably be easy tasks: fixing tests here, very simple bugs there – that’s fine, it matters too! By doing such tasks, you’ll get familiar with the project’s infrastructure, its development approach and its established culture, and you’ll see what Rust code looks like in a real project. After that, you can move on to harder (and therefore usually more interesting) tasks. Working on a project you use regularly will also give you extra motivation. It feels great to know that your feature helps not just you but other people all over the world. As a bonus, it can strengthen your portfolio and help you land a job. My own first engineering job came about precisely because of my GitHub profile.
Don’t count on every open source project assigning you a personal mentor – very few projects can afford that luxury. You’ll need to figure out a lot by yourself, and that’s completely normal – it’s how the industry works. If you’ve tried everything on your own and still hit a dead end, don’t hesitate to reach out to more experienced people on the project. When they see your question and how you attempted to solve the problem, they’ll most likely try to help, because they’ll recognize your motivation.
A very good engineer gave me this advice roughly 10 years ago, and it helped me enormously early in my engineering career. Now it’s my turn to pass it on to others.
How have you watched Rust change over the years, especially in your field?
You know, what I like is that Rust is becoming… boring, in any area. Yes, boring. When I first met Rust, the ecosystem had relatively few ready-made libraries, many of them offering fairly basic functionality (the 80/20 principle, as you know), and the language frequently gained features that mattered a lot for day-to-day work, etc. For someone passionate about new technologies, being at the heart of something evolving so actively is certainly exciting. But if all you want is to get your work done… instability isn’t the nicest thing to deal with.
Today the ecosystem is much better. I rarely run into a case where I can’t find a Rust library (for my use cases!), and the libraries are generally of quite good quality – I seldom even need to patch them! The language offers a pretty solid feature set that makes it nearly painless to use in many scenarios. That’s precisely what I expect from a good technology for the industry. There are certainly niches where Rust as a technology still has to make its mark – AAA gamedev, for instance – but we’re heading in that direction.
What do you expect for Rust over the coming decade?
I’m not sure I’m much of a forecaster, but let’s give it a go.
Over the next decade, Rust’s share of the industry will certainly grow, most likely by a considerable percentage. I base this on what’s publicly available from big market players – like Microsoft and Google – and on numerous publications from smaller companies. The Rust subreddit has plenty of success stories, and far, far fewer about migrating from Rust back to something else.
I’m quite certain that in the coming decade Rust won’t “kill” any programming language (the “killer” label usually comes up in the context of C and C++) – please don’t fall for that. There’s too much code written in those languages, and that code still matters a great deal to the industry. Rewriting it by hand doesn’t make economic sense, and we haven’t yet come up with good enough automated tools. Research is under way in these areas, but so far I haven’t seen results good enough for widespread use, not even with “magical” LLM-based tools.
Is Rust meant only for systems programming, or do you consider it valuable in other areas too?
I really dislike the term “system programming”, because I humbly believe people still don’t have a clear idea of what it means. Writing operating systems, writing drivers for them, embedded development – I don’t know, and I’ve witnessed far too many arguments over the precise definition (with no ultimate benefit to anyone).
Let’s say that here “system programming” means “writing OS and drivers”. In that case I can state with confidence that Rust works well for other things too. I’ve had great experiences using Rust to build backend services, to write CLI utilities for every occasion, and for game development (at least when you don’t need tight integration with “serious” game engines such as Unreal Engine and Unity). And those are only the areas I’ve personally worked in. Looking at the community, I see many more success stories from entirely different areas of programming: databases, log solutions, compilers, etc.
More specific cases have to be evaluated individually, and factors such as library availability (which can at times seriously limit Rust, even with the option to write bindings), regulatory matters such as access to certified compilers (we have Ferrocene here, but in real life it’s not that straightforward) and various other issues come into play. Overall, though, Rust can be used very successfully in many areas beyond “system programming”.