How a Simple Arch Linux Installation Made Me Accidentally Study Operating Systems

Prakhar Pandey — Thu, 29 May 2025 08:20:34 +0000

ME: "Let’s install Arch Linux – how hard can it be?"
ARCH: "You have 290GB free, but only 30GB is shrinkable."
Me: "...Wait, what?"

The Hiccup That Sparked a Journey
I recently attempted to install Arch Linux alongside my existing OS. I had around 290GB of free space, yet while trying to shrink the volume during partitioning, I hit an unexpected roadblock: only 30GB was available to shrink.

Like any curious dev, I asked why.

A quick search led me to the term memory fragmentation. What seemed like a minor partitioning issue turned out to be a deep concept rooted in how operating systems manage memory. This one error pushed me into a spiral of tutorials and docs. By the time I was done, I had unintentionally studied most of what an Operating Systems course would teach.

Key Concepts I Learned

1. Memory Fragmentation
I discovered there are two types:

External fragmentation: Free space exists but not contiguously, so large partitions can’t be created.

Internal fragmentation: Wasted space inside allocated memory blocks.

I used defragmentation tools to try and reorganize data on the disk—leading me to explore file systems, how files are stored, and how OSs manage space.

2. Paging and Segmentation
These are two methods of memory management:

Paging: Divides physical memory into fixed-size pages and virtual memory into frames.

Segmentation: Divides memory into variable-size segments based on logical divisions like code, data, stack.

Understanding how these systems reduce fragmentation helped me make sense of my disk issue.

3. Process Scheduling
From First-Come-First-Serve (FCFS) to Round Robin, I explored:

How the OS allocates CPU time to processes

Preemptive vs. non-preemptive scheduling

Why some processes feel sluggish when many are running (hello, multitasking limits)

4. Virtual Memory & Swapping
The magic of running more processes than your physical RAM can handle. Virtual memory tricks your system into believing it has more RAM by swapping pages in and out of disk. Understanding this helped me grasp:

Why my system slows under load

The impact of swap space

How Linux handles memory with vmstat, htop, and free

5. System Calls & Kernel Space
Every time a program reads a file or writes to disk, it uses system calls to ask the kernel to do it on its behalf. This led me to learn about:

User space vs. kernel space

How APIs wrap around syscalls (e.g., open(), read(), write())

6. File Systems and Mounting
While trying to manually create partitions and mount points, I learned:

Difference between ext4, FAT32, NTFS, Btrfs

What /mnt, /boot, and /home actually mean

How fstab works and what mounting a file system truly entails

From a Hiccup to a Deep Dive
What began as a technical problem became a full-blown Operating Systems crash course. And honestly? It was one of the most fun, frustrating, and rewarding debugging experiences I’ve ever had.

This experience reminded me why I love tech: every error is a learning opportunity in disguise.

Final Thoughts
If you're planning to install Arch Linux, be ready for surprises—but also for a learning journey. Whether you're a student or just curious, getting your hands dirty is often the best way to understand what's really going on under the hood.

Let’s Connect
If you’ve ever had a “simple” project turn into a major learning curve, I’d love to hear your story in the comments!

DEV Community: Prakhar Pandey

[Boost]