Hi, I’m Denis Gladkiy, a software engineer specializing in computer graphics and a recent addition to the team at Huly Labs. For the past 20 years, I’ve worked primarily with C++, Java, and C#. Rust is a new language for me — one I’ve been exploring seriously for about a month now.

This post isn’t a deep technical dive or a formal analysis — just some honest impressions and everyday observations from someone approaching Rust with a fresh pair of eyes. I’m deliberately steering clear of the big-ticket features the language proudly markets — like memory safety without garbage collection. Instead, I want to talk about the smaller things — the day-to-day experience that makes Rust feel different.

Defaults That Actually Make Sense

One of the first things I appreciated was how many sensible defaults Rust has. Variables are immutable by default, and visibility is scoped sensibly. It feels like the language is built with safety and clarity in mind, not as an afterthought, but as the default posture.

It’s refreshing to work in an environment where the language assumes you’re trying to write correct code unless told otherwise.

Strict Typing That Works With You

The type system is strict — sometimes infuriatingly so — but in a good way. It pushes you to think carefully, but it rarely feels like a fight. When things compile, they tend to just work. There’s a learning curve, of course, but I found that curve to be intellectually rewarding, not frustrating.

Builder Patterns, Marker Types, and Composable Design

One of the most exciting discoveries for me in Rust has been how the language allows you to express builder-like patterns in a fully type-safe way — without relying on runtime checks, nulls, or flags. It feels like a new level of control over step-by-step logic.

The magic lies in Rust’s composability. Traits, associated types, lifetimes, enums, and even the lack of inheritance come together to form a toolkit that lets you model complex behaviors safely and expressively.

And then there are marker types — types that exist solely to signal something at the type level. For example, using phantom types or zero-sized structs to indicate configuration states, permissions, or compile-time invariants. These are things that in other languages you’d enforce with docs, runtime checks, or simply hoping no one misuses an API. In Rust, the compiler has your back — you can make certain invalid states unrepresentable by design.

For instance, a builder that transitions through configuration stages can use different types at each stage. You can ensure that build() is only available after certain required fields are set — not through panics, but through the absence of the method in the current type’s implementation. It’s elegant. It’s safe. It scales beautifully.

This reminded me of what LINQ brought to C#: not just a single feature, but a compositional design idea that leveraged the full power of the language. Except in Rust, it’s even stronger — because the compiler verifies everything statically.

Tiny Joys: Trailing Commas and No ++

This might sound trivial, but I love the trailing commas everywhere — in function declarations, in struct definitions — it just makes diffs cleaner and editing smoother. Also, the lack of the ++ operator? Yes, please. No more mental overhead around prefix vs. postfix semantics. It’s such a down-to-earth, engineering-first decision that makes me feel like this language was designed by people who’ve been burned one too many times by ambiguous syntax.

Build Scripts That Are Just Rust

Another win: build scripts written in actual Rust. It feels coherent and unified — you don’t need to context-switch into some half-baked DSL. Your tooling is part of your language, not tacked on.

A Surprisingly Mature Ecosystem

Coming from the world of C++, I expected Rust’s ecosystem to feel young and undercooked. I was wrong. The crates.io ecosystem is packed with well-designed, high-quality libraries. So much so that I caught myself looking up crates for problems I’d normally solve with a few lines of code — just because the ecosystem makes that convenient and, often, idiomatic.

Docs That Compile (and Test Themselves)

One feature that really impressed me is the ability to compile and test code embedded in documentation comments. While the testing framework might feel basic in some areas, this feature is pure brilliance. It keeps docs honest and up-to-date — and that’s no small feat.

Lifetimes

As someone coming from years of manual memory management in C++, I see them as a conceptual upgrade. They make memory constraints explicit and part of your design, rather than a dangerous afterthought.

So… Do We Still Need C++?

To wrap up, I’ll say this: I don’t see a reason to write new performance-critical code in C++ anymore. I’m not suggesting we rewrite all legacy code — that’s just not realistic. But for new systems? Choosing C or C++ over Rust without a very specific reason feels like giving away a competitive advantage.

I’m still learning. My understanding of Rust is evolving every day. But even from just a month in, I see enough to know: this isn’t just a trendy language. It’s a serious engineering tool — and it’s here to stay.