Why Linux?

September 23, 2026 • 12 min read

Linux · CLI · DevOps · SRE · Cloud · Shell Scripting · Containers · Docker · Kubernetes

Linux is the de facto platform for modern software infrastructure. It underpins over 80% of public cloud workloads and 96% of the top million web servers. In practice, I use Linux because of its powerful command-line interface (CLI) streamlined for development. Its mature toolchains and support for containers/virtualization significantly boost productivity.

For developers, learning Linux means mastering scripting and automation (cron, shell scripts), reliable debugging/profiling tools (strace, perf), and secure practices (kernel hardening, firewalls).

From a career perspective, Linux skills are highly valued. DevOps/SRE roles, cloud-native development, and data center operations all presuppose comfort with Linux systems. Major cloud providers (AWS, Azure, GCP) default to Linux images for VMs and containers (often Ubuntu, Debian, CentOS/RHEL, or specialized images), partly because Linux avoids proprietary license costs and offers optimized performance. We present a table comparing default OS options across providers below.

Why I Use Linux

My primary reason for using Linux is the amount of clutter I can eliminate from my workflow. In my experience, Windows introduces more background services and system-level overhead into my development workflow than I want to deal with. For software development, where I frequently switch between terminals, documentation, browsers, containers, and other tools, this overhead can become noticeable.

Linux provides a more focused environment where I have greater control over what runs on my system, allowing more of the available resources to be dedicated to the work itself. Apart from that, using a modern Tiling Window Manager (TWM) also allows you to set up the workflow according to your liking.

The customizability aspect of Linux isn’t about using some colorful wallpapers and styling decorations. It’s about optimizing how you use your machine more efficiently and automating redundant tasks using scripting.

Using a modern TWM like Hyprland, Sway, etc. provides a more superior experience than simple Alt-Tab on Windows. Unfortunately, I won’t discuss ricing or my customizations any further as it’s not the focus of this article.

In my experience as a developer, Linux’s design greatly simplifies software creation and deployment. Linux distributions (I use Arch, but for simplicity I’ll be using Ubuntu’s package manager rather than Pacman or AUR helpers) are fully open-source, giving access to source code and enabling deep customization.

Core tools like the Bash shell, GNU coreutils, and editors (I use Neovim) run natively on Linux, giving immediate scripting and text-processing capability.

The intuitive pipeline of Unix-like shells (pipes, redirection) allows combining tools (grep, awk, sed) to automate actions. Indeed, Linux’s GNU userland is built on decades of Unix heritage (Bash, coreutils, libc). This rich shell environment is far more powerful than what traditional GUIs alone offer.

Because everything on Linux is a file or process, I can script and automate virtually all system tasks. Package managers (APT for Debian/Ubuntu, Pacman/Yay/Paru for Arch, etc.) provide one-stop installation and updates of software dependencies.

In practice, I can install a C compiler, Python, Docker, or any library with a single command:

sudo apt install build-essential python3 docker.io

Whereas on other OSes setup is often more tedious and time taking.

Overall, Linux gives me granular control: I can inspect system behavior (via /proc, dmesg, journalctl), tune performance (using tools like perf, htop, strace), and secure the environment (firewall rules, SELinux/AppArmor profiles) in ways rarely available on non-Unix platforms.

This flexibility “makes the bigger tools stop feeling confusing,” as one expert notes: because most cloud and container orchestration runs on Linux, understanding the OS fundamentals demystifies higher-level technologies.

Developer Productivity

Tooling and Automation

Linux is famed for its tool-rich environment. The command line interface (CLI) is central: shells like Bash and Zsh enable complex one-liners and scripts.

For example, a simple Bash script can loop over files and perform builds or tests:

#!/bin/bash

for src in src/*.c; do
  gcc -O2 -o bin/$(basename "$src" .c) "$src"
done

This level of automation (batch compilation, log processing, backups) is ingrained in Linux workflows.

Tools like cron for scheduled tasks, expect or ansible for scripted deployments, and editors (vim, emacs, nano) work seamlessly in Linux, often launched or integrated via the CLI.

Containers and Virtualization

Modern development heavily relies on Docker/Kubernetes, which natively use Linux kernel features (namespaces and cgroups).

The typical Docker architecture on Linux has a daemon that manages container images and running containers on the host OS.

Because containers run on Linux hosts, familiarity with Linux is essential. In fact, when using Docker on Windows or macOS, a hidden Linux VM is used under the hood.

Kubernetes and Docker documentation assume a Linux-like environment for file paths and networking.

Package Management

Linux distros maintain vast repositories. This means any developer library or tool is typically just one command away.

For instance, on Ubuntu one might do:

sudo apt update && sudo apt install -y python3-pip git

These package systems resolve dependencies automatically.

By contrast, on Windows or macOS, many tools must be downloaded manually or installed via separate managers (e.g. Homebrew, Chocolatey) that are not as universally standard.

Scripting and Automation

Linux shells were made for scripting. In DevOps or data pipelines, Bash and utilities like curl, sed, jq become scripting building blocks.

For example, to deploy code I might script a sequence:

git pull
npm install
sudo systemctl restart myapp.service

The ability to embed such commands in version-controlled scripts means infrastructure can be fully automated (Infrastructure as Code).

In contrast, Windows batch scripting or PowerShell have improved but traditionally lack the ubiquity and many of the small GNU tool conveniences Linux provides.

Security and Permissions

Linux’s permission model (users/groups, chmod, SELinux) is transparent and scriptable. I can set strict file permissions or network rules (iptables/nftables) with simple commands.

Patching is straightforward:

sudo apt upgrade

This quickly applies OS and package updates.

This continual patchability (and the open-source model) aids security. Many references emphasize that Linux distributions receive “continuous patches and updates to improve security”, making them reliable for running sensitive workloads.

Performance Profiling

Linux provides low-level tools (perf, ftrace, gdb, strace, valgrind) for diagnosing CPU usage, I/O bottlenecks, or memory issues.

For example:

perf stat ./myprogram

This yields detailed CPU cycle and cache-miss metrics.

These tools are part of the Linux ecosystem and crucial for performance tuning. By contrast, similar profiling on Windows often requires buying third-party tools or using slower alternatives.

The Hidden Complexity of Development Setup

I am constantly interacting with juniors at my university as their Teaching Assistant. One thing many freshmen don’t realize when they start programming is how much of their development environment is actually being configured behind the scenes.

You install an IDE, download a compiler, install a programming language, and start writing code without necessarily thinking about how the operating system knows where those tools are or how different programs interact with one another.

For example, when using Visual Studio for C++ development, I often see students create multiple .cpp files, each containing its own main() function.

When the project produces a linker error, they sometimes resort to commenting out the code they aren’t currently using. They don’t necessarily understand that Visual Studio is compiling the source files together and then linking them into a single executable, which cannot have multiple definitions of main().

This isn’t their fault; they haven’t yet had to understand how the build and linking process works.

A good example is the PATH environment variable.

At a basic level, PATH is a list of directories that the shell searches when you enter a command. If the executable for a compiler is located in one of those directories, you can simply type gcc or python from any directory instead of specifying the complete path to the executable.

Linux makes this concept particularly transparent.

You can inspect your current PATH with:

echo $PATH

Temporarily add a directory with:

export PATH="$PATH:/path/to/program"

Or add the configuration to your shell startup file, such as .bashrc or .zshrc, to make it persistent.

The mechanism is simple, visible, and easy to automate.

Windows provides the same fundamental concept through environment variables, but configuring them can feel considerably less direct, particularly for beginners.

You often have to navigate through system settings to locate the environment-variable configuration, modify the Path variable, add the required directory, and then restart the relevant terminal or application before the change is recognized.

Modern Windows has improved significantly with tools such as winget, PowerShell, Scoop, and Chocolatey, so it would be inaccurate to say that Windows cannot provide a good development environment.

The difference is that Linux exposes these mechanisms as a natural part of the command-line workflow, whereas Windows often presents them through a combination of GUI configuration and separate tooling.

This is one of the reasons the Linux development experience becomes valuable once you move beyond introductory programming.

Installing a compiler, exposing it through PATH, switching between toolchains, installing dependencies, and reproducing the same environment on another machine can all be handled through commands and configuration files.

Instead of treating development setup as a sequence of GUI configuration steps, Linux encourages you to treat your development environment itself as something that can be inspected, configured, scripted, and reproduced.

Career Advantage: DevOps, SRE, Cloud Roles

From a career standpoint, Linux proficiency is a strong asset. The majority of server infrastructure (web servers, databases, CI/CD pipelines) runs on Linux.

Organizations hiring for DevOps and Site Reliability Engineering almost invariably list “Linux skills” as prerequisites.

Cloud-native roles expect familiarity with Linux because all major cloud services (containers, serverless runtimes, orchestration) are built on Linux.

Even mobile/backend developers benefit: Android is Linux-based (over 70% of smartphones use Android), and many cloud databases and frameworks assume a Linux environment.

Even macOS is UNIX based, which is a precursor to Linux.

Certifications and courses reflect this demand. The Linux Foundation and cloud providers offer Linux administration and security training as part of DevOps certification tracks.

Anecdotally, senior developers often attribute promotions to Linux expertise: understanding SSH, systemd, and network troubleshooting makes you more effective in on-call rotations or performance tuning.

In sum, knowing Linux opens doors to roles in DevOps/SRE, cloud engineering, cybersecurity, and big data analysis all expect Linux fluency.

Tech employers often state that Linux knowledge is more important than any specific programming language, because system-level understanding underpins reliable deployment and scalability.

Anyways, now we have agents smart enough to write the code, but Linux is where to run and scale this code.

Linux on Cloud

Major cloud providers offer a wide range of Linux distributions as virtual machine images.

AWS

On AWS EC2, commonly available options include:

Amazon Linux 2/2023
Ubuntu
RHEL
SUSE
Debian

Amazon Linux is provided at no additional charge, so users primarily pay for the EC2 compute resources, while RHEL and SUSE images may include additional licensing costs through AWS Marketplace.

Microsoft Azure

On Microsoft Azure, users can deploy distributions such as:

Ubuntu LTS
Red Hat
SUSE
Debian
CentOS

Most standard Linux images do not incur a separate operating-system license fee, with costs primarily associated with the VM’s compute resources, although some images may include additional paid support.

Windows VMs, in contrast, generally include additional Microsoft licensing costs.

Google Cloud

Similarly, Google Cloud provides Linux images including:

Debian
Ubuntu
Container-Optimized OS
Red Hat
SUSE

through Compute Engine.

Standard distributions such as Debian, Ubuntu, and Container-Optimized OS generally do not carry a separate OS licensing charge; users primarily pay for the underlying compute and other cloud resources.

Windows instances incur additional licensing costs.

According to AWS, Amazon Linux 2 is “provided at no additional charge,” with AWS billing primarily for the underlying instance usage.

Azure similarly supports distributions such as Ubuntu, Red Hat, SUSE, and other popular Linux distributions, while Google Cloud provides Debian, Ubuntu, and Container-Optimized OS images as part of its Compute Engine ecosystem.

In practice, this means developers on AWS, Azure, and GCP can often deploy Linux servers at relatively low cost through free-tier allowances or promotional credits, while Windows instances generally include additional licensing costs.

More importantly, Linux’s ubiquity across cloud infrastructure means that learning Linux directly translates into greater familiarity with the environments used for modern software deployment, DevOps, cloud engineering, and backend development.

Comparisons to Other OSes

Compared to Windows or macOS, Linux differs significantly.

Where Windows is closed-source and GUI-centric, Linux provides a transparent OS with source access.

macOS shares Unix heritage (Darwin) and has a Bash/Zsh shell, but Linux offers a wider diversity of distros and server-oriented tools.

For instance, macOS users often install Homebrew for packages, whereas Linux has built-in apt/yum with massive free repos.

On performance, Linux generally uses fewer resources (important on servers) and supports a broader range of hardware (ARM, x86, embedded devices).

Security models differ too: many industries rely on Linux firewalls, SELinux/AppArmor, and trusted repository updates.

Debugging on Linux has the advantage of established open-source tools and community support; e.g., every libc/glibc bug is publicly visible and patched rapidly.

In summary, while Windows is dominant on desktops (and valuable in its domain), and macOS is strong for GUI/Apple ecosystem development, Linux’s flexibility, transparency, and ubiquity in cloud/server contexts make it an indispensable platform for backend, cloud, and systems development.

So any programmer should at least try to learn it.