Introducing Bogdan Mircea, Rust Developer at Exein
Let me start by saying that I've always been deeply passionate about low-level programming. The more I learnt, the more I started to believe that high-level programming languages leave a lot of potential untapped simply because they prioritize ease of use. While this makes sense for many applications, there's something uniquely satisfying about the control and efficiency you can achieve with a low-level programming language.
There are languages dedicated to different areas. Development is a huge thing now. It's a very broad domain. So there are specializations within it, there's JavaScript for front-end, then there's C or C++ for systems -level programming, backend services, and so on. There's Python that's mostly known, I guess, for data science. So each has their ups and downs.
Before I started learning Rust, I was actually focusing on improving my C skills. While I had some knowledge of C, I had rarely used it professionally and couldn't really consider myself a C developer. As I was honing my C skills, I began to wonder about the practical applications. Positions specifically requiring C are quite limited and mostly in high entrypoint niches such as embedded systems or systems programming. For backend or high-performance services, C++ is more commonly used. The game development industry, for instance, prominently relies on C++. This realization led me to question the viability of pursuing C further.
I started hearing about Rust a few years ago and decided to see what all the excitement was about. Rust has consistently been ranked as the most loved programming language in the Stack Overflow surveys for several years, which piqued my curiosity.
At one point, I had a two-week vacation, and I decided to dedicate it to exploring Rust. I went through "The Rust Programming Language" book and most of the entry-level documentation. The more I delved into Rust, the more I realized how well the language resonated with what I wanted from my code.
I want performant code.
I want, you know, maintainable code. I liked the strong type system and the expressiveness that it gives you. And at the same time, I like how it just solves a lot of the foot guns that languages like C or C++ have. So that's how it all started.
I began by working on a database driver, my first significant project in Rust. It was a synchronous driver for a database called Exasol This was an open-source personal project, something I worked on in my free time to gain a solid understanding of Rust.
Completing this project was a great learning opportunity. Building something open-source, especially a library that others might use, makes you pay attention to details you might otherwise overlook.
Despite finishing the initial Exasol driver, I recognized there was room for improvement. When I eventually set out to rewrite the driver I was already far more familiar with Rust than when I wrote the first version. In fact, the sheer curiosity of how much better I could make it was one of the greatest motivations for the rewrite!
One fundamental difference that I wanted for the new version was making it asynchronous, since async I/O libraries are becoming increasingly popular due to their efficiency. Another one was the overall library API design. The first driver had quite an opinionated interface and I felt like that might seriously hinder the odds of someone using it.
As I was seeking inspiration from existing database libraries in Rust, I noticed that the SQLx database framework released version 0.7, which came with an overhaul of their public interfaces. While previously impossible, the framework now allowed writing entire custom drivers. This was great because SQLx is asynchronous by design and frameworks and ORMs are very common in the database world for an important reason: API consistency.
Seizing this chance, I rewrote the entire driver to be the first (and potentially only) third-party database driver for SQLx. And I am actually quite proud of how it turned out. While it may be a niche project, the beauty of open source lies in collaboration. We all contribute to building better tools together.
The world is built on open-source after all.
Throughout the years, I moved from one job to another, searching for a place where I truly fit in. Eventually, this journey led me to Exein.
What do I like about Exein? Well, a lot of things. Firstly, the people. Everyone here is incredibly nice and friendly, while still maintaining a professional attitude. My visit to Rome was especially memorable—it was the most heartfelt welcome I've ever received in my entire career.
I also appreciate that we are a small team. Having previously worked in large corporations, it’s refreshing to be in an environment where everyone knows each other and we've grown closer. Even though I work remotely, I never feel disconnected from the team. In previous jobs, I felt like just another number among thousands, but here, I interact regularly with the technical team and even other departments, making every interaction meaningful.
On the technical side, I love working on our product. Unlike many positions where you mostly maintain existing code, at Exein, I'm actually developing and improving our product. I get to build new features, refactor solutions, and create something from scratch. It's not just about fixing bugs or cleaning up code. Here, I'm continuously growing alongside the product, feeling like I'm building something significant rather than just patching things up.
Seven months might seem like a short time, but at Exein, it's flown by in a whirlwind of learning, achievement, and camaraderie. The supportive and collaborative environment here has truly fostered a sense of belonging. I can't wait to see what the future holds for both myself and the amazing product we're building together.
