Linux Fundamentals: From Commands to Internals

Linux is everywhere.

It runs servers, cloud infrastructure, Android devices, routers, supercomputers, containers, embedded systems, and millions of development environments.

If you want to understand Linux deeply, learning commands like ls, cd, and systemctl is not enough. You need to understand what is happening underneath those commands.

This series starts from the foundation and gradually moves toward Linux internals.

Linux is very important to learn for all software engineering students because it is a powerful operating system environment for building, running, deploying, and automating applications.

What Exactly Is Linux?

The word "Linux" is used in several different ways, which often causes confusion.

Technically, Linux is a kernel. The kernel is the core software responsible for managing the computer's hardware and providing fundamental services to applications.

A simplified view of a Linux system looks like this:

+----------------------------------+
|          Applications            |
|  Browser | Editor | Web Server   |
+----------------------------------+
|        Libraries / Runtime       |
+----------------------------------+
|             Shell                |
|       bash | zsh | fish          |
+----------------------------------+
|          Linux Kernel             |
| Process | Memory | Filesystem    |
| Network | Drivers | Security     |
+----------------------------------+
|             Hardware             |
| CPU | RAM | Disk | Network Card  |
+----------------------------------+

The Linux kernel sits between applications and the hardware. When an application wants to perform an operation such as reading a file, allocating memory, or communicating over a network, it requests the kernel to perform that operation.

Linux Is a Kernel

One of the most important things to understand is that Linux itself is technically a kernel.

The kernel is responsible for managing important system resources such as:

• CPU
• Memory
• Processes
• Filesystems
• Networking
• Hardware devices
• Security
• System calls

For example, when you run a program:

./app

the Linux kernel is involved in creating and managing the process that runs the application.

When a program reads a file:

Application
	|
	v
System Call
	|
	v
Linux Kernel
	|
	v
Filesystem
	|
	v
Storage Device

This is why understanding Linux means understanding more than just terminal commands.

Linux vs. Linux Distribution

Another common source of confusion is the difference between Linux and a Linux distribution.

Linux is the kernel. A Linux distribution combines the Linux kernel with many other components required to create a complete operating system environment.

A simplified view is:

Linux Distribution
|
|-- Linux Kernel
|-- System Libraries
|-- GNU Utilities
|-- Shell
|-- Package Manager
|-- Services
|-- Desktop Environment
`-- Applications

Some popular Linux distributions are:

• Ubuntu
• Debian
• Fedora
• Arch Linux
• openSUSE
• Linux Mint
• Alpine Linux

Different distributions may use different package managers and default configurations.

For example, Ubuntu commonly uses:

sudo apt update
sudo apt install nginx

Fedora commonly uses:

sudo dnf install nginx

Even though the tools and configurations may differ, both systems use the Linux kernel.

Why Should Software Engineering Students Learn Linux?

Linux is very important for software engineering students. Modern software development is closely connected with:

• Servers
• Cloud computing
• Networking
• Databases
• Containers
• DevOps
• CI/CD
• Automation
• Cybersecurity
• Distributed systems
• Embedded systems

Many applications that we develop locally eventually run on Linux servers.

For example, you may develop an application on your laptop:

Developer Machine
	  |
	  | Git
	  v
   Repository
	  |
	  v
   CI/CD Pipeline
	  |
	  v
   Linux Server
	  |
	  v
Production Application

Understanding Linux makes it easier to understand what happens when your application is deployed to a production environment.

Linux Command Line

One of the most important ways to interact with Linux is through the command line. The command line allows us to communicate with the operating system using commands.

For example:

ls

lists files and directories.

cd /var/log

changes the current directory.

pwd

shows the current working directory.

mkdir project

creates a directory.

rm file.txt

removes a file.

These commands may look simple, but they are built on top of deeper operating system concepts. The important thing is not just memorizing commands. You should understand what happens when you execute them.

What Is a Shell?

A shell is a program that provides a command-line interface for interacting with the operating system.

Popular shells include:

• Bash
• Zsh
• Fish

For example:

ls -la

When you enter this command, the shell interprets your input and starts the appropriate program.

A simplified process looks like this:

You type a command
	   |
	   v
	 Shell
	   |
	   v
  Program starts
	   |
	   v
 Linux Kernel
	   |
	   v
	Hardware

The shell is therefore not the Linux kernel. It is a user-space program that provides an interface for interacting with the system.

User Space and Kernel Space

Linux separates normal applications from the kernel.

A simplified model looks like this:

+----------------------------------+
|           User Space             |
|                                  |
| Applications                     |
| Shell                            |
| Libraries                        |
| Web Servers                      |
| Databases                        |
+----------------------------------+
|          Kernel Space            |
|                                  |
| Process Management               |
| Memory Management                |
| Filesystems                      |
| Networking                       |
| Device Drivers                   |
+----------------------------------+
|            Hardware              |
+----------------------------------+

Applications normally run in user space. The kernel runs in a privileged environment called kernel space.

This separation provides protection. For example, one normal application should not be able to directly overwrite another application's memory.

System Calls

So how does an application communicate with the Linux kernel? The answer is system calls.

A system call is an interface through which a user-space program requests a service from the kernel.

Some common system calls include:

open()
read()
write()
close()
fork()
exec()
wait()
socket()

For example, when a program wants to read a file, it can request the kernel to perform the operation.

Conceptually:

Application
	|
	| read()
	v
Linux Kernel
	|
	v
Filesystem
	|
	v
Storage

System calls are one of the most important concepts for understanding Linux internals.

Processes

When you run a program, Linux creates a process to execute it.

For example:

python app.py

starts a Python process.

You can view running processes using:

ps

or:

ps aux

You can also use:

top

to monitor processes and system resources.

Every process has a Process ID, commonly called a PID.

PID     COMMAND
1       systemd
1200    nginx
1450    python
2010    bash

The Linux kernel manages these processes and determines how they share CPU resources.

The Linux Filesystem

Linux uses a hierarchical filesystem. The top-level directory is called the root directory:

/

A simplified Linux filesystem looks like this:

/
|-- bin
|-- boot
|-- dev
|-- etc
|-- home
|-- lib
|-- opt
|-- proc
|-- root
|-- tmp
|-- usr
`-- var

Some important directories include:

/home

Contains users' personal directories.

/home/student
/home/developer

/etc

Contains system and application configuration files.

/var

Contains variable data such as logs and application data.

/tmp

Contains temporary files.

/dev

Contains device files.

/proc

Provides information about running processes and the Linux kernel.

For example:

cat /proc/cpuinfo

can display CPU information.

Everything Is a File

A famous Unix/Linux concept is:

Everything is a file.

This does not literally mean that every object is a normal file stored on a disk. Instead, Linux provides file-like interfaces for interacting with many different resources.

For example:

/dev
/proc
/sys

provide access to different types of system resources.

You can explore devices using:

ls /dev

and inspect system information using:

ls /proc

This consistent interface is one of the powerful ideas inherited from Unix.

File Permissions

Linux provides a permission system to control access to files and directories.

Run:

ls -l

and you may see:

-rwxr-xr-- 1 user user 1024 Sep 10 10:30 script.sh

The permission section is:

-rwxr-xr--

It can be divided into:

Owner       Group       Others
rwx         r-x         r--

Where:

• r = read
• w = write
• x = execute

For example:

chmod +x script.sh

adds execute permission to the script.

Permissions are an important part of Linux security.

Linux Networking

Linux is heavily used for networking and server applications.

You can inspect network interfaces using:

ip addr

You can inspect listening network connections using:

ss -tuln

A web server may listen on ports such as:

80
443

For example:

Client
   |
   | HTTP/HTTPS
   v
Linux Server
   |
   v
Web Application

Understanding Linux networking is useful when working with:

• REST APIs
• Web servers
• Microservices
• Cloud applications
• Distributed systems
• Containers

Services and systemd

Modern Linux distributions commonly use systemd to manage system services.

For example:

systemctl status nginx

can show the current status of an Nginx service.

You can start a service using:

sudo systemctl start nginx

Stop it using:

sudo systemctl stop nginx

And enable it to start automatically during boot:

sudo systemctl enable nginx

Understanding services is important when deploying applications to Linux servers.

Linux and Software Development

Linux provides a powerful environment for software development.

A typical development environment might contain:

Linux
|
|-- Git
|-- GCC / Clang
|-- Python
|-- Node.js
|-- Java
|-- Docker
|-- Databases
`-- Build Tools

For example:

git clone <repository>
cd project
npm install
npm test
npm run build

These commands can be combined with shell scripts to automate development workflows. This is one of the reasons Linux is so useful for software engineers.

Linux and Cloud Computing

Linux plays a major role in modern cloud infrastructure.

When you deploy an application to a cloud platform, the application may eventually run inside a Linux-based virtual machine or container.

A simplified architecture could look like this:

User
 |
 v
Internet
 |
 v
Load Balancer
 |
 v
Linux Server
 |
 +---- Application
 |
 +---- Database
 |
 +---- Cache
 |
 `---- Logs

Understanding Linux helps developers troubleshoot applications running in production environments.

Linux and Containers

Linux is also fundamental to modern container technologies. Tools such as Docker use Linux kernel features to isolate processes and manage resources.

A simplified architecture looks like this:

+-----------------------------+
|        Container            |
|                             |
|      Application            |
+-----------------------------+
|        Linux Kernel         |
+-----------------------------+
|          Hardware           |
+-----------------------------+

Understanding processes, filesystems, networking, permissions, and isolation makes it easier to understand containers.

Linux and Automation

One of Linux's biggest strengths is automation. Instead of performing the same task manually, you can create shell scripts.

For example:

#!/bin/bash

echo "Starting application..."

git pull

npm install

npm test

npm run build

echo "Deployment completed!"

This simple idea becomes extremely powerful when combined with:

• CI/CD
• Git
• Docker
• Cloud platforms
• Monitoring
• Infrastructure automation

Linux is therefore not just an operating system for running applications. It is also a powerful platform for automating software development and deployment.

Linux Is More Than Commands

It is easy to think of Linux as a collection of commands:

ls
cd
cp
mv
rm
grep
find
ps
kill
systemctl

But memorizing commands is only the beginning.

A deeper understanding comes from asking questions like:

• What is a process?
• How does a program start?
• How does Linux allocate memory?
• What happens when a program opens a file?
• How does one process communicate with another?
• How does networking work?
• What is a system call?
• How does the filesystem work?
• How does Linux manage permissions?
• How does the kernel communicate with hardware?
• How are services started?
• What happens when a process crashes?

These questions take us from Linux usage to Linux understanding.

The Road Ahead

In this series, we will gradually move from basic Linux usage toward Linux internals.

The journey will look something like this:

Linux Basics
	|
	v
Command Line
	|
	v
Filesystem
	|
	v
Permissions
	|
	v
Processes
	|
	v
Memory Management
	|
	v
System Calls
	|
	v
File Descriptors
	|
	v
Networking
	|
	v
Inter-Process Communication
	|
	v
Kernel Internals
	|
	v
Containers & Virtualization

The goal is not simply to memorize commands. The goal is to understand why those commands work, what happens underneath them, and how Linux manages the system as a whole.

Final Thoughts

Linux is an important technology for anyone who wants to build a strong foundation in software engineering.

You don't need to become a Linux kernel developer to benefit from learning Linux. Even understanding the basics of the following can improve your understanding of how software actually runs:

• Processes
• Memory
• Filesystems
• Permissions
• Networking
• System calls
• Shells
• Services

So don't just learn:

ls
cd
systemctl

Ask yourself:

What happens behind this command?

That question is where the real Linux learning begins.

This series is about going beyond the commands and understanding what is happening underneath.

Let's Learn Linux Internals

In the next part, we will start with the Linux filesystem and basic command-line concepts, then gradually move deeper into processes, memory, system calls, networking, and kernel internals.

Learn the command.

Understand the concept.

Explore what happens underneath.