I explored Linux for the first time and here’s what I discovered

I explored Linux for the first time today. Instead of focusing on commands, I tried to understand how Linux is structured internally.

I wanted to keep this blog as raw as possible — more like personal notes — sharing what I observed while exploring and trying to make sense of it.

After setting up Ubuntu, I checked what exists at the root level of the system and found multiple directories like /dev, /etc, /proc, and more. These names didn’t mean much at first, but they became the starting point of my exploration.

While exploring, I used a few basic commands like listing directories, navigating between folders, and checking the current path. These helped me move around the system, but my main focus was understanding what each directory represents rather than the commands themselves.

/etc folder

When I navigated into the /etc directory, I noticed many files with names ending in .conf, which looked like configuration files.

This made me curious, so I explored further and found that /etc contains system-level configuration files — including settings for the OS and installed software.

Instead of hiding configurations inside a graphical interface, Linux stores them in readable text files. This makes the system more transparent and gives developers direct control over how the system behaves.

What stood out to me is how centralized configuration is in Linux. Many core system behaviors can be traced back to this single directory, making it feel like the control center of the operating system.

While browsing this directory, one file that caught my attention was "passwd", as the name suggested it might be related to users or authentication. That led me to explore it further.

/etc/passwd - User Management as Data

Inside the /etc directory, I found a file named passwd, which stores user information.

Each line in this file represents a user and contains structured data such as username, user ID, home directory, and default shell.

This file exists to allow the operating system to identify and manage users in a consistent way.

It solves the problem of user management by storing all user-related information in a single, readable format.

What surprised me is that users in Linux are not abstract entities — they are simply entries in a file, which makes the system highly transparent and easy to inspect.

/etc/resolv.conf — DNS Configuration

Another important file inside /etc is resolv.conf, which defines the DNS servers used by the system.

DNS (Domain Name System) is responsible for converting human-readable domain names into IP addresses.

This file exists because the system needs to know where to send DNS queries when accessing websites.

It solves the problem of internet navigation by acting as a bridge between domain names and actual server locations.

What I learned here is that internet connectivity depends on low-level configurations like this, and without it, even basic browsing would not work.

/proc — Live System Information

The /proc directory was one of the most unique parts of the Linux file system.

It contains files that provide real-time information about system processes, CPU usage, and memory.

Unlike regular files, these are not stored on disk but are dynamically generated by the system.

This directory exists to give developers and administrators direct access to system state.

It solves the problem of monitoring and debugging by exposing internal system data in a readable format.

What I found interesting is that Linux represents even dynamic system data as files, making it consistent with the overall design philosophy.

/dev — Hardware as Files

The /dev directory contains representations of hardware devices such as disks, terminals, and input devices.

In Linux, hardware devices are treated as files, which allows programs to interact with them using standard file operations.

This approach exists to simplify communication between software and hardware.

It solves the complexity of handling different hardware types by providing a unified interface.

What I learned is that Linux abstracts hardware in a very elegant way, making system interaction more consistent.

/var/log — System Logs and Debugging

The /var/log directory stores system logs, which record events, errors, and system activity.

These logs exist to help track what is happening inside the system over time.

They solve the problem of debugging by providing a history of system behavior.

If something goes wrong, logs are the first place to check for clues.

What I found interesting is how detailed these logs can be, showing everything from login attempts to system errors.

File Permissions — Security at Every Level

While exploring files, I noticed that each file has associated permissions that control who can read, write, or execute it.

This permission system exists to protect system integrity and prevent unauthorized access.

It solves the problem of security by ensuring that only allowed users can modify critical files.

What I learned is that Linux enforces security at a very granular level, making it robust and reliable for multi-user environments.

/proc/net/route — How Linux Knows Where to Send Data

While exploring deeper inside /proc, I found a file called /proc/net/route.

At first, the data looked confusing because it was written in hexadecimal format. But after understanding it, I realized that this file contains the routing table of the system.

It defines how network traffic is directed — for example, where to send data if it’s outside the local network.

What I found interesting is that commands like "ip route" are actually just reading this file and presenting it in a readable format.

This showed me that even networking logic in Linux is exposed through simple files.

/dev/null — The Black Hole of Linux

Inside the /dev directory, I found a special file called /dev/null.

This file acts like a black hole — anything written to it simply disappears.

It exists because sometimes programs need to discard output without storing it anywhere.

This solves the problem of handling unwanted data or logs.

What I found interesting is that even something like "discarding data" is implemented as a file in Linux.

/proc/sys/net/ipv4/ip_forward — One Setting That Changes System Behavior

While exploring system-level configurations, I came across a file called /proc/sys/net/ipv4/ip_forward.

This file contains a simple value — either 0 or 1.

If set to 1, the system starts forwarding network packets, effectively behaving like a router.

If set to 0, it behaves like a normal system.

What surprised me is that such a powerful behavior change is controlled by a single value inside a file.

This shows how Linux allows direct control over system behavior through simple configurations.

Conclusion

Exploring the Linux file system gave me a completely new perspective on how operating systems work.

One key insight I gained is that Linux treats almost everything as a file — from users and processes to hardware and configurations.

This design makes the system highly transparent, flexible, and powerful.

As I explored more, I realized that Linux does not hide its internal workings. Instead, it exposes them through files, making it easier to understand how everything is connected.

What initially felt confusing started to feel logical once I began recognizing patterns in how the system is structured.