If you're wondering what a truck driver is doing on a programming blog... or perhaps the other way around. :-)

...that's a perfectly fair question. 😁

I'm a truck driver, and as I write these words, I'm probably somewhere on the road in Europe. But programming has been one of my longest-running passions.

The story, however, doesn't start with the truck.

I used to be a programmer. Then I became a truck driver.

In 2017, I gave up programming as a profession.

I never gave up programming itself.

I had reached a point where I couldn't stand turning something I loved into a daily obligation anymore. So I did something that may have seemed rather strange at the time: I walked away from professional programming and got behind the wheel of a truck.

And I don't regret it.

As it turns out, driving a truck across Europe can be a remarkably relaxing way to spend your working life. 😁

I saw places, met people, gathered experiences and, perhaps most importantly, I got back the freedom to program because I wanted to, not because I had to.

There is a very popular idea that you should turn your passion into your profession.

I don't believe that anymore.

Sometimes, when you turn something you love into an obligation, you risk killing the very thing you loved in the first place.

For me, programming stayed beautiful precisely because I no longer had to make a living from it.

And then I came back.

Over the past few years, I gradually started programming more and more again.

At first, mostly out of curiosity. Then projects started appearing. Then came real problems that needed solving. And before I knew it, I was seriously learning again.

I rediscovered Python. I started working with FastAPI, Docker, Linux, databases and all sorts of technologies that I now use in my projects.

Some things clicked quickly.

Others took me months to understand.

And that's where the important part of this blog begins.

Because when you're learning on your own, there are moments when you look at a piece of code and think:

"Okay... but why the hell is it done this way?"

Documentation often tells you how.

Tutorials show you what to write.

But much less often do you find someone willing to explain why.

That's what I want to try to do here.

I'm not here to teach you just Python

Python is where we're going to start.

But the goal of this blog isn't to turn anyone into a "Python programmer".

Languages change.

Today we're writing Python. Tomorrow we might be writing Go, Rust, C, or something else entirely.

Programming remains.

I want us to learn how to break a problem down, understand it, find a solution and only then choose the tools we need to build it.

I want us to understand what happens behind the code instead of memorizing recipes.

Because once you understand programming, learning a new language becomes much easier. It's simply another language in which to express the same ideas.

Simplicity is the ultimate sophistication

There is a quote attributed to Leonardo da Vinci that has stayed with me for several years:

"Simplicity is the ultimate sophistication."

I have no idea what programming language Leonardo would have chosen if he were alive today. 😁

But I do know that when I rediscovered Python, I found in it something that resonated deeply with that idea.

Not because Python is a simplistic language.

Quite the opposite.

It is because Python can express complex ideas in a form that can almost read like a story.

And its indentation, which may initially feel like a constraint, eventually gives the code an extraordinary sense of order.

Simplicity doesn't mean doing less.

It means removing everything that isn't necessary.

Why this blog?

Camionagiul.club started with a completely different idea.

Originally, I wanted to build a hub for truck drivers — a place where I could gather useful information and tools.

Along the way, things changed.

I decided to keep the domain and turn it into a place where I can talk about programming, Linux, technology and the projects I'm building.

And after learning so many things over the past year, I figured it would be a shame to keep all of that knowledge to myself.

So I'm putting it here.

Who am I writing for?

First and foremost, I'm writing for the person who is right now where I was when I started learning again.

Maybe you know a little Python.

Maybe you've written a few programs.

Maybe you've heard of Docker, FastAPI, Git, Linux and databases, but you're still not quite sure how all those pieces fit together.

Or maybe you know absolutely nothing.

That's perfectly fine.

I don't want to assume that you already know the things I'm trying to explain.

I don't want to throw complicated terminology at you just to make myself sound smarter.

And most of all, I don't want to tell you:

"It's simple."

Because if you're asking the question, then it isn't simple for you yet.

So we'll break it down, piece by piece.

We build real things

One of the reasons I decided to do this is that I don't want us building laboratory applications that exist only for the sake of a tutorial.

We're going to build things that actually exist and actually work.

The very platform you're reading these words on was built by me.

It has a theme system, plugins, translations, a newsletter, a sitemap, notifications and plenty of other things that we'll be able to take apart, piece by piece, as we go.

That means that when we eventually discuss a particular solution, we won't be talking about some made-up example from a tutorial.

We'll be talking about real code.

And perhaps more importantly, we'll talk about the mistakes we made along the way.

Because real software isn't born perfect.

It is built, broken, fixed, simplified and rebuilt.

The journey starts here

I don't pretend to know everything.

Not even close.

And I'll probably keep learning new things for as long as I still feel like writing code.

Maybe one day we'll talk about Rust here.

Maybe Go.

Maybe something that doesn't even exist yet.

But if you've ended up here because you want to learn programming, then I invite you to take the journey with me.

Don't memorize.

Understand.

Don't look for the perfect language.

Learn how to think.

And don't be afraid to start from zero.

Because every programmer was once a beginner who didn't understand a damn thing.

I'm still one.

I just happen to have a few more kilometers under my belt. 🚛

And a few more lines of code behind me.

Welcome to camionagiul.club.