Unit 2: Operating System & Computer Languages

An Operating System (OS) is system software that manages hardware resources and provides services to application programs. It acts as an intermediary between you (the user) and the hardware (CPU, RAM, disk). Without an OS, you would need to write machine code to perform even the simplest task — like displaying a character on screen.

An OS is like a hotel manager. Guests (applications) arrive and need rooms (RAM), food (CPU time), and services (printer, internet). The manager assigns rooms, manages housekeeping (memory cleanup), ensures no guest takes over the entire hotel (process isolation), and handles checkout (closing apps). You, the guest, never interact with the plumbing or electrical wiring directly — the manager handles it all.

OS Architecture
┌──────────────────────────────────────────────────────┐
│                    USER (You)                         │
├──────────────────────────────────────────────────────┤
│              Application Software                     │
│   Chrome │ VS Code │ WhatsApp │ VLC │ Python          │
├──────────────────────────────────────────────────────┤
│              OPERATING SYSTEM                         │
│  ┌──────────────────────────────────────────────┐    │
│  │ Process Mgmt │ Memory Mgmt │ File System     │    │
│  │ Device Mgmt  │ Security    │ User Interface  │    │
│  └──────────────────────────────────────────────┘    │
│  ┌──────────────────────────────────────────────┐    │
│  │         KERNEL (Core of the OS)               │    │
│  │    System calls, drivers, scheduler           │    │
│  └──────────────────────────────────────────────┘    │
├──────────────────────────────────────────────────────┤
│                    HARDWARE                           │
│      CPU  │  RAM  │  SSD/HDD  │  GPU  │  NIC         │
└──────────────────────────────────────────────────────┘

Every company, everywhere. Windows dominates desktops (72% market share). Linux dominates servers (96.3% of top 1M web servers). Android (Linux kernel) dominates mobile (95% in India). macOS is preferred by designers and iOS developers. Choosing the right OS for a project is a real engineering decision.

"Windows IS the computer." No. Windows is just one OS among many. The same hardware can run Windows, Linux, macOS (with restrictions), or even no OS at all (bare-metal embedded systems). The OS is software — it can be replaced, dual-booted, or run inside a virtual machine.

Unit 1 (hardware components that the OS manages) → Unit 3 (Linux, a specific OS) → Unit 4 (network services that run on an OS)

What: Jobs are collected, grouped (batched), and executed sequentially without user interaction. No real-time input.

Analogy: Like dropping clothes at a laundry service — you give your clothes, they wash everything in batches, you pick up later. No interaction during the process.

Industry: Early mainframes (1960s-70s). Still used conceptually in payroll processing at TCS/Infosys — salary calculations for 6 lakh employees run as overnight batch jobs.

What: CPU time is shared among multiple users/tasks. Each task gets a tiny time slice (quantum), creating the illusion of simultaneous execution.

Analogy: A teacher answering questions from 30 students by giving each student 10 seconds of attention in rotation. Each student feels served, but the teacher is actually switching rapidly.

Industry: All modern OS (Windows, Linux, macOS). When you run Chrome + VS Code + Spotify simultaneously, the CPU switches between them thousands of times per second. This is called context switching.

What: Guarantees that critical tasks complete within a strict deadline. Missing a deadline is treated as system failure.

Analogy: An emergency room doctor — if a cardiac arrest patient comes in, treatment MUST start within 60 seconds. There's no "please wait, I'm updating Windows."

Industry: ISRO's Chandrayaan-3 landing sequence (microsecond precision). Anti-lock braking systems (ABS) in Maruti/Hyundai cars. Medical ventilators during COVID-19. DRDO missile guidance systems. QNX and VxWorks are popular RTOS choices.

What: Multiple interconnected computers appear as a single system to the user. Resources are shared across the network.

Analogy: A restaurant chain where any branch can serve any order because they share a common kitchen network and inventory system.

Industry: Google's infrastructure — your search query hits thousands of servers across multiple data centres worldwide, but you see one result page. Hadoop/Spark clusters at Flipkart for big data processing.

What: Lightweight OS designed for specific hardware with limited resources (low RAM, low power). Does one thing well.

Analogy: A single-purpose machine — a washing machine's brain doesn't need to run Excel; it just needs to manage water levels, spin speed, and timers.

Industry: Smart TVs (Tizen in Samsung, webOS in LG). Router firmware (OpenWrt). IoT devices (ESP32 running FreeRTOS). ATM machines. Digital payment terminals (Pine Labs, Paytm Soundbox).

What: OS optimized for touchscreen devices with battery constraints, cellular connectivity, and app sandboxing.

Analogy: A compact apartment designed for efficiency — everything (kitchen, bedroom, bathroom) in limited space, but designed to be functional and beautiful.

Industry: Android (Linux kernel, 95% Indian market). iOS (Apple, XNU kernel). HarmonyOS (Huawei, growing in China). Every UPI app (PhonePe, GPay, Paytm) runs on mobile OS.

A file system organizes files in a tree structure — a root at the top, branches (directories/folders), and leaves (files). Every file has a unique location called a path.

Windows
C:\                              ← Root (drive letter)
├── Users\
│   ├── Rahul\
│   │   ├── Desktop\
│   │   ├── Documents\
│   │   │   └── project.py       ← Absolute path: C:\Users\Rahul\Documents\project.py
│   │   └── Downloads\
│   └── Priya\
├── Program Files\
│   ├── Google\Chrome\
│   └── Microsoft VS Code\
├── Windows\
│   └── System32\                ← NEVER delete files here!
└── Temp\

Linux
/                                ← Root (forward slash, no drive letters)
├── home/
│   ├── rahul/
│   │   ├── Desktop/
│   │   ├── Documents/
│   │   │   └── project.py       ← Absolute path: /home/rahul/Documents/project.py
│   │   └── Downloads/
│   └── priya/
├── etc/                         ← System configuration files
├── var/                         ← Variable data (logs, databases)
├── usr/                         ← User programs (installed software)
├── tmp/                         ← Temporary files (cleared on reboot)
├── bin/                         ← Essential command binaries (ls, cp, mv)
└── dev/                         ← Device files (hardware represented as files!)

"Linux doesn't have drive letters? How does it handle multiple disks?" Linux mounts additional drives into the existing directory tree. A second drive might appear as /mnt/data or /media/usb. Everything is part of one unified tree under /. Much cleaner than Windows' C:, D:, E: system.

Boot Sequence
┌──────────────────────────────────────────────────────────────────────┐
│ STEP 1: POWER ON                                                     │
│  PSU provides power → CPU receives first instruction from ROM        │
├──────────────────────────────────────────────────────────────────────┤
│ STEP 2: BIOS / UEFI (Firmware)                                       │
│  Stored in ROM/flash on the motherboard                              │
│  • Initializes hardware (RAM, GPU, storage)                          │
│  • Runs POST (Power-On Self-Test) — checks if hardware works         │
│  • POST fails? You hear beep codes (1 beep = RAM, 3 beeps = GPU)    │
├──────────────────────────────────────────────────────────────────────┤
│ STEP 3: BOOTLOADER                                                    │
│  BIOS finds bootable device (SSD/HDD) → loads the bootloader         │
│  • Windows: Windows Boot Manager (bootmgr)                           │
│  • Linux: GRUB (GRand Unified Bootloader) — lets you choose OS       │
│  • Bootloader's job: find and load the OS kernel into RAM             │
├──────────────────────────────────────────────────────────────────────┤
│ STEP 4: KERNEL LOADING                                                │
│  Kernel is loaded into RAM and takes control                          │
│  • Initializes device drivers                                        │
│  • Sets up memory management, process scheduler                      │
│  • Mounts root file system                                           │
├──────────────────────────────────────────────────────────────────────┤
│ STEP 5: INIT / SYSTEMD (Linux) or smss.exe (Windows)                 │
│  First user-space process (PID 1 on Linux)                            │
│  • Starts system services (networking, display, login)                │
│  • Launches daemons/services in parallel (systemd) or serial (SysV)  │
├──────────────────────────────────────────────────────────────────────┤
│ STEP 6: LOGIN SCREEN                                                  │
│  Display manager (GDM/LightDM on Linux, logonui.exe on Windows)      │
│  • User authentication → desktop environment loaded                   │
│  Total time: 5-30 seconds (SSD vs HDD makes the biggest difference)  │
└──────────────────────────────────────────────────────────────────────┘

Data centre engineers at Jio/Airtel remotely manage server boot using UEFI's network boot feature (PXE). Hundreds of servers can boot from a central image — no USB drives needed. When AIIMS was hit by ransomware in 2022, recovery involved booting from external media (bypassing the encrypted OS) — understanding the boot sequence was critical for the recovery team.

"BIOS and UEFI are the same thing." No. UEFI is the modern replacement for BIOS. UEFI supports drives larger than 2 TB (GPT partitioning), has Secure Boot (prevents rootkit attacks during boot), and initializes hardware faster. Any PC built after 2015 uses UEFI, though the settings screen is still commonly called "BIOS setup."

The kernel is the core component of an OS that has complete control over the hardware. It runs in a privileged mode (kernel space) with direct access to CPU, RAM, and devices. Everything else — your apps, your browser, your IDE — runs in user space with restricted access. Apps must ask the kernel (via system calls) to access hardware.

The kernel is like a bank vault manager. Regular employees (user-space apps) can request money from the vault, but they can't enter the vault themselves. The vault manager (kernel) verifies their identity, checks their authority, and hands over the requested amount. If someone tries to enter the vault directly — the alarm goes off (segmentation fault / blue screen).

Kernel Space vs User Space
┌─────────────────────────────────────────┐
│          USER SPACE (Restricted)         │
│                                          │
│  Chrome  │  VS Code  │  Python  │  VLC   │
│                                          │
│  ↕ System Calls (the ONLY way to talk)  ↕│
│                                          │
├─────────────────────────────────────────┤
│          KERNEL SPACE (Privileged)        │
│                                          │
│  Process Scheduler  │  Memory Manager    │
│  Device Drivers     │  File System       │
│  Network Stack      │  Security Module   │
│                                          │
│  Direct access to: CPU, RAM, Disk, NIC   │
└─────────────────────────────────────────┘

"The kernel IS the OS." Not exactly. The kernel is the core of the OS, but the OS also includes user-space tools: shell, file manager, system utilities, GUI. Linux is technically just a kernel — what we call "Linux" is actually GNU/Linux (kernel + GNU tools + distribution-specific software). Android uses the Linux kernel but has a completely different user-space stack.

Machine language is the only language a CPU directly understands — sequences of 0s and 1s (binary). Each instruction tells the CPU exactly what to do: add two numbers, move data from memory, compare values. Every program you've ever used — from WhatsApp to Windows — is eventually converted to machine language before the CPU can run it.

If the CPU speaks only Tamil, machine language IS Tamil. Assembly language is Tamil written in Roman script (transliteration). High-level language is English — which needs a translator (compiler) to convert into Tamil.

Machine Code (x86)
; Adding two numbers (5 + 3) in machine language
10110000 00000101     ← MOV AL, 5    (put 5 into register AL)
00000100 00000011     ← ADD AL, 3    (add 3 to AL)
11110100               ← HLT          (halt the CPU)

; Result: register AL now holds 00001000 (decimal 8)

"Nobody writes machine language anymore." Mostly true, but CPU designers at Intel, AMD, and ARM must understand machine language because they're designing the hardware that executes it. Also, security researchers analyze machine code to find vulnerabilities in compiled programs (reverse engineering).

Assembly language uses mnemonics (short human-readable codes like MOV, ADD, JMP) instead of binary. An assembler converts assembly code to machine code. It's a 1-to-1 mapping: each assembly instruction corresponds to exactly one machine instruction.

x86 Assembly
; Adding two numbers (same operation as above, but readable)
section .text
global _start

_start:
    mov  eax, 5       ; Put 5 in register EAX
    add  eax, 3       ; Add 3 → EAX = 8
    mov  ebx, eax     ; Move result to EBX (exit code)
    mov  eax, 1       ; System call number 1 (sys_exit)
    int  0x80         ; Call kernel — exit with code 8

Assembly is still used where every CPU cycle matters: (1) BIOS/UEFI firmware — the first code that runs on boot. (2) Device drivers — directly talk to hardware. (3) Embedded systems at DRDO/BEL — missile guidance requires predictable, cycle-exact timing. (4) Malware analysis — security researchers at CERT-In reverse-engineer compiled malware back to assembly to understand attacks.

A compiler translates the entire source code into machine code at once, producing an executable file. You run the executable separately — the compiler is no longer needed at runtime.

Like translating an entire book from English to Hindi before giving it to the reader. The translation takes time upfront, but once done, the reader (CPU) reads the Hindi version at full speed without needing the translator anymore.

Compiler Phases
Source Code: "int x = 5 + 3;"

Phase 1: LEXICAL ANALYSIS (Scanner)
  → Breaks code into tokens: [int] [x] [=] [5] [+] [3] [;]
  → Like splitting a sentence into individual words

Phase 2: SYNTAX ANALYSIS (Parser)
  → Builds a parse tree (checks grammar)
  →    =
      / \
     x   +
        / \
       5   3
  → If grammar is wrong: "SyntaxError: unexpected token"

Phase 3: SEMANTIC ANALYSIS
  → Checks meaning: Is x declared? Are 5 and 3 compatible types?
  → Type checking, scope resolution

Phase 4: INTERMEDIATE CODE GENERATION
  → Generates platform-independent representation
  → t1 = 5 + 3;  x = t1;

Phase 5: CODE OPTIMIZATION
  → Simplifies: x = 8  (constant folding — computed at compile time!)

Phase 6: CODE GENERATION
  → Produces machine code for the target CPU (x86, ARM, etc.)
  → MOV EAX, 8

GCC (GNU Compiler Collection) compiles C/C++ — used to compile the Linux kernel, ISRO's flight software, and most embedded systems. javac compiles Java to bytecode — powering Android apps and banking systems at SBI. LLVM/Clang is used by Apple for iOS apps and by Google for Chrome.

An interpreter reads and executes source code line by line at runtime. No separate executable is produced. The interpreter must be present every time the program runs.

Like a live translator at a UN conference — translates each sentence as the speaker says it. Slower than having a pre-translated book, but you can start immediately without waiting for the full translation.

Python (CPython interpreter) — used at Google, Netflix, Instagram, and every AI/ML project. JavaScript (V8 engine in Chrome, Node.js) — powers every website. Ruby (MRI interpreter) — used at Shopify, GitHub (originally).