IK
Chapter 1 of 8
~28 min read
Last reviewed July 17, 2026

Operating Systems: Structure and Services

How an operating system is built, covering the kernel, shell, layered design, process lifecycle, RAM versus virtual memory, system calls, and FCFS scheduling.

Written and reviewed by the IK Learning team

  • OS Architecture
  • Kernel & Shell
  • Process Lifecycle
  • RAM vs Virtual Memory
  • System Calls
  • FCFS Scheduling

This chapter explains how an operating system is structured, covering the kernel, shell, and layered design, the full lifecycle of a process, the difference between RAM and virtual memory, how system calls work, and how FCFS scheduling orders tasks for the CPU.

Chapter Introduction

What this chapter is about, and why it matters

An operating system is the piece of software you use constantly and almost never think about. Every time you open an app, save a file or plug in a USB drive, something has to decide which program gets the processor, where in memory the data goes, and which device driver to call. That something is the OS.

This chapter opens the box. You will see that an OS is built in layers, with the kernel at the centre doing the dangerous work and the shell at the outside talking to you. You will follow a program through its life as a process, and see why a computer can appear to run twenty programs at once on a processor that can only execute one instruction at a time.

The scheduling and memory sections are where exam marks concentrate. Both are best learned by working an example on paper — draw the process states, calculate an FCFS waiting time by hand, and the definitions stop being abstract.

What You Will Learn

The skills this chapter is assessed on

  • Describe the layered structure of an operating system and the role of the kernel and shell.
  • List the main services an operating system provides.
  • Explain the process lifecycle and name each state a process passes through.
  • Distinguish RAM from virtual memory and explain why virtual memory slows a system down.
  • Explain what a system call is, and calculate waiting and turnaround times under FCFS scheduling.

Key Concepts Explained

10 core ideas — each with its definition and a separate worked example

Operating system

Definition

An operating system is system software that manages a computer's hardware and software resources, and provides an environment and common services in which application programs can run.

Example

When you save a document, the word processor does not know where the file physically sits on the disk or how to command the drive. It asks the operating system, which handles the hardware and reports back whether the save succeeded.

Detailed Explanation

The OS exists so that application programmers do not have to rewrite hardware code for every model of disk, printer and graphics card ever made. It is a layer of shared, reusable machinery — which is exactly what makes it "system" software rather than an application.

Kernel

Definition

The kernel is the core component of an operating system. It loads first, stays in memory, and has direct privileged control over the CPU, memory and devices, managing processes, memory allocation and hardware access.

Example

When two programs both request memory at the same moment, the kernel decides how much each receives and keeps their regions separate, so one program crashing cannot corrupt the other's data.

Detailed Explanation

The kernel runs in a privileged mode that ordinary programs cannot enter. That separation is a safety mechanism: an application asking to write anywhere in memory is refused, which is why a badly written app closes with an error instead of taking down the whole machine.

Shell

Definition

The shell is the part of an operating system that acts as the interface between the user and the kernel, accepting commands from the user and passing them to the kernel for execution.

Example

Typing `dir` in Command Prompt, or clicking a folder icon, both reach the same place. The shell — whether command-line or graphical — translates your instruction into a request the kernel can carry out.

Detailed Explanation

Kernel and shell are the pair most often reversed in exams. Remember the geography: the kernel is at the centre next to the hardware, the shell wraps around the outside next to the user. A nut has its kernel inside and its shell outside.

Layered structure of an OS

Definition

A layered operating system is organised as a series of levels, where each layer uses only the services of the layer directly beneath it and provides services to the layer directly above.

Example

From the bottom upward: hardware → kernel → system libraries and services → shell / user interface → application programs. A web browser at the top never touches the hardware at the bottom; the request passes down through each layer.

Detailed Explanation

Layering is what makes an OS maintainable. A new graphics card needs a new driver near the bottom, and nothing above it has to be rewritten. The cost is a small performance overhead at each boundary — a trade the industry accepted decades ago.

Process

Definition

A process is a program that is currently being executed, together with the memory, resources and current state the operating system has allocated to it.

Example

The browser file sitting on your disk is a program. The moment you launch it, the OS creates a process with its own memory space. Open the browser twice and you have one program but two processes, each with its own tabs and history.

Detailed Explanation

The distinction is program = passive file, process = active execution. Every exam that covers this chapter tests it, usually in a one-mark definition question.

The process lifecycle

Definition

A process passes through a defined sequence of states during its lifetime: new (being created), ready (waiting for the CPU), running (executing on the CPU), waiting or blocked (waiting for an input/output operation to finish), and terminated (finished and released).

Example

A program that asks the user for input goes running → waiting the instant it requests keyboard input, because there is nothing to compute until you type. When you press Enter it returns to ready, not straight to running — it must wait its turn for the CPU again.

Detailed Explanation

The waiting state is what makes multitasking efficient. Instead of letting the CPU idle while a process waits for a slow disk, the OS hands the CPU to another ready process. This is why a computer feels responsive even though it may be running only one instruction at a time.

RAM (primary memory)

Definition

RAM (Random Access Memory) is the computer's fast, volatile main memory, which holds the programs and data currently in use and loses its contents when power is removed.

Example

Opening a 20-page document loads it from the disk into RAM so the CPU can reach it quickly. Close the file without saving and the edits are gone, because they only ever existed in volatile memory.

Virtual memory

Definition

Virtual memory is a memory-management technique in which the operating system uses a reserved area of secondary storage as an extension of RAM, moving less-active pages of data out to disk so that more programs can run than physical memory alone would allow.

Example

With ten browser tabs open on a machine with limited RAM, the OS moves the pages you have not looked at recently onto the disk. Switching back to one of those tabs feels sluggish for a second — that is the page being fetched back into RAM.

Detailed Explanation

Virtual memory buys capacity by spending speed. A hard disk is thousands of times slower than RAM, so a system relying heavily on virtual memory "thrashes" — spending more time moving pages than doing work. This is the technical reason adding RAM is often the most effective upgrade for a slow computer.

System call

Definition

A system call is a controlled request made by an application program to the operating system kernel when it needs a service that requires privileged access, such as reading a file, allocating memory or communicating over a network.

Example

A Python program running `open("data.txt")` cannot read the disk itself. It issues a system call; the CPU switches into privileged mode, the kernel performs the read, and control returns to the program with the data.

Detailed Explanation

System calls are the only doorway between an ordinary program and the hardware, and that is the point. Because every privileged action must pass through this checkpoint, the OS can enforce permissions — which is how one user is prevented from reading another user's files.

FCFS (First Come First Served) scheduling

Definition

FCFS is a CPU scheduling algorithm in which processes are executed strictly in the order they arrive in the ready queue, and each process runs to completion before the next one begins.

Example

Three processes arrive together with burst times of 8, 2 and 3 milliseconds. Under FCFS the second process waits 8 ms and the third waits 10 ms, even though both are far shorter than the first.

Detailed Explanation

FCFS is simple and completely fair in arrival order, but it suffers from the convoy effect: one long process at the front makes every short process behind it wait. That single weakness is what the exam question about FCFS is almost always testing.

Step-by-Step Worked Examples

How to lay the answer out so method marks are earned

Calculating average waiting time under FCFS

Question: Three processes arrive at time 0 in the order P1, P2, P3 with burst times 8 ms, 4 ms and 2 ms. Calculate the waiting time for each and the average waiting time.

  1. Under FCFS, processes run in arrival order: P1, then P2, then P3.
  2. P1 starts immediately at time 0, so its waiting time is 0 ms.
  3. P2 cannot start until P1 finishes at 8 ms, so P2 waits 8 ms.
  4. P3 cannot start until P2 finishes at 8 + 4 = 12 ms, so P3 waits 12 ms.
  5. Add the waiting times: 0 + 8 + 12 = 20 ms.
  6. Divide by the number of processes: 20 ÷ 3.

Answer

Average waiting time = 6.67 ms. Note that running the shortest process first would have reduced this considerably — which is precisely the argument against FCFS.

Where This Is Used in Real Life

The same ideas, outside the syllabus

Why closing background apps speeds up a phone

Each background app holds a process and its memory. Closing them frees RAM, which reduces how often the OS has to page data out to slower storage. You are directly relieving the virtual-memory pressure described in this chapter.

Task Manager as a live process table

Open Task Manager and you are looking at the process list the OS maintains, with the state, memory allocation and CPU share of each process. The theory in this chapter is visible on screen at any moment.

Scheduling beyond computers

A supermarket with one till serving customers strictly in queue order is running FCFS, complete with the convoy effect when someone ahead has a full trolley. Express lanes exist because shortest-job-first is measurably better for average waiting time.

Common Mistakes to Avoid

Errors that cost marks in this chapter, and the correction for each

Mistake

Swapping the definitions of kernel and shell.

Correct Approach

Kernel = inner core, talks to hardware, privileged. Shell = outer interface, talks to the user. Picture a nut.

Mistake

Using "program" and "process" interchangeably.

Correct Approach

A program is a passive file on disk. A process is that program actually executing, with memory allocated to it.

Mistake

Describing virtual memory as "extra RAM".

Correct Approach

It is disk space used *as if* it were RAM. It increases capacity but is far slower — saying it is extra RAM misses the entire trade-off.

Mistake

Sending a process from waiting straight back to running.

Correct Approach

After its input/output completes, a process returns to the ready state and must be scheduled again before it runs.

Mistake

Forgetting that the first process in an FCFS calculation has zero waiting time.

Correct Approach

When all processes arrive at time 0, the first one starts immediately. Including a non-zero wait for it shifts every subsequent figure.

Mistake

Claiming FCFS gives the best average waiting time because it is fair.

Correct Approach

Fair in ordering, poor in efficiency. FCFS frequently produces a worse average waiting time than algorithms that run short processes first.

Exam Preparation Tips

Technique specific to this chapter

  • Draw the process state diagram whenever a question mentions process states. The arrows between states carry marks that a written list does not.
  • Show the full calculation in scheduling questions — individual waiting times, the total, then the division. Method marks survive an arithmetic slip.
  • When comparing RAM and virtual memory, use a table with clear bases: speed, location, volatility, cost, capacity.
  • For "services of an operating system", give at least five: process management, memory management, file management, device management, and security or user-interface provision.
  • If asked why a computer has become slow, connect it to the theory — insufficient RAM causing heavy paging — rather than giving general advice.

Quick Revision Summary

The whole chapter in one screen — read this the night before

  • OS = system software managing hardware and providing services to applications.
  • Kernel = privileged core next to the hardware. Shell = interface next to the user.
  • Layers: hardware → kernel → system services → shell → applications.
  • Program = file on disk. Process = program in execution.
  • Process states: new → ready → running → waiting → ready → … → terminated.
  • RAM = fast, volatile, limited. Virtual memory = disk used as overflow, slower.
  • Heavy paging between RAM and disk is called thrashing.
  • A system call is the controlled doorway from an application into the kernel.
  • FCFS runs processes in arrival order; its weakness is the convoy effect.
  • Average waiting time = sum of individual waiting times ÷ number of processes.

Glossary of Terms

Words used in this chapter, defined plainly

Multitasking
Running several processes apparently at once by switching the CPU rapidly between them.
Context switch
Saving one process's state and loading another's so the CPU can change tasks.
Burst time
The amount of CPU time a process needs to complete.
Turnaround time
Total time from a process arriving to it finishing.
Paging
Moving fixed-size blocks of memory between RAM and disk.
Thrashing
A state where the system spends more time paging than doing useful work.
Device driver
Software that lets the OS communicate with a specific piece of hardware.

Practice Questions

Now test yourself on the concepts above. Collapse the answers to make it a real practice run.

Multiple Choice Questions with Explanations

8 MCQs — pick an option to check yourself, then read why the answer is right

1Which of these is NOT an operating system?

Correct answer: C — Photoshop

Photoshop is an application program used for editing images, not an operating system that manages hardware and resources.

2On a multi-user system, the operating system makes sure that:

Correct answer: A — Every user gets equal access and privacy

A multi-user operating system keeps each user's files and settings separate, giving everyone fair access while protecting their privacy.

3Within Windows, new user accounts can be set up through:

Correct answer: B — Control Panel or Settings

In Windows, new user accounts are created and managed through the Control Panel or the Settings app.

4The central part of the OS that communicates directly with hardware is called the:

Correct answer: B — Kernel

The kernel is the core of the operating system that talks directly to the hardware and manages memory, processes, and devices.

5A graphical shell lets the user:

Correct answer: B — Click icons and navigate menus

A graphical shell (GUI) lets users interact by clicking icons and navigating menus instead of typing text commands.

6Under the FCFS scheduling method, processes are handled:

Correct answer: C — In the order of their arrival

Under First Come First Served, processes are executed in the exact order in which they arrive in the queue.

7Threads belonging to the same process:

Correct answer: B — Share common memory and resources

Threads within the same process share the same memory space and resources, which lets them run concurrently and communicate easily.

8Which system call creates a new process?

Correct answer: D — fork

The fork() system call creates a new process by duplicating the process that calls it.

Short Questions with Answers

10 short-answer questions

The operating system is called the central controller because it manages and supervises every activity taking place in the computer system, including hardware components such as the CPU, memory, and input/output devices. Example: While music is playing and a file is being downloaded, the OS decides how much CPU time and memory each program gets so that both keep running smoothly.
The operating system works as a translator by converting the commands a user gives through applications or interfaces into machine-level instructions, so that the hardware can understand and carry out the user's tasks. Example: When you click the Print button, the OS converts that click into the low-level signals the printer hardware needs to start printing.
A user account is a separate profile that lets a person use the computer with their own settings, files, and privacy. In Windows, a new account is created through the Control Panel or Settings, which allows several users to operate the same computer independently. Example: Go to Settings → Accounts → Family & other users → Add account, then enter the new user details.
The kernel is the core part of the operating system that communicates directly with the hardware, whereas the shell is the outer layer that acts as an interface between the user and the OS. Example: The kernel reads a file from the hard disk, while the shell is the Windows desktop or the Command Prompt where you give the command to open that file.
A system library is a collection of ready-made functions that programs use for common tasks such as input, output, and memory handling, so programmers do not have to write these routines themselves. Example: The C standard library provides functions such as printf() for output and malloc() for memory allocation.
FCFS (First Come First Served) is a scheduling method in which processes are executed in the order of their arrival. Its advantage is that it is straightforward and simple to implement, while its disadvantage is that a lengthy process forces the others to wait, which raises the overall waiting time. Example: If a 10-minute process arrives just before a 1-minute process, the short process must wait the full 10 minutes before it can run.
Virtual memory is storage space on the hard disk that the operating system uses as extra memory when the RAM is full. It performs more slowly than RAM because accessing a hard disk takes far longer than accessing RAM. Example: When too many programs are open, the OS moves inactive data to the disk, so switching back to that program feels slow.
A system call is the mechanism a program uses to request a service from the operating system, giving it access to hardware resources such as files and memory. Example: fork() creates a new process, while read() and write() are used to read from and write to a file.
A file system is the part of the operating system that arranges and stores data on storage devices, keeps track of file names and their storage locations, and lets users create, read, update, and delete files. Example: NTFS in Windows saves a document inside the Documents folder as notes.txt and remembers exactly where on the disk it is stored.
Multitasking is the ability of an operating system to run more than one program at the same time by rapidly switching the CPU between the different tasks. Example: Listening to music, typing a document, and downloading a file all at once on the same computer.

Long Questions with Detailed Answers

5 in-depth answers

- Architecture of an Operating System The architecture of an operating system describes how its components are organized and how they cooperate with one another. Each component performs a distinct role, and together they allow the computer to function smoothly — much like a school where different departments handle specific duties yet work together to keep the school running. - Kernel vs Shell a. Kernel: The kernel is the innermost part of the operating system. It directly manages the computer's system software and hardware, such as the CPU, memory, and devices. It determines how and when various programs are allowed to use these resources. Example: When you open a file, the kernel handles the task of reading it from the hard drive and sending it to the screen. Just as an engine drives a car, the kernel drives the system, while accessories such as the steering wheel and dashboard resemble the shell. b. Shell: The shell is the outer layer of the OS that communicates with the user. It takes commands from the user and forwards them to the kernel. Shells come in two forms: i. Graphical shells (such as the Windows desktop) where icons are clicked and menus are used. ii. Command-line shells (such as Command Prompt or Terminal) where instructions are typed in. - OS Layers and Modular Design Operating systems are commonly designed in layers, with each layer assigned a specific task: a. Lower layer: Works directly with hardware devices such as the CPU, RAM, and hard drive. b. Middle layer: Manages these resources and ensures programs can access them whenever required. c. Upper layer: Runs applications and offers the interface the user sees on screen. Each layer relies on the one beneath it. This structure makes the operating system simpler to manage, repair, and upgrade without altering the entire system. Example: A school can help illustrate the layered architecture of an operating system: 1. Support staff (such as guards and cleaners) work at the base, keeping the school functional (similar to lower layers working with hardware). 2. The administration handles resources, schedules, and rules (similar to middle layers managing memory and storage). 3. Teachers and students make use of these arrangements to teach and learn (similar to upper layers running applications and interacting with users).
The operating system takes charge of managing every program that runs on a computer. These running programs are referred to as processes. Process management makes sure each process receives the resources it requires, even while several processes are active at once. This is one of the most critical jobs an operating system performs, since it keeps all processes running smoothly without interfering with each other. - Process Life Cycle A process passes through several stages over its life cycle: a. Creation i. This occurs when a program is launched (such as MS Word). ii. The OS loads the program into memory and assigns it the resources (such as CPU time and memory) it needs. b. Execution i. The process is actively running and carrying out its tasks. c. Termination i. The process completes its task and is closed by the user or the system. ii. The OS frees up the resources so they become available to other processes. Example: The process life cycle of launching a web browser, such as Google Chrome, on a phone or computer. a. Creation: Starts when the user taps or clicks the browser icon. The operating system loads the program into memory and allocates the necessary resources. b. Execution: The browser carries out tasks like loading web pages, displaying media, and responding to user actions. c. Termination: Happens when the browser is closed. The operating system halts the process and releases its resources for other uses. - Multitasking and Concurrency Modern operating systems can handle many processes so efficiently that they all seem to run at once. a. Multitasking: The operating system lets more than one program stay open and usable by a single user at the same time. Users can switch between them whenever needed. Example: You can listen to music, keep a document open, and browse the internet, switching between them as required. b. Concurrency: More than one process is active at the same time within an OS, but the CPU handles them one at a time in extremely rapid cycles. Example: Much like a chef preparing three dishes, working briefly on one before moving to the next and repeating the cycle, the CPU switches between processes so quickly that the user notices no delay. - Process Scheduling Concepts Many processes may be in progress during the same period, but the CPU only works on one at a time, in very fast turns. Since the CPU cannot execute all processes simultaneously, the operating system must decide: 1. Which process runs first? 2. How long should each process run? This decision-making process is called scheduling. Operating systems use several scheduling methods. First Come, First Served (FCFS) is the simplest of these scheduling techniques.
Difference between RAM and Virtual Memory RAM | Virtual Memory RAM (Random Access Memory), also known as primary memory, is | Virtual memory is a portion of the computer's storage drive the main working area of a computer where data and instructions | used as extra RAM when the actual RAM becomes full. are stored temporarily. | It is a fast storage area that lets the CPU access information | Storage drives transfer data at lower speeds and have higher quickly while a program executes. | access times than RAM, which makes virtual memory slower. Data held in RAM is wiped when the computer is switched off. | It allows more programs to run simultaneously by using space | from an HDD, SSD, or NVMe drive. Multithreading and Performance Multithreading is an operating system technique that lets a single process carry out multiple tasks at once by splitting its work into smaller units called threads. Each thread operates independently but shares the same memory and resources as the process it belongs to. Multithreading boosts performance because tasks can be split across multiple threads and run in parallel, allowing complex operations to finish faster, improving overall system efficiency, and keeping applications responsive.
A system call is a request that a program sends to the operating system to carry out a specific task the program cannot perform on its own. - Purpose: System calls act as a bridge between user programs and the kernel, letting applications safely access hardware and core OS functions. Without them, programs that control hardware directly would be complex and unsafe. Example: When a text editor saves a file, it uses a system call to instruct the operating system to write the data onto the storage drive (such as a hard drive). - Types of System Calls: The main categories of system calls include: 1. open: Opens a file for reading or writing. Example: Opening a music file to play it. 2. read: Fetches data from a file or input device. Example: Reading text out of a document. 3. write: Sends data to a file or output device. Example: Saving an image onto the computer. 4. fork: Creates a new process by duplicating an existing one. Example: Opening a new browser tab, where the OS may use fork to spawn another process.
Step 1: Understand FCFS Scheduling First-Come, First-Served (FCFS) is a non-preemptive scheduling algorithm in which processes execute in order of their arrival times. Whichever process arrives first receives the CPU first and runs to completion before the next one begins. Given processes: 1. P1: Arrival = 0s, Burst = 4s 2. P2: Arrival = 1s, Burst = 3s 3. P3: Arrival = 2s, Burst = 1s Step 2: Arrange Processes in Execution Order (Requirement I) Sorting by arrival time gives: P1 → P2 → P3 Step 3: Execution Sequence and Gantt Chart (Requirement II) 1. Execution starts at time 0. 2. P1 runs from 0s to 4s. 3. P2 runs from 4s to 7s. 4. P3 runs from 7s to 8s. [Gantt Chart] 0 4 7 8 | P1 | P2 | P3 | Step 4: Start Time and Completion Time (Requirement III) P1: 1. Start time = 0s (starts as soon as it arrives) 2. Completion time = Start + Burst = 0 + 4 = 4s P2: 1. Start time = Completion of P1 = 4s (must wait for P1 to finish) 2. Completion time = 4 + 3 = 7s P3: 1. Start time = Completion of P2 = 7s (must wait for P2 to finish) 2. Completion time = 7 + 1 = 8s Process | Start Time (s) | Completion Time (s) P1 | 0 | 4 P2 | 4 | 7 P3 | 7 | 8 Step 5: Calculate Waiting Time for Each Process (Requirement IV) Waiting time = Start time − Arrival time (the time a process spends in the ready queue before it starts executing). 1. P1: Waiting time = 0 − 0 = 0s 2. P2: Waiting time = 4 − 1 = 3s 3. P3: Waiting time = 7 − 2 = 5s Process | Waiting Time (s) P1 | 0 P2 | 3 P3 | 5 Step 6: Calculate Average Waiting Time (Requirement V) 1. Total waiting time = 0 + 3 + 5 = 8s 2. Number of processes = 3 3. Average waiting time = Total waiting time / Number of processes = 8 / 3 = 2.6667s (or 8/3 s)

Important Questions for Revision

6 high-priority questions

The operating system oversees every activity of the computer system. It manages hardware such as the CPU, memory, and input/output devices. This is why it is known as the central controller of the system.
The kernel is the core of the operating system that communicates directly with hardware. The shell is the outer part (interface) that lets users interact with the OS by taking in user commands and passing them on to the kernel.
Advantage: FCFS is simple and straightforward to implement — processes are handled in the precise order they arrive, and none are skipped. Disadvantage: Short processes may wait a long time if queued behind longer ones (known as the "convoy effect"), which can reduce overall efficiency.
Virtual memory uses a portion of the hard disk (HDD/SSD) as temporary RAM. Hard disk access speed is much slower than RAM. Because of this, when the operating system relies on virtual memory, overall performance is slower than when using RAM.
An OS is made up of three main parts: - Kernel — the core that directly controls hardware (CPU, memory, devices). Example: when a file is opened, the kernel reads it from the hard drive. - Shell — the outer interface that takes user commands and passes them to the kernel. It can be graphical (Windows desktop) or command-line (Command Prompt). - Layered Design — the OS is split into layers, each with a specific job: 1. Lower layer: works directly with hardware 2. Middle layer: manages resources 3. Upper layer: runs applications and provides the user interface Each layer depends on the one below it, which makes the OS easier to manage and repair.
RAM vs Virtual Memory: 1. RAM (Random Access Memory) is the main working area — fast, temporary storage used while a program executes. 2. Virtual Memory uses hard disk space as an extension of RAM once RAM fills up. It is slower because hard disks are slower than RAM. Multithreading: A technique that lets a single process carry out multiple tasks at once by dividing its work into smaller units called threads. Each thread shares the same memory. This improves performance by enabling parallel execution, better responsiveness, and more efficient use of resources.

Frequently Asked Questions

6 quick answers to common questions about this chapter

The kernel is the core of the OS that directly controls hardware like the CPU and memory — it's the "engine." The shell is the outer interface users interact with, whether typing commands or clicking icons — it's more like the "dashboard." The shell passes user requests to the kernel, which actually carries them out.
No. RAM is fast physical memory the CPU accesses directly. Virtual memory is a technique that uses space on the hard disk as overflow when RAM fills up, letting more programs run at once — but because disk access is much slower than RAM, relying on virtual memory heavily slows a system down.
When a text editor saves a file, the program itself can't write directly to the hard disk — it has to ask the operating system to do it through a system call. This keeps hardware access safe and controlled instead of letting every program touch storage directly.
FCFS (First-Come, First-Served) processes tasks strictly in arrival order, with no regard for how long each one takes. If a short task arrives right after a very long one, it has to wait for the long task to finish completely — this is sometimes called the "convoy effect."
Yes. OS architecture, kernel vs shell, the process lifecycle, RAM vs virtual memory, system calls, and FCFS scheduling are all examinable topics covered through MCQs and short/long answer questions.
Multitasking is the OS running several separate programs and switching between them quickly. Multithreading happens within a single process, splitting its own work into smaller threads that share the same memory. Multitasking juggles different programs; multithreading speeds up one program internally.

Chapter Test

8 questions with the answers hidden — check what you actually remember

You have just read the explanations above. This checks whether they stuck. The answers stay hidden until you finish, so it is closer to exam conditions than scrolling through the notes again.

  • 8 questions, one at a time — no time limit.
  • You can move back and change an answer before submitting.
  • Afterwards you get your score, every explanation, and what to re-read.

Your score is saved in this browser only. No account, nothing sent anywhere.

Related Topics in the Other Class

Class 9Introduction to Computing Systems