Operating Systems Overview
Understand how an operating system manages hardware, applications, files, users, and security boundaries.
- Certification
- CompTIA A+
- Recommended study time
- 5h 30m
- Status
- Not started
Recommended study time
About 5h 30m in total, measured from the material on this page. At your session length of 45 minutes that is 8 sittings.
- Read the lesson20 min
About 2,650 words at a careful technical reading pace.
- Second pass with notes12 min
Re-read the harder parts and write your own notes.
- Work through the examples1h
3 worked examples and 9 practice questions.
- Recall from memory12 min
2 written recall questions.
- Practice decision12 min
One applied decision with feedback.
- Teach it back20 min
Write the topic in your own words.
- Real-world scenario15 min
Read the situation and justify your decision in writing.
- Hands-on practice2h
Labs, commands and configuration until you can do it unaided.
- Spaced review1h
4 short review sessions spread over the following weeks.
Learning objectives
- Explain the operating system's role between applications and hardware.
- Compare the everyday uses of Windows, macOS, Linux, Android, and iOS.
- Recognize processes, filesystems, user accounts, drivers, and permissions.
Start here
About 20 minutes of reading, in 8 short parts.
An operating system is the referee between hardware, applications, and people. It decides which program gets the CPU, who is allowed to open which file, and how a device request becomes electrical activity. Almost every support task you will ever perform happens through OS concepts.
Where you meet it: Windows endpoints, Linux servers, macOS creative machines, mobile devices, and every permission, driver, update, or boot problem in a ticket queue.
The lesson, part by part
Open one part at a time. Each part stands on its own, so you can stop and come back.
An operating system provides four services that applications cannot safely provide for themselves: process management (which code runs and when), memory management (who gets which region of RAM), filesystem and device management (how storage and hardware are addressed), and security (who may do what).
It enforces these with a hardware-supported privilege boundary. Kernel mode has unrestricted access to memory and devices; user mode does not. When your application needs to read a file or send a packet it makes a system call, which traps into the kernel, does the privileged work, and returns. That boundary is why one crashing application usually does not take the machine down, and why a bad driver — which runs in kernel space — can.
Key ideas
If you remember nothing else from this topic, remember these.
- The kernel-mode versus user-mode boundary is the reason a single crashing application rarely takes the whole machine down, while a bad kernel-mode driver can cause a full system crash.
- Virtual memory gives every process the illusion of owning the entire address space, and the operating system silently maps those virtual addresses onto physical RAM or a page file, which is why two processes can both believe they own the same-looking address without conflict.
- The boot sequence has a strict order: firmware, bootloader, kernel, then user-space services, and knowing that order lets you place a fault precisely just from where in that sequence it stops.
- Windows and Linux enforce permissions with genuinely different models, ACLs plus UAC elevation on Windows against owner/group/other bits plus sudo on Linux, and mixing up which model applies to which system is a common source of wasted troubleshooting time.
- NTFS journaling, ext4 journaling, and APFS copy-on-write all exist to solve the same problem: recovering a consistent filesystem state after an unexpected power loss, and each does it differently enough that recovery tools are not interchangeable across them.
- Disk space exhaustion on the system volume produces symptoms that look unrelated: failed updates, broken printing, corrupted temp files, and app crashes, because dozens of separate OS subsystems all quietly assume free space exists.
Resolving an application that only fails for one user on a shared machine
A worked example, step by step.
On a shared kiosk workstation, User A can open the inventory application normally, but User B gets 'Access is denied' every time they try to launch it, even though both accounts are standard users.
- 01Confirm scopeLog in as User A on the same machine: the app opens fine. Log in as User B: the error reproduces immediately, confirming this is account-specific, not machine-wide.
- 02Check the exact error pathThe error dialog references C:\ProgramData\InventoryApp\config.dat, giving a specific file to inspect rather than guessing.
- 03Inspect effective permissionsRight-click the file, open Properties, Security tab, and click Advanced to view effective access for User B. The Users group has Read only, while Modify was granted individually to User A at some point.
- 04Check the application logsEvent Viewer shows an Access Denied write attempt to that same config.dat when User B launches the app, confirming the app needs write access to that file at startup.
- 05Decide the correct fixRather than adding User B to local Administrators, which grants far more than needed, add the Users group (or a dedicated app-users group) Modify permission on that specific file.
- 06Apply and testGrant Modify to the Users group on config.dat, keep ownership unchanged, and log back in as User B.
- 07VerifyThe application now opens correctly for User B without an elevation prompt or error.
- 08DocumentRecord in the ticket that the fault was an NTFS permission gap on a specific file, not a broken installation, so future kiosk accounts get the group permission by default.
Outcome: The application worked only for the one account that had been individually granted file permission; fixing the underlying NTFS ACL on the shared group, rather than elevating the user's account, solved the problem for every future user of that machine.
Operating System Facts Worth Memorising
Worth keeping at hand while you work.
- systemd (PID 1)
- First user-space process on most modern Linux distributions; manages services and boot targets
- journalctl
- Reads the systemd journal; journalctl -xe shows recent errors
- sfc /scannow
- Windows System File Checker; repairs corrupted system files from a local cache
- DISM /Online /Cleanup-Image /RestoreHealth
- Repairs the Windows component store that sfc itself relies on
- EFI System Partition
- FAT32 partition holding the bootloader files that UEFI firmware reads
- NTFS permissions vs share permissions
- When both apply over a network, the more restrictive of the two always wins
- Event Viewer
- Windows log viewer; Application, System, and Security logs are the three checked most often
- Safe Mode
- Windows boot state loading minimal drivers and no third-party startup items, used to isolate driver faults
- chmod 755
- Owner gets read/write/execute, group and others get read/execute only
- /etc/passwd and /etc/shadow
- User account info and hashed passwords respectively on Linux
- Task Manager Startup tab
- Shows and disables programs launching at Windows login
- Windows Update troubleshooting order
- Check free disk space, then check Windows Update logs, then reset update components
Common misunderstandings
What most beginners get wrong here.
Reinstalling the operating system is the fastest fix for most weird behaviour.
Most faults are permission, profile, driver, or disk-space issues that are faster and less disruptive to diagnose directly than to nuke and reinstall.
Adding a user to the local Administrators group is an acceptable quick fix for an access denied error.
This grants far more privilege than the problem requires and creates a security exposure; the correct fix is the specific ACL entry the task actually needs.
A blue screen and a kernel panic mean the hardware is definitely broken.
Most blue screens and panics are caused by a faulty or incompatible driver, which is why checking recent driver changes comes before hardware replacement.
The page file only matters on old computers with little RAM.
Every modern OS still uses a page file or swap even with abundant RAM, for memory management flexibility and to hold hibernation state; disabling it is rarely wise.
Windows and Linux permission models work the same way, just with different commands.
Windows ACLs are per-object lists of specific permissions per account or group, while Linux traditionally uses fixed owner/group/other bits; they are structurally different systems.
Exam traps
How the question writers try to catch you out.
- When a question shows both NTFS and share permissions applied to the same network resource, the exam wants the most restrictive combined result, not either one alone.
- A question describing a fault that appears immediately after a driver update, with a stop code, is testing 'roll back the driver' as the correct next step, not full hardware replacement.
- Expect exact command names to matter: sfc /scannow repairs system files, while DISM repairs the component store sfc depends on; a question may require choosing the right tool for a stated symptom.
- Questions describing a machine stuck at boot before any Windows logo is a firmware or boot-loader stage problem, while a crash after the logo but before login points to a driver or corrupted system file.
- Distinguish safe mode from a system restore point in exam wording: safe mode isolates the cause, a restore point reverts state; they solve different problems.
Check yourself
Answer in your head first, then reveal. This is not scored.
Two users on the same Windows machine have different experiences with the same application. What are the first three things to test, in order?
Why does a crashing user-space application rarely take down the whole operating system, while a bad driver can?
A Linux server will not accept new SSH logins and disk-based logging has stopped. What should you check first?
What is the practical difference between sfc /scannow and DISM /Online /Cleanup-Image /RestoreHealth?
Why is checking free disk space one of the first troubleshooting steps regardless of the reported symptom?
Quick reference
A condensed summary of the lesson above, for revision.
What It Is
An operating system, or OS, is the core software that manages hardware resources and provides services to applications. Its kernel controls low-level access to CPU time, memory, storage, and devices. User interfaces, system utilities, drivers, filesystems, and security services build on that core.
Why It Matters
Nearly every IT task happens through an operating system. Installing software, creating accounts, applying updates, reading logs, configuring networks, and recovering files all depend on OS concepts. Understanding the shared principles makes it easier to move between Windows, macOS, Linux, Android, and iOS even though their tools differ.
How It Works
- The kernel schedules CPU time, allocates memory, and controls privileged hardware access.
- Drivers translate operating-system requests for specific devices.
- Filesystems, accounts, and permissions organize data and limit actions.
Where You See It
- Windows endpoints, Linux servers, macOS workstations, and Android or iOS mobile devices.
Key Terms
- Kernel
- The privileged core that manages hardware and system resources.
- Process
- A running instance of a program with allocated resources.
- Filesystem
- The rules and structures an OS uses to name and organize stored data.
- Driver
- Software that lets the OS communicate with a particular hardware device.
- Permission
- A rule defining what a user or process may read, change, or execute.
Examples
- When a printer is connected, the OS uses a driver to translate print requests into instructions the device understands.
- A standard user account can run everyday applications while administrator approval protects system-wide settings.
Common Problems
- Failed updates
- Incompatible or missing drivers
- Insufficient permissions
- Runaway processes
How It Fails
- Boot files can become damaged.
- A driver can crash the kernel or leave hardware unavailable.
- Full storage can prevent updates and normal application writes.
How to Troubleshoot
- Identify whether the failure affects one application, one account, or the whole OS.
- Check logs, storage space, updates, drivers, and permissions.
- Use recovery or safe-start tools before reinstalling.
Practical Knowledge
- Know where to inspect processes, services, devices, disks, and logs.
- Use standard accounts for routine work and elevate only when necessary.
Exam Coverage
- OS functions and editions
- Filesystems and permissions
- Update, driver, and boot troubleshooting
Interview Questions
- What does an operating system do between an application and hardware?
- How would you investigate an application that works for an administrator but not a standard user?
Worked examples
Each calculation is shown one step at a time, then you try it yourself before revealing the answer.
Read and set Linux file permissions
A script shows as -rwxr-xr-- . What are its numeric permissions, and what command would make it rwxr-x---?
- 1. Split the stringIgnore the leading file-type character, then take three groups: owner rwx, group r-x, others r--.
- 2. Score each groupread = 4, write = 2, execute = 1. Owner 4+2+1 = 7. Group 4+0+1 = 5. Others 4+0+0 = 4.
- 3. Read the numberThe permissions are 754.
- 4. Build the targetrwx = 7, r-x = 5, --- = 0, so the goal is 750.
Answer: -rwxr-xr-- is 754; chmod 750 script.sh produces rwxr-x---. A 'Permission denied' on your own script is usually a missing execute bit (chmod +x).
Now you try
What is rw-r--r-- numerically?
What does chmod 600 key.pem allow?
Which command changes the owning user?
Explain a 'missing' drive capacity
A customer buys a 1 TB drive and Windows reports 931 GB. Has the shop cheated them?
- 1. Manufacturer unitsDrive makers use decimal units: 1 TB = 1,000,000,000,000 bytes.
- 2. Operating system unitsWindows reports binary units but labels them GB: 1 GiB = 1,073,741,824 bytes.
- 3. Do the division1,000,000,000,000 ÷ 1,073,741,824 ≈ 931.
- 4. Account for formattingThe filesystem and recovery partitions then consume a further few gigabytes.
Answer: No. The bytes are all there; the two sides count in different units. Say this to the customer in plain terms rather than quoting powers of two.
Now you try
How much usable space would a 2 TB drive report?
How many bytes in 1 MiB?
Why does a phone advertise 128 GB but show around 112 GB?
Size virtual machines on a host
A host has 16 GB RAM and 8 CPU cores. How many 4 GB lab VMs can safely run at once?
- 1. Reserve for the hostThe host operating system and hypervisor need their own memory — reserve about 4 GB.
- 2. Divide what remains16 − 4 = 12 GB available. 12 ÷ 4 = 3 VMs.
- 3. Check CPUCores can be oversubscribed; memory generally cannot. Two virtual CPUs each across 3 VMs is 6 of 8 cores — comfortable.
- 4. Check diskDynamically expanding disks grow over time; confirm free space on the host volume before you build.
Answer: Three 4 GB VMs. Memory is the hard limit: overcommit it and the host swaps to disk and everything crawls.
Now you try
Same host, VMs need 6 GB each. How many?
Why does a container need less memory than a VM?
Which resource can you safely oversubscribe?
Watch and read
Verified official and reputable sources for this topic. Links open in a new tab.
Video training
Reading and courses
Lesson notes and bookmark
Notes and bookmarks for this lesson, saved with everything else you have marked.
No notes on this item yet.
Learning progress
0% across six evidence areas. Reading alone does not change progress.
Prerequisites
Next steps
- 01Open the system's process viewer and identify active applications and background services.
- 02Find the filesystem location of your user profile and a system directory.