‍

What I Learned After Building the Same Project in Both

‍

‍

There was a moment when the way I look at programming quietly changed.

‍

It did not come from a new tool or a trending framework. It happened during a normal workday, somewhere between finishing a task and starting another one, when I asked myself a question that felt almost too simple.

‍

How long did it actually take me to build this?

‍

Not how fast it runs. Not how efficient it is.

‍

Just how long it took me, as a person, to go from idea to something real.

‍

And that question stayed in my head longer than I expected.

‍

‍

‍

‍

The thing benchmarks never show

If you search for comparisons between Rust and Go, you will see clean numbers everywhere. Performance charts, memory usage, speed tests.

‍

Rust is faster. Go is easier. Rust is safer. Go is quicker to ship.

‍

All of that is true in its own way. But none of it explains what it feels like to sit down and build something from scratch.

‍

Because real work is not done in perfect conditions. It happens when you are tired, when you are distracted, when you are trying to fix something that should have worked an hour ago.

‍

That is where time becomes something different.

‍

Not technical. Personal.

‍

‍

I decided to test something simple

Instead of reading another comparison, I decided to try it myself.

‍

I built two small tools.

‍

One in Go.

‍

One in Rust.

‍

Same idea. Same level of complexity. No pressure to make them perfect. I just wanted to see how the process feels from beginning to end.

‍

Not how fast the code runs.

‍

How fast I move while writing it.

‍

‍

The first days felt very different

With Go, things started moving almost immediately.

‍

Within a few days, I already had something working. It was not polished, but it existed. I could run it, test it, change it without thinking too much. The structure felt natural. I did not have to fight the language to move forward.

‍

It felt light.

‍

Rust gave me a completely different experience.

‍

From the first lines, I had to slow down. Every detail mattered. Types, ownership, rules that did not allow shortcuts. It was not just coding, it was constant thinking.

‍

At moments, it felt like the language was holding me back.

‍

And honestly, sometimes it was frustrating.

‍

‍

Then something unexpected happened

After some time, the frustration started to change.

‍

The same strict rules that slowed me down at the beginning started to make sense. Errors became clearer. Problems were caught earlier. I was fixing things before they even had a chance to break.

‍

The process was still slower than Go.

‍

But it felt more stable.

‍

Instead of moving fast and fixing later, I was moving carefully and fixing less.

‍

‍

Speed at the start is not the whole story

If I only measure how quickly I can get something running, Go clearly wins.

‍

There is no doubt about that. It lets you move fast without overthinking every step. You write code, you run it, you improve it as you go.

‍

But development does not end when something starts working.

‍

That is where the difference becomes more interesting.

‍

In the Go project, as I added more features, I noticed small issues appearing. Nothing serious, but enough to slow me down later. Debugging, adjusting, revisiting decisions.

‍

In the Rust project, progress was slower in the beginning, but later it felt more controlled. Fewer surprises. Fewer moments where I had to stop everything and fix something unexpected.

‍

It felt like choosing when to deal with problems.

‍

Now or later.

‍

‍

The part that is hard to explain

There is something else that influenced my time more than I expected.

‍

Mental effort.

‍

Go feels easy to carry. I can read the code quickly, understand it, and continue without feeling tired. It fits well when I have many tasks and not enough time.

‍

Rust is heavier. It asks for attention. It forces me to think before I write, not after. At first, that feels exhausting.

‍

But over time, that effort turns into confidence.

‍

Not fast confidence, but quiet confidence.

‍

‍

So which one actually took longer

The honest answer is not as simple as I thought.

‍

Go helped me build something usable much faster. That part is clear.

‍

Rust took more time in the beginning. More thinking. More stopping and understanding.

‍

But when I look at the full process, including fixing, improving, and making things stable, the difference is not only about speed.

‍

‍

What changed for me

After this small experiment, I stopped asking which language is better.

‍

That question does not really help.

‍

Instead, I started asking something more practical.

‍

When do I want to spend my time?

‍

Do I want to move quickly, accept that I will fix things later, and keep momentum?

‍

Or do I want to slow down early, think deeper, and avoid problems before they appear?

‍

Both choices make sense.

‍

But they create very different experiences.

‍

‍

The thought that stayed with me

I went back to that simple question again.

‍

How long did it actually take me to build this?

‍

And I realized it is not just about hours or days.

‍

It is about how I feel during those hours. How often I get stuck. How confident I am when I finish.

‍

Rust and Go are not just tools with different performance.

‍

They change how time feels while you are building.

‍

And once you notice that, you stop looking at benchmarks first.

‍

You start paying attention to your own experience instead.

‍

Aram Andrasyan | Web Development Expert & Software Engineer

‍