Operating Systems Fundamentals
An operating system is the software layer that lets programs use a computer’s processor, memory, storage, and devices safely. It shares those limited resources among programs and gives people and applications stable ways to work with hardware.
itOperating systems | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Operating Systems Fundamentals
An operating system is the responsible adult between programs and hardware. Programs would like processor time, memory, files, network access, and devices. Giving each one the keys to the machine would end with somebody formatting the furniture. The operating system coordinates those requests so many programs can share finite resources without directly controlling the machine.
The first important idea is user mode and kernel mode. Applications normally work in user mode, where they have limited access. The kernel runs privileged operating-system code, which means it can schedule work, manage memory, coordinate input and output, and apply access rules. A protected request crosses a controlled interface, often a system call. That boundary is why an ordinary application failure is usually contained, while a kernel-mode failure can inconvenience everyone at once.
The second idea is the request path. Reading a file is not a private conversation between an application and a disk. The kernel checks the request, applies filesystem and permission rules, may use cached file data, and coordinates a driver when device work is needed. Completion returns through the same sort of machinery. Networks, displays, keyboards, and storage differ in detail, but they all ask the operating system to arrange the awkward bits.
The third idea is that a process is a resource boundary and a thread is an execution path inside it. The scheduler chooses runnable threads for processor time. Virtual memory maps program addresses to physical memory pages, giving processes isolation and useful caching without producing extra capacity from a nearby cupboard. When demand remains too high, memory pressure can still slow or stop work.
The surprise is that “the computer is slow” is not a diagnosis. It is a polite notice that a request may be waiting for CPU time, memory, a filesystem, a driver, a device, a network operation, or a permission check. Start by finding the affected process and the resource path. Changing configuration before measuring the constrained resource is how a small mystery acquires a sequel.
Read the Intro for the full map of components and boundaries. Use Slides when the request path needs a quick visual pass, and keep the Cheatsheet nearby for terms such as page cache, write-back, and least privilege. The Practice reference gives you read-only Linux observations, while the quiz checks whether the parts still line up after the terminology has attempted its usual administrative ceremony.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://learn.microsoft.com/en-us/windows-hardware/drivers/gettingstarted/user-mode-and-kernel-mode
Supports
- User-mode and kernel-mode execution boundaries
- Private user-mode virtual address spaces and isolation
- Kernel-mode shared address space and system-wide failure impact
- https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/
Supports
- Kernel managers for memory, processes and threads, input/output, devices, power, configuration, and security
- Kernel low-level scheduling and hardware interrupt responsibilities
- https://cdn.kernel.org/doc/html/latest/admin-guide/mm/concepts.html
Supports
- Virtual memory, page tables, protection, and controlled sharing
- Page cache, write-back, reclaim, memory pressure, and out-of-memory handling
- https://www.kernel.org/doc/html/latest/filesystems/vfs.html
Supports
- Virtual filesystem interface to user-space programs
- Filesystem coexistence, pathname lookup, inodes, and file input/output interfaces
- https://pubs.opengroup.org/onlinepubs/9799919799/
Supports
- Current portable operating-system interfaces specification
- https://docs.kernel.org/filesystems/proc.html
Supports
- Linux proc filesystem process and memory observability interfaces used in the practice reference and exercise
- https://engineering.fb.com/2018/07/19/production-engineering/oomd/
Supports
- Production memory-pressure handling, pre-OOM visibility, and workload-aware recovery policy
- Pressure Stall Information for CPU, memory, and input/output resource shortages
- https://www.unix.org/unix_history.html
Supports
- Unix development, first edition, and public technical description milestones
- https://www.gnu.org/gnu/initial-announcement.html
Supports
- GNU Project announcement in 1983 and its Unix-compatible system goal
- https://www.gnu.org/gnu/gnu-history.en.html
Supports
- Linux kernel development in 1991 and combination with GNU components
- https://learn.microsoft.com/en-us/sysinternals/resources/archive/v02n03
Supports
- Windows NT 3.1 public release in July 1993
- https://www.kernel.org/pub/linux/kernel/v1.0/
Supports
- Linux 1.0 source archive dated March 1994
- https://www.apple.com/newsroom/2001/01/09Apples-Mac-OS-X-to-Ship-on-March-24/
Supports
- Mac OS X shipment date and UNIX-based Darwin foundation
- https://learn.microsoft.com/en-us/windows-server/get-started/overview
Supports
- Windows Server as an enterprise server platform
- https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux
Supports
- Red Hat Enterprise Linux deployment across cloud and hybrid environments
- https://www.suse.com/products/server/
Supports
- SUSE Linux Enterprise Server product positioning
- https://ubuntu.com/
Supports
- Ubuntu Linux distribution and support options
- https://www.apple.com/macos/
Supports
- macOS desktop operating system
