Introduction

Hello, world!

Before you dive in, let me explain why Ultimate Rust was built and what it means

Who I Am

My name is Richard Alves. When I started programming, I was one of those developers who always want to make their code as optimized as possible. Solving things in the most performant way possible, the most secure way possible. I'd rather take longer to build something while already thinking about its future scalability than build fast just to say I did.

I know that's not exactly a virtue, but it's what led me to discover Rust.

The Discovery

I remember searching for something like "best language for x thing" and hearing about Go and Rust. I chose to try Go first. After having dealt with more "sloppy" languages like PHP, C, Python, and JavaScript, I thought it was incredible! I fell in love right away! How could a language not even compile if I declare a variable but don't use it? It seemed like the perfect language for a perfectionist like me.

Then I went and tried Rust too. The code looked a lot harder to me, but everywhere I looked, people said it was more performant. It was the cheese luring someone like me in. It was obviously only a matter of time before I tried it.

I fell in love right away too, and on a whole other level. From that moment on, I became a Rust fanatic. There are people who are in love with places, there are people who are in love with other people, but me... I fell in love with Rust.

Rust: The Perfect Language?

Over time, I started realizing that Rust wasn't just a faster, safer, or stricter language, like I'd seen everywhere I researched. It was a completely new way of thinking while writing code. A way of writing code that doesn't let you hack things together, doesn't let you close your eyes to mistakes details that, sooner or later, would blow up in your face in any other language.

Suddenly, I wasn't "just programming" anymore. I was writing code that couldn't break silently, that gave me guarantees I didn't even know I needed. Nothing like "it's working and I don't even know how" or worse, "it's NOT working and I don't even know how."

The feeling of compiling something in Rust is like turning in an assignment that went through an army of teachers: nothing loose comes out of there, nothing improvised, nothing "I'll fix it later."

It might sound strange to say this, especially about a programming language, but it even changes the way you think while you program.

You start seeing every variable in your code as something alive. Every reference as a promise. Every borrow checker error (Rust's compiler) as a teacher saying: "Hey, you can do better. You know you can do better."

It's also strange to say this, but Rust will teach you discipline. At least it taught me.

It taught me to treat memory with respect. It taught me that performance isn't a detail, it's my responsibility. And, above all, it taught me that writing a program is much more than stringing lines of code together. It's building something another person will read, understand, trust, and expand.

And the more I learned, the more I noticed an uncomfortable truth: if I could rewrite everything I'd built in the past in Rust, I would. Not out of vanity, but because Rust awakens a standard of excellence; it makes the product other people will use better.

Rust isn't just a language. It's a commitment.

The Rough Journey

But my passion for Rust didn't make learning it easy. Quite the opposite.

When I decided to dive headfirst into Rust, I ran into plenty of frustrating obstacles.

• The first was that materials in Portuguese were scarce, and the ones that did exist were mostly of very low quality, way too superficial, or simply badly done machine translations that confused more than they taught.

• So I turned to content in English. And there came the second problem: practically every material about Rust, even the official Rust Book itself, assumed I already had solid programming experience. They required knowing intermediate or advanced concepts before even starting to actually learn Rust. They recommended Rust as a "second language."

Even though I'd already had some contact with programming, I had never built a project complex enough to feel like I met those requirements. I was stuck between being "too much of a beginner" for the existing resources and "too experienced" to give up.

I had to use several resources at the same time: the Rust Book itself (which I recommend to everyone), Udemy courses, YouTube videos, and AIs to explain things to me and make the explanations more approachable and adapted to someone without complete experience. It was a fragmented, exhausting, and often confusing process.

INFO

Continues in the next section, about the project.