From WSL to Linux: Two Years of Breaking Things and Learning How Computers Work

Two years ago, Linux wasn't something I planned to learn. I wasn't looking for a new operating system, trying to become a Linux enthusiast, or searching for ways to customize my desktop. My curiosity started from something much simpler.

While watching programming tutorials on YouTube, I noticed that many experienced developers spent most of their time inside a terminal. They weren't just clicking through graphical menus all the time. They were also navigating projects, managing files, running servers, installing dependencies and debugging issues with commands.

At first, it looked intimidating. Then it became fascinating.

The Beginning: WSL and Virtual Machines

Like many students, I wasn't ready to replace my primary operating system immediately. My first experience with Linux came through Windows Subsystem for Linux (WSL). It gave me access to a Linux environment without leaving Windows. Soon after, I started experimenting with Linux distributions inside Oracle VirtualBox.

This phase taught me some fundamental concepts:

• Navigating directories
• Working with the Linux filesystem
• Installing software through package managers
• Understanding permissions
• Using shell commands effectively

At that point, Linux was simply a playground for experimentation. I didn't realize it would eventually become my primary development environment.

The Decision to Dual Boot

As my projects grew larger, virtual machines started feeling restrictive. I wanted:

• Better performance
• Direct hardware access
• A more authentic Linux experience

That's when I decided to dual boot Linux alongside Windows. Looking back, this was one of the most valuable technical decisions I made during my development journey. Linux forced me to understand my machine rather than simply use it.

What Linux Actually Changed For Me

Linux didn't make me a better developer overnight.

What it changed was the way I approached problems.

Before Linux:

• I searched for solutions.
• I followed tutorials.
• I relied heavily on graphical interfaces.

After Linux:

• I read documentation.
• I investigated root causes.
• I became comfortable troubleshooting systems.
• I understood what was happening behind the scenes.

The biggest lesson wasn't learning commands.

It was learning how computers actually work.

Why Linux Feels Different

The biggest difference wasn't performance. It was visibility. Modern operating systems often hide complexity behind graphical interfaces. Linux does the opposite. It encourages curiosity.

When something breaks, you're not presented with a generic error dialog. Instead, you investigate:

• Logs
• Processes
• Permissions
• Services
• Configuration files

Over time, you stop memorizing commands and start understanding systems.

Linux didn't teach me commands. It taught me how computers actually work.

The Problems That Taught Me the Most

Most of my learning happened when things went wrong.

Mounting and Disk Issues

One of the first major problems I encountered involved disk mounting. Partitions weren't behaving as expected. Drives sometimes failed to appear correctly.

Understanding the solution required learning concepts such as:

• Filesystems
• Partitions
• Mount points
• Disk utilities
• Linux storage architecture

Before Linux, I had never paid much attention to how storage actually worked. Afterwards, I understood what was happening behind the scenes.

Accidentally Breaking GNOME

One of my most memorable mistakes happened while experimenting with packages and desktop configurations. I accidentally removed components required by GNOME. After rebooting, I discovered that my graphical desktop environment was gone. Only the terminal remained.

For a moment, it felt like I had completely destroyed my system. But instead of reinstalling Linux, I decided to fix it. Using only:

• Terminal commands
• Package managers
• Documentation
• Community forums

I eventually restored the entire desktop environment. That experience changed my confidence completely. I realized Linux wasn't fragile. It was recoverable.

Why Developers Should Learn Linux

Many beginners ask:

Do I need Linux to become a software developer?

The answer is no. You can build excellent software on Windows, macOS, or Linux. However, Linux offers a unique advantage. It exposes you to the environment where much of modern software runs.

Whether you're working with:

• Cloud servers
• Docker containers
• CI/CD pipelines
• Kubernetes clusters
• Web hosting infrastructure

Linux is everywhere. Learning Linux doesn't just teach an operating system. It teaches the ecosystem powering modern software.

Where Linux Shows Up In Real Development

One thing I didn't realize when I started learning Linux was how frequently it appears in modern software engineering.

Today Linux powers:

• Cloud servers
• Docker containers
• CI/CD pipelines
• Web hosting infrastructure
• Kubernetes clusters
• Backend production systems

Even if you never use Linux as your primary operating system, understanding Linux environments makes you a stronger developer.

Many of the tools used in professional software engineering are designed with Linux-first workflows in mind.

The Terminal Is Not the Goal

Many people associate Linux with terminal commands. That's only a small part of the story. The real value lies in understanding concepts such as:

• Processes
• Networking
• Permissions
• Package management
• System administration
• File systems

These skills transfer directly into software engineering, DevOps, cloud computing, and backend development. The terminal is simply the interface. The understanding behind it is what matters.

10 Linux Commands I Use Almost Every Day

pwd

Shows the current working directory.

ls

Lists files and folders.

cd

Navigate between directories.

cat

Read file contents directly from the terminal.

grep

Search text inside files.

find

Locate files and folders quickly.

chmod

Manage file permissions.

systemctl

Control system services.

git

Version control and source management.

docker

Manage containers and development environments.

I don't use these commands because they're "Linux commands."

I use them because they save time and make development workflows more efficient.

Two Years Later

Today, Linux is my primary development environment. Most of my projects are built, tested, and deployed from Linux.

The terminal that once looked intimidating now feels natural. Not because I memorized hundreds of commands. But because years of experimentation, troubleshooting, and learning gradually built familiarity.

I still encounter problems. I still read documentation. I still learn something new regularly. That's part of the experience.

Advice for Beginners

If you're curious about Linux, you don't need to switch immediately. Start small. Try:

1. WSL
2. A Virtual Machine
3. A Live USB
4. Dual Boot (when comfortable)

Don't worry about mastering every command. Focus on understanding:

• How your computer works
• How software is installed
• How services run
• How systems communicate

The goal isn't becoming a Linux expert overnight. The goal is becoming a better engineer.

Should You Learn Linux?

If you're interested in:

• Web Development
• Backend Development
• Cloud Computing
• DevOps
• Cybersecurity
• Open Source

then Linux is worth exploring.

You don't need to install it immediately.

Start with:

1. WSL
2. Virtual Machines
3. Live USB environments
4. Dual Boot when comfortable

Focus on learning concepts rather than memorizing commands.

The goal isn't becoming a Linux expert.

The goal is becoming a more capable engineer.

Final Thoughts

If you're curious about Linux, don't be afraid to break things.

Some of the most valuable lessons I've learned came from systems that stopped working, configurations that failed, and mistakes that forced me to understand what was happening beneath the surface.

Linux isn't just an operating system.

For many developers, it's one of the best learning environments available.