At some point during this Linux journey, I looked at ubuntu-dev01 and thought:
“You know what this VM needs? Emotional damage.”
So naturally, I installed a C compiler.
A language old enough to remember when computers were beige and programmers openly hated users without pretending otherwise.
And honestly?
It feels weirdly refreshing.
Why C?
Because C believes suffering builds character.
Modern programming languages spend enormous amounts of effort protecting developers from mistakes.
C reacts to that entire philosophy like an angry grandfather yelling at a thermostat.
Null pointer?
Your fault.
Memory leak?
Also your fault.
Segmentation fault?
Excellent. Now suffer and grow as a person.
C does not hold your hand.
C barely acknowledges your existence.
It simply watches from a distance while you accidentally overwrite memory and destroy your own program like a raccoon rummaging through electrical wiring.
Linux and C Feel Suspiciously Natural Together
Using C on Linux feels correct in the same way using a cast iron pan feels correct.
Heavy.
Old.
Dangerous if mishandled.
Capable of surviving civilization itself.
The deeper you go, the more Linux starts making sense:
- processes,
- sockets,
- permissions,
- memory,
- threads,
- system calls,
- file descriptors.
Suddenly the operating system stops feeling magical.
You begin realizing Linux is actually very honest.
Brutal.
But honest.
When Windows breaks, it gives you a spinning circle and emotional confusion.
When Linux breaks, it practically points at the problem and says:
“You did this.”
Which, frankly, I respect.
Building ubuntu-dev01
Setting up the development environment itself is deceptively simple.
Almost suspiciously simple.
sudo apt update
sudo apt install build-essential gcc gdb make vim git -y
That single command installs:
- GCC compiler
- debugger
- build tools
- development libraries
- Git
- editor (I prefer nano versus Vim)
Basically everything needed to transform a peaceful Ubuntu VM into a machine dedicated entirely to compiler warnings and self-doubt.
The Ancient Programmer Ceremony
Every person learning C eventually performs the same ritual humanity has repeated for decades.
Compile and Run :
And there it is.
The tiny greeting that launched generations of programmers into careers filled with:
- caffeine,
- debugging,
- existential crises,
- and arguing online about text editors.
Beautiful.
The Modern Tech Industry Would Hate This
The funny thing is that learning C today almost feels rebellious.
Modern tech culture wants everything abstracted:
- low-code,
- no-code,
- AI-generated code,
- frameworks built on top of frameworks built on top of other frameworks held together by npm packages maintained by one exhausted guy in Nebraska.
Meanwhile C sits quietly in the corner like a retired mechanic holding a wrench.
No startup pitch.
No inspirational TED Talk.
No “thought leadership.”
Just:
“Did the code compile or not?”
Honestly, there is something deeply satisfying about that level of honesty.
The Humbling Experience of Compilation Errors
One thing nobody tells beginners:
The compiler becomes your new abusive life coach.
Forget one semicolon and GCC responds with a six-line error message that reads like ancient Latin discovered inside a cursed tomb.
Sometimes the problem is obvious.
Sometimes the compiler points to line 84 when the actual mistake happened on line 12 three hours ago.
And eventually you realize debugging is less about intelligence and more about slowly descending into madness with discipline.
Why This Still Matters
Underneath all the modern buzzwords, low-level computing still runs the world.
Servers.
Operating systems.
Embedded systems.
Networking infrastructure.
Critical utilities.
All quietly powered by ancient technologies nobody on LinkedIn brags about because there is no way to make memory allocation sound inspirational.
The internet itself is basically:
- old code,
- old protocols,
- duct tape,
- caffeine,
- and system administrators one inconvenience away from becoming supervillains.
People forget that.
Technology is not just shiny apps and startup founders wearing sneakers while talking about “reimagining human connection.”
Sometimes technology is just a tired person staring at logs at 2 AM because a process crashed for reasons known only to God and the kernel.
Final Thoughts
So yes.
ubuntu-dev01 is now officially a C development machine.
A place where:
- warnings become personal attacks,
- segmentation faults become spiritual lessons,
- and every successful compilation feels like surviving a small war.
And honestly, combining Linux and C programming feels dangerous, and (maybe) wildly impractical (and old-fashioned) for normal people (those who do not care about optimized code).