Unit 1: Introduction to Operating System [2 Hours]
An Operating System (OS) is the invisible layer that makes a computer usable. Without it, the hardware is just circuits and storage with no way to run programs, manage memory, or talk to devices. This unit covers what an OS is, where it came from, what it tries to accomplish, the different forms it takes, and the core functions it performs.
Tested Topics
- Operating System definition, objectives, and types — 3x (2023, 2022, 2021)
- Multitasking vs. Multiprocessing / Batch OS comparison — 2x (2025, 2022)
1.1 History, Introduction, and Generation of Operating System
Definition
An Operating System (OS) is system software that acts as an intermediary between computer hardware and the user, managing hardware resources and providing a platform for application programs to run.
A computer without an OS is like a kitchen with all the equipment but no chef, no labels, and no process. The OS is the chef: it knows what every appliance does, who gets to use what, and in what order. It takes your request — "open this file," "print that document" — and translates it into the raw instructions the hardware actually understands.
Detailed Explanation
The OS sits between the hardware layer below and the user and applications above. When you click "Save," the OS intercepts that action, finds free space on the storage device, writes the file, updates the directory, and confirms success — all in milliseconds, all without the application needing to know the physical details of the disk.
Understanding how the OS evolved helps explain why it works the way it does today.
Generations of Operating Systems
First Generation (1940s–early 1950s): No OS at all
Early computers like ENIAC had no OS. Programs were wired directly into the machine using plug boards and switches. Each user physically sat at the machine, set up the connections for their program, ran it, and disconnected. One program, one user, one machine — serially. Time between jobs was wasted on manual setup.
Second Generation (mid-1950s–early 1960s): Batch Processing Systems
To reduce idle time, similar jobs were grouped into batches. Users submitted jobs (programs + data) on punched cards. An operator loaded them in sequence, and a simple monitor program — the earliest form of an OS — read and executed them one after another automatically. There was no interaction between user and computer during execution. The machine ran without interruption, but users had to wait hours to see results.
Third Generation (mid-1960s–early 1970s): Multiprogramming and Time-Sharing
Two critical ideas emerged in this generation. First, multiprogramming: while one job waited for an Input/Output (I/O) operation (like reading from a tape), the CPU switched to another job instead of sitting idle. Second, time-sharing: the CPU's time was divided into small slices and rapidly switched among many users, giving each the illusion of a dedicated machine. The OS became genuinely complex — it now had to schedule CPU time, manage memory for multiple concurrent programs, and handle simultaneous users. UNIX was born in this era.
Fourth Generation (1980s–present): Personal Computers and Graphical User Interfaces
With affordable personal computers, the OS shifted to serve individual users rather than shared mainframes. Graphical User Interface (GUI)-based systems like MS-DOS (text-based), followed by Windows and macOS (graphical), made computers accessible to non-technical users. This generation also brought network support, multitasking for a single user, and eventually mobile OSs like Android and iOS.
| Generation | Era | Key Feature | Example |
|---|---|---|---|
| 1st | 1940s–early 50s | No OS, manual wiring | ENIAC |
| 2nd | Mid-50s–early 60s | Batch processing | IBM 7094 with FMS |
| 3rd | Mid-60s–early 70s | Multiprogramming, time-sharing | UNIX, OS/360 |
| 4th | 1980s–present | Personal computing, GUI | Windows, macOS, Linux, Android |
Summary
- An OS is system software that manages hardware and provides an interface for users and applications.
- First-generation computers had no OS; users manually wired programs.
- Second-generation introduced batch processing to reduce CPU idle time.
- Third-generation introduced multiprogramming and time-sharing, making the OS genuinely complex.
- Fourth-generation brought personal computing, GUIs, and network support to individual users.
Test Yourself
- Trace the evolution of operating systems from the first generation to the fourth generation.
- What problem did batch processing solve, and what problem did it leave unsolved?
Hints:
- 1st: no OS, manual setup. 2nd: batch monitor, jobs grouped automatically. 3rd: multiprogramming keeps CPU busy; time-sharing serves many users simultaneously. 4th: personal computing, GUI, networks, mobile.
- Batch processing eliminated manual setup between jobs, reducing CPU idle time between programs. It left the problem of user interaction unsolved — users still waited hours with no feedback during execution.
1.2 Objectives of Operating System
Definition
The objectives of an Operating System are the core goals it is designed to achieve: making the computer convenient to use and using the hardware efficiently. These are formally captured by two models — the OS as a Resource Manager and the OS as an Extended Machine.
Every OS is trying to do two things at once: hide the ugly complexity of hardware from the user, and make sure no resource — CPU time, memory, disk space, network — gets wasted or monopolized unfairly.
Detailed Explanation
Objective 1 — Resource Manager
A computer has a fixed set of resources: the Central Processing Unit (CPU), memory (RAM), storage devices, and input/output (I/O) devices like keyboards, printers, and network cards. Multiple programs and users compete for these resources simultaneously. The OS acts as the Resource Manager — it allocates, tracks, and reclaims resources so that:
- No program hogs the CPU indefinitely.
- Programs do not overwrite each other's memory.
- Two programs do not simultaneously write to the same file and corrupt it.
- A crashed program releases its resources back to the system.
The resource management role covers four main areas:
Process Management: The OS decides which program gets CPU time, for how long, and in what order. This is called scheduling. When the currently running program waits for I/O, the OS switches the CPU to another ready program rather than letting it sit idle.
Memory Management: The OS allocates blocks of RAM to each running program. It ensures each program can only access its own allocated region — preventing one program from reading or corrupting another's data. When a program finishes, its memory is freed and made available again.
File Management: The OS organizes data on storage devices using a file system. It provides operations like create, read, write, delete, and rename, and enforces permissions so that only authorized users can access sensitive files.
I/O Device Management: The OS provides a uniform interface to all hardware devices through software components called device drivers. A program calls a standard print function; the OS figures out which printer is connected, how to communicate with it, and queues the job if the printer is busy.
Let's Clarify
Picture a government office with one photocopier and twenty employees. Without a manager, everyone rushes the machine at once — papers get mixed up, the machine jams, and nothing gets done efficiently. The office manager (the OS) creates a queue, allocates a time slot to each person, ensures no one takes more paper than their share, and makes sure the machine is never left idle when someone is waiting. That is resource management.
Objective 2 — Extended Machine (Abstract Machine)
Raw hardware is deeply inconvenient to program. To read one sector from a hard disk, a programmer would need to know the exact disk geometry, the timing signals, the register addresses of the disk controller, and the interrupt handling sequence. Without an OS, every developer would have to write this low-level code themselves — for every device, for every machine.
The OS solves this by providing an abstraction layer. It hides the hardware details and presents programmers and users with a cleaner, simpler machine — the Extended Machine. Instead of talking to disk controllers directly, a programmer calls readFile("data.txt"). The OS translates that into the correct low-level hardware operations invisibly.
The Extended Machine concept works at multiple levels:
User opens application → Application calls OS service (system call) → OS translates to hardware instruction → Hardware executes → OS returns result to application → Application shows result to user
| View | What the OS Provides | Who Benefits |
|---|---|---|
| Resource Manager | Efficient, fair allocation of CPU, memory, I/O, storage | System performance and multi-user fairness |
| Extended Machine | Simple, uniform interface hiding hardware complexity | Application developers and end users |
Summary
- The OS has two primary objectives: managing resources efficiently and presenting a simplified interface to users and programs.
- As a Resource Manager, it allocates CPU, memory, I/O devices, and storage fairly among competing programs.
- As an Extended Machine, it hides hardware complexity through abstraction, so programmers work with simple calls rather than raw hardware.
- Process, memory, file, and I/O management are the four pillars of the resource management role.
Test Yourself
- Define Operating System. Explain objectives of Operating System. (2023)
- What is an operating system? Explain the two main views of an OS: Resource Manager and Extended Machine.
- What is meant by the OS as an "Extended Machine"? How does it benefit application developers?
Hints:
- OS = system software bridging hardware and users. Objectives: (1) Resource Manager — allocates and manages CPU, memory, I/O, storage fairly. (2) Extended Machine — hides hardware details and provides a simple abstract interface.
- Resource Manager: controls CPU scheduling, memory allocation, I/O queuing, file access. Extended Machine: provides clean system calls so developers write
readFile()instead of raw disk controller commands. - The Extended Machine objective means the OS provides an abstraction layer over hardware. A developer calls a standard file-read function; the OS handles sector addressing, controller signals, and interrupt handling transparently. Developers write portable, hardware-independent code.
1.3 Types of Operating System
Definition
Operating systems are classified into types based on how they handle tasks, how many users they support, and how they respond to processes. Each type is designed to solve a specific class of computing problem.
Not all computers are used the same way. A bank's transaction server, a student's laptop, and a hospital's patient-monitoring system have completely different demands. OS types exist because one design cannot efficiently serve all those scenarios.
Detailed Explanation
1. Batch Operating System
In a Batch OS, similar jobs are grouped (batched) together and processed sequentially without user interaction. Jobs are submitted in advance — typically as punched cards or files — and the OS executes them one by one automatically. There is no direct communication between the user and the computer while a job is running.
How it works: User submits job → Operator groups similar jobs into a batch → OS loads and runs them one after another → Output is collected and returned later to the user.
Advantages: CPU is kept busy with minimal idle time; good throughput for repetitive tasks.
Disadvantages: No real-time interaction; if a job fails, the error is only found later; turnaround time (time from submission to result) can be hours.
Used for: Payroll processing, bank statement generation, report generation — tasks that are large, repetitive, and do not need interaction.
2. Multiprogramming Operating System
A Multiprogramming OS keeps several programs loaded in memory simultaneously. When the running program waits for I/O, the CPU immediately switches to another ready program. The goal is to maximize CPU utilization by eliminating idle time.
Key concept: Multiple programs in memory → CPU runs one → that program requests I/O → CPU switches to next program → first program's I/O completes → first program re-enters the ready queue.
Multiprogramming does not mean programs run at exactly the same instant. It means the CPU is always kept busy by switching among jobs whenever one would otherwise make it wait.
3. Multitasking (Time-Sharing) Operating System
A Multitasking OS extends multiprogramming by rapidly switching the CPU among multiple tasks using small fixed time slots called time slices or quantum. Each user or task gets a turn so quickly that all appear to run simultaneously. This is the OS type on virtually every modern desktop, laptop, and smartphone.
How it works: OS divides CPU time into tiny slices (typically 10–100 milliseconds) → assigns one slice to each task in rotation → switches so fast that each task appears to run continuously.
Response time — the time between a user action and the system response — is kept short, giving an interactive feel.
4. Multiprocessing Operating System
A Multiprocessing OS manages systems with two or more physical CPUs (processors). Multiple CPUs can execute different processes at the exact same instant — genuine parallelism, not the rapid switching of multitasking.
How it works: OS scheduler distributes processes across available CPUs → processes run in parallel → OS coordinates shared memory and synchronization between them.
Advantage: True simultaneous execution increases throughput, speed, and fault tolerance. If one CPU fails, others continue.
Used for: Servers, scientific computing, large-scale databases, rendering farms.
5. Real-Time Operating System (RTOS)
A Real-Time Operating System (RTOS) processes input and produces output within a strict, guaranteed time constraint called a deadline. Missing a deadline is treated as a system failure.
Two types:
- Hard Real-Time: missing any deadline causes catastrophic failure. Used in aircraft autopilots, anti-lock braking systems, pacemakers, missile guidance systems.
- Soft Real-Time: missing an occasional deadline degrades quality but does not cause failure. Used in video streaming, online gaming, digital phones.
6. Distributed Operating System
A Distributed OS manages a network of independent computers and presents them to users as a single unified system. Computations can be distributed across nodes, and resources anywhere in the network can be shared.
Used for: Cloud computing platforms, large-scale scientific research clusters.
7. Embedded Operating System
An Embedded OS is designed to run on resource-constrained, special-purpose hardware with limited CPU power, memory, and storage. It is built into the device and performs only the functions that device needs.
Used for: Smart TVs, digital cameras, washing machines, ATMs, routers.
Multitasking vs. Multiprocessing vs. Batch OS
| Feature | Batch OS | Multitasking OS | Multiprocessing OS |
|---|---|---|---|
| User interaction | None during execution | Continuous, interactive | Can be interactive or not |
| CPU count | One | One | Two or more |
| Concurrency type | Sequential (one job at a time) | Apparent (rapid switching) | True parallel execution |
| Response time | Hours | Seconds or less | Depends on load distribution |
| Main goal | Throughput | User responsiveness | Throughput and speed via parallelism |
| Use case | Payroll, bank reports | Personal computers, phones | Servers, scientific computing |
Common Mistake
Students frequently confuse multitasking and multiprocessing. Multitasking is one CPU switching rapidly among tasks — no two tasks run at exactly the same instant. Multiprocessing is multiple CPUs running different processes simultaneously — true parallel execution. A laptop doing multitasking is not doing multiprocessing unless it has multiple CPU cores all independently executing separate processes. Modern computers often do both, which adds to the confusion.
Summary
- Batch OS groups jobs and runs them sequentially with no user interaction; good for high-throughput repetitive tasks.
- Multiprogramming keeps multiple programs in memory and switches the CPU to another when one waits for I/O.
- Multitasking (time-sharing) rapidly divides CPU time into slices among tasks, giving all users an interactive experience.
- Multiprocessing uses multiple CPUs for genuine parallel execution, improving speed and throughput.
- RTOS guarantees response within a deadline; hard real-time is for safety-critical systems, soft real-time for media applications.
- Distributed and Embedded OSs extend the model to networks and resource-constrained devices respectively.
Test Yourself
- What is an operating system? Is "Multitasking" operating system better than "Batch" operating system? Justify your answer. (2022)
- How multitasking is different from multiprocessing? (2025)
- List and briefly explain four types of operating systems with a use case for each.
Hints:
- OS = software that manages hardware and provides interface for users/apps. Multitasking vs Batch: Multitasking is "better" for interactive use because it provides continuous user feedback, fast response times, and allows multiple apps to run. Batch is better for throughput-intensive, non-interactive tasks like payroll. Neither is universally superior — the right choice depends on the use case.
- Multitasking: one CPU, rapid time-slice switching among tasks, apparent concurrency. Multiprocessing: multiple CPUs, genuine simultaneous execution of different processes. Key distinction: multitasking simulates parallelism; multiprocessing achieves it.
- Batch: sequential, no interaction, payroll. Multitasking: time-sliced CPU, interactive, personal computers. Multiprocessing: multiple CPUs, parallel, servers. RTOS: guaranteed deadlines, aircraft/pacemakers.
1.4 Functions of Operating System
Definition
The functions of an Operating System are the specific tasks it performs to manage hardware resources and provide services to users and application programs. These functions are the practical implementation of the OS's objectives.
If the objectives say what the OS is trying to achieve, the functions are what it actually does every second the computer is running.
Detailed Explanation
1. Process Management
A process is a program in execution. The OS creates a process when a program is launched, tracks its progress, allocates CPU time to it, handles its pauses and resumptions, and terminates it when done.
Key process management tasks:
- Process creation and termination: starting a new process when a program is run, ending it cleanly when done.
- CPU scheduling: deciding which process runs next when the CPU becomes free. Common algorithms include First Come First Served (FCFS), Round Robin, and Priority Scheduling.
- Process synchronization: when multiple processes share data, the OS prevents conflicts through mechanisms like locks and semaphores.
- Deadlock handling: a deadlock occurs when two processes each wait for a resource held by the other. The OS detects and resolves this.
2. Memory Management
The OS controls how Random Access Memory (RAM) is allocated to processes and ensures that processes do not interfere with each other's memory space.
Key memory management tasks:
- Allocation and deallocation: giving memory to a process when it starts, reclaiming it when the process ends.
- Memory protection: ensuring process A cannot read or write process B's memory region.
- Virtual memory: when RAM is full, the OS temporarily moves inactive data to disk (swap space) and loads it back when needed, creating the illusion of more memory than physically exists.
3. File System Management
The OS organizes all data on storage devices into a hierarchical structure of files and directories. It provides a consistent interface for creating, reading, writing, and deleting files regardless of the underlying storage hardware.
- Directory management: organizing files into folders and providing path-based access (e.g.,
/home/ankit/notes.txt). - File permissions: controlling who can read, write, or execute each file.
- Space management: tracking which disk sectors are free and which are occupied.
4. I/O Device Management
The OS provides a uniform interface to all hardware devices through device drivers — small software modules that translate generic OS commands into the specific signals each device understands.
- Device drivers: each device (printer, keyboard, network card) has a driver that the OS uses to communicate with it.
- Buffering: temporary storage of data in transit between a fast device (CPU/RAM) and a slow device (printer/disk) to prevent bottlenecks.
- Spooling: Simultaneous Peripheral Operations On-Line (SPOOL) queues output jobs (like print requests) so the CPU is not kept waiting for the slow device.
5. Security and Protection
The OS protects data and resources from unauthorized access and accidental or malicious damage.
- Authentication: verifying user identity (username and password, biometrics).
- Authorization: controlling what authenticated users are permitted to do.
- Protection mechanisms: memory protection, file permissions, process isolation.
6. User Interface
The OS provides the interface through which users interact with the computer. Two forms exist:
- Command Line Interface (CLI): text-based commands typed by the user. Powerful, scriptable, but requires knowledge of commands. Example: Linux terminal, Windows Command Prompt.
- Graphical User Interface (GUI): windows, icons, and menus controlled by mouse or touch. Intuitive for general users. Example: Windows desktop, macOS Finder.
7. Networking
Modern OS types manage network connections, enabling communication between computers. The OS handles protocols like Transmission Control Protocol/Internet Protocol (TCP/IP), manages network hardware drivers, and provides file sharing and remote access services.
Summary
- Process management: creates, schedules, synchronizes, and terminates processes; handles deadlocks.
- Memory management: allocates RAM, protects process memory regions, implements virtual memory.
- File system management: organizes data into files and directories, enforces permissions, tracks disk space.
- I/O management: uses device drivers to abstract hardware; uses buffering and spooling to handle speed mismatches.
- Security: authenticates users and authorizes access to resources and data.
- User interface: provides CLI or GUI for user interaction with the system.
Test Yourself
- List and explain the major functions of an operating system.
- What is a device driver? How does it help the OS manage I/O devices?
- What is virtual memory? Why does the OS need it?
- Differentiate between buffering and spooling.
Hints:
- Seven functions: process management (scheduling, sync, deadlock), memory management (allocation, protection, virtual memory), file management, I/O management, security/protection, user interface, networking.
- A device driver is software that translates generic OS commands into device-specific signals. Without drivers, the OS would need separate code for every brand and model of every device. Drivers isolate hardware specifics from the rest of the OS.
- Virtual memory uses disk space as an extension of RAM. When physical RAM is full, inactive memory pages are moved to disk (swap). This allows systems to run programs larger than available RAM and run more programs simultaneously.
- Buffering: temporary storage of data in transit between two devices with mismatched speeds (e.g., RAM and disk). Spooling (SPOOL): queuing print jobs on disk so the CPU submits jobs and moves on while the slow printer works through the queue at its own pace.
Exam Questions
- What is an operating system? Is "Multitasking" operating system better than "Batch" operating system? Justify your answer. (2022)
- Define Operating System. Explain objectives of Operating System. (2023)
- How multitasking is different from multiprocessing? (2025)
Whole Chapter Summary
1.1 History and Generations: The OS evolved from no software at all (1st gen, manual wiring) to batch monitors (2nd gen), then multiprogramming and time-sharing (3rd gen), and finally personal computing with GUIs and networking (4th gen). Each generation solved the main idle-time or usability problem left by the previous one.
1.2 Objectives: The OS has two fundamental goals. As a Resource Manager, it fairly and efficiently allocates CPU, memory, I/O devices, and storage among competing processes. As an Extended Machine, it hides hardware complexity behind a clean abstraction layer so that users and developers work with simple interfaces rather than raw hardware commands.
1.3 Types: Batch OS runs jobs sequentially with no interaction, best for throughput-heavy tasks. Multiprogramming maximizes CPU use by switching to another program during I/O waits. Multitasking rapidly time-slices the CPU for interactive use. Multiprocessing uses multiple CPUs for true parallel execution. RTOS enforces strict deadlines for safety-critical applications. Distributed and Embedded OSs extend these principles to networks and constrained hardware.
1.4 Functions: The OS performs seven main functions: process management (scheduling, sync, deadlock), memory management (allocation, protection, virtual memory), file system management, I/O device management (drivers, buffering, spooling), security and protection, user interface (CLI and GUI), and networking.
Last-Minute Revision Sheet
| Concept | Trigger Phrase | Recall Cue |
|---|---|---|
| OS definition | Intermediary software | Hardware ↔ OS ↔ User/App |
| Resource Manager | Fair allocation | CPU, RAM, I/O, Storage — OS controls all |
| Extended Machine | Hide hardware | readFile() not disk controller commands |
| 1st Gen OS | No OS | Plug boards, one user, serial |
| 2nd Gen OS | Batch | Grouped jobs, no interaction, punched cards |
| 3rd Gen OS | Multiprogramming + time-sharing | UNIX era; CPU stays busy; multi-user |
| 4th Gen OS | GUI + personal computing | Windows, macOS, Android |
| Batch OS | Sequential, no interaction | Payroll, bank reports |
| Multiprogramming | CPU never idle | Switch to another job during I/O wait |
| Multitasking | Time-slice, rapid switch | Apparent parallelism; one CPU; interactive |
| Multiprocessing | Multiple CPUs | True parallelism; servers; speed + reliability |
| RTOS Hard | Deadline = life or death | Pacemakers, autopilots, ABS brakes |
| RTOS Soft | Deadline = quality | Video streaming, gaming |
| Process management | Scheduling + sync | FCFS, Round Robin; deadlock prevention |
| Virtual memory | More RAM than exists | Inactive pages → disk (swap) |
| Spooling | Print queue | SPOOL = jobs lined up; CPU free while printer works |
| Buffering | Speed mismatch bridge | Fast RAM ↔ slow disk; temp storage in between |
| Device driver | Hardware translator | Generic OS command → device-specific signal |
| CLI vs GUI | Text vs visual | CLI: powerful, scriptable. GUI: intuitive, mouse-driven |