Linux Fundamentals

Linux is a family of operating systems built around the Linux kernel. The kernel exposes the low-level interfaces for hardware, processes, filesystems, networking, and memory. A working Linux machine also needs user-space programs: a shell to accept commands, libraries and utilities to do work, a service manager, and a distribution that assembles and updates the whole system.

That separation gives you a useful starting model. The kernel manages shared machine resources. User-space programs request work through kernel interfaces. You normally work in user space, but every command eventually depends on the kernel's rules for processes, files, permissions, and devices.

The mental model

Think in four connected layers:

Kernel — schedules processes, manages memory, exposes devices, and provides virtual filesystems such as /proc and /sys.
Filesystem — gives programs stable paths for configuration, executable files, persistent data, runtime state, devices, and user home directories.
Processes and services — a running program is a process. A service manager starts and supervises long-running programs on systems that use one.
Shell and tools — the shell parses commands, expands names, connects programs with pipes, and redirects input and output. Programs such as ls, cp, grep, and chmod do the specific work.

You diagnose most Linux problems by locating the layer first. A missing command is usually a shell path or package issue. A permission denial is a filesystem access decision. A service that will not start is a process or service-management problem. A machine that cannot discover a device may require kernel, driver, or device inspection.

Files are the operating model

Linux presents much of the system through paths. Regular files hold data. Directories map names to files. Device files provide access points to devices. Pseudo filesystems expose kernel state without storing ordinary disk files. The FHS defines common directory placement conventions, but distributions can make different implementation choices.

Start by recognizing these paths:

/etc — host-specific configuration.
/home — user home directories.
/var — variable data such as logs and application state.
/tmp — temporary files; programs must not assume they survive.
/proc — a kernel interface containing system and process information.
/sys — a kernel interface for devices and system information.

A path is not an authorization. Access depends on the calling process identity, file ownership, mode bits, and sometimes additional controls such as ACLs, capabilities, or mandatory-access policy. For ordinary permissions, Linux distinguishes the file owner, the owning group, and everyone else. Directories give r, w, and x different meanings from regular files: execute means search or traverse the directory.

Processes, services, and logs

A process has a process ID, or PID. /proc has a numeric directory for each running process, which gives you an inspectable view of process state. Do not treat /proc as a configuration directory: it is a kernel interface whose contents describe the current system.

Many distributions use systemd as PID 1. On those systems, systemd starts and supervises services. systemctl is the control interface and journalctl reads the system journal. Other service managers exist, so identify the init system before applying systemd commands to an unfamiliar host.

Logs answer what happened. Process status answers what exists now. Configuration answers what the system is intended to do. Keep those questions separate when you troubleshoot.

The shell is a composition language

A shell runs programs and controls their input, output, environment, and exit status. A pipe connects one command's standard output to the next command's standard input. Redirection changes where a command reads or writes. This is why small utilities compose well:

journalctl -u sshd | grep 'Failed'

The pipeline is not magic. Each program still has its own arguments and exit status. In Bash, the status of a pipeline is normally the status of its last command. Enable pipefail when a failure in an earlier command must make the whole pipeline fail.

Treat commands as changes to state, especially with elevated privileges. Read a command's manual page, inspect the target, use the narrowest scope, then verify the result. sudo changes the authority of a command; it does not make an unsafe command safe.

Where Linux fits

Linux is a useful choice when you need a broadly supported server and automation platform, a configurable workstation, an embedded base, or a container host. Its interfaces and tools reward inspection and composition. They also place responsibility on you: distributions differ, service managers differ, and a command that is safe in a disposable test environment may be destructive on a production host.

This course is orientation, not operating-system administration certification. Next, practice in a disposable virtual machine. Learn paths and permissions, inspect processes and logs, read manual pages, then move into package management, networking, storage, service design, and security policy.