From Curiosity to Systems: How Linux Changed the Way I Think About Development

When I first started exploring the world of programming, I was like most beginners—curious, enthusiastic, and deeply focused on writing code that worked. I wasn't thinking in terms of systems or operating environments. For me, development lived inside an IDE window and ended with a "Compilation Successful" message.

But then Linux happened. What started as a playful dive into the world of operating systems turned into a complete transformation in how I think about computers, software, and development itself.

The Initial Spark: All Keyboard, All the Time

I didn’t dual boot Linux out of necessity—I did it because I was excited by the idea of controlling my system entirely with the keyboard. I wanted to be fast, efficient, and in command. So I installed my first Linux distro and began exploring the terminal like it was a whole new universe.

To do it right, I enrolled in the Linux Essentials course by Cisco. That course gave me a foundational understanding, but it was really just the beginning. I wasn’t satisfied with just using Linux—I wanted to master it.

Distros, Bugs, and Breaking Stuff

Naturally, one distro wasn’t enough. I tried Ubuntu, Kali, Arch, Parrot OS, and Debian. Each had its own vibe and quirks. But with those came bugs—many of them caused by me. I wasn’t an expert then, and sometimes my installations created dependency loops, bootloader issues, or just flat-out refused to work.

I learned that breaking your system isn’t a setback—it’s a lesson. Each crash taught me something new about bootloaders, package managers, init systems, or kernel modules. I became that guy whose laptop was always in trouble—but only because I was always trying something new.

Eventually, I found my comfort zone in Arch Linux, and later in Garuda Linux with Sway, which I use now. Arch gave me the control and minimalism I craved, and it pushed me to learn how the system worked from the inside out.

Tiling Window Managers and the Art of Configuration

Once I had Arch, I couldn’t resist the next step: tiling window managers. I tried them all—i3, dwm, awesome, sway—and realized that configuring them was almost like writing your own desktop environment. Every keybinding, every bar, every widget—handcrafted. It was a hassle, sure, but it was also deeply satisfying. It taught me about dotfiles, configuration formats, X11 vs Wayland, and a lot of debugging.

The experience shifted my mindset. I stopped expecting things to "just work." Instead, I learned to make them work, to mold my environment to my needs.

Coding in the Terminal: A Different Kind of Discipline

I decided I didn’t want to leave the terminal even when I coded. So I began using Vim, experimenting with tmux, exploring terminal-based file managers, and even writing custom vim configurations to compile and run code without ever leaving the editor.

I also gave Neovim a shot, but at the time, it felt overwhelming—like too much power I wasn’t ready to wield. So I stuck with Vim for personal projects and used VS Code for web development, which I still do. But my long-term goal is clear: I want to completely shift from VS Code to Vim, and every week I get a little closer.

Breaking Bootloaders, Playing with Kernels

Linux also made me fearless. I’ve messed with GRUB boot files, experimented with custom kernels, switched themes, changed desktop environments, and configured so many different things that I’ve lost count. Each configuration taught me something deeper about the Linux system architecture, how the kernel communicates with hardware, how the system boots, and how the user experience is just a layer on top of all that machinery.

This wasn’t just customizing—it was learning by breaking and fixing. It taught me resilience, research skills, and attention to detail. These are qualities that directly improved my approach to development.

How Linux Changed My Developer Mindset

Before Linux, I saw development as a task: write the code, debug it, ship it. After Linux, I started seeing development as system building. Now, I think in layers:

• Is this code memory-efficient?

• How does it behave under different kernel schedulers?

• Will it work in a headless environment?

• Can I automate this with a script instead of relying on an app?

I learned to appreciate modularity, transparency, and the beauty of text-based configuration. I now value tools that are composable and flexible over tools that are just "easy." I’m more comfortable diving into logs, interpreting stack traces, and navigating environments that would have intimidated me before.

Most importantly, Linux taught me to ask why and not just how.

Final Thoughts: From Curiosity to Mastery (In Progress)

My Linux journey is still ongoing, but one thing is clear: it didn’t just change how I use a computer—it changed how I think as a developer. It gave me a deeper understanding of the systems beneath my code. It made me more confident, more experimental, and more disciplined.

I started out just wanting to use the keyboard more. What I got instead was a complete education in systems thinking, problem solving, and intentional development.

So if you're a developer—especially one who, like me, wants to understand everything—Linux isn’t just an operating system. It’s a philosophy, a teacher, and a path to deeper mastery.