Computer System

A computer system is an electronic machine that accepts raw data, processes it using a stored set of instructions, and gives out information. Keep those two words apart in the exam. Data is raw and by itself meaningless — 245. Information is processed data that answers something — "your electricity bill is Rs 1465".

Every job a computer does, from adding two numbers to booking a Tatkal ticket on IRCTC, follows the same three-stage IPO cycle: Input, then Process, then Output. A fourth stage, Storage, sits alongside so results survive after the machine is switched off. When you pay by UPI, the touchscreen takes the input (amount and PIN), the processor and the bank's servers do the processing, the "Payment Successful" screen is the output, and the entry in your passbook is the storage.

Hardware is every part you can touch — the keyboard, the motherboard, the RAM stick, the printer. Software is the set of instructions that tells the hardware what to do; you cannot touch it, you can only copy it. Neither is useful alone. Hardware without software is a dead box of metal; software without hardware is a file that nobody can run.

The five functional units. Whatever the size of the machine — a supercomputer at C-DAC or the chip inside a washing machine — the same five blocks are present.

   +-------------+       +--------------------------+       +--------------+
   | INPUT UNIT  | ----- |   CPU                    | ----- | OUTPUT UNIT  |
   | keyboard,   |       |  +--------+  +--------+  |       | monitor,     |
   | mouse,      |       |  |   CU   |  |  ALU   |  |       | printer,     |
   | scanner     |       |  +--------+  +--------+  |       | speaker      |
   +-------------+       |  +------------------+    |       +--------------+
                         |  |    REGISTERS     |    |
                         |  +------------------+    |
                         +--------------------------+
                                     |
                         +---------------------------+
                         |  MEMORY UNIT              |
                         |  primary (cache/RAM/ROM)  |
                         |  secondary (HDD/SSD/pen)  |
                         +---------------------------+

1. Input unit — accepts data from outside and converts it into the binary form the machine understands.
2. Memory unit — holds the data and the instructions while work is going on.
3. Control Unit (CU) — the manager. It fetches each instruction, decodes it, and sends control signals telling the other units what to do. It does no calculation itself.
4. Arithmetic Logic Unit (ALU) — does the actual work: arithmetic (+ - * / // %) and logic (comparisons, and, or, not).
5. Output unit — converts the binary result back into a form a human can use.

The CPU (Central Processing Unit), also called the processor or the microprocessor, is the CU and the ALU together, plus a small set of registers. Registers are the CPU's own tiny, extremely fast storage — the accumulator, the program counter (which holds the address of the next instruction), the instruction register and the memory address register. They hold one value at a time, and they are the fastest storage in the whole machine because they sit inside the processor itself.

The CPU repeats one loop, the machine cycle: Fetch the next instruction from memory, Decode it, Execute it, Store the result. Everything inside the CPU is kept in step by a clock, and clock speed is simply how many clock pulses, or cycles, that clock produces per second. A 3.2 GHz processor produces 3.2 billion clock cycles a second. Be careful not to read that as 3.2 billion instructions a second — one machine cycle normally takes several clock cycles, so the two numbers are not the same. Note the other trap too: for clock speed, giga means 1,000,000,000 exactly, but for memory, giga means 1024 x 1024 x 1024. The two "giga"s are not the same number.

All these units are mounted on or plugged into the motherboard and talk to each other over the system bus, which has three parts: the address bus (which memory location), the data bus (what value) and the control bus (read or write).

The single idea that makes a computer general-purpose is the stored program concept: instructions and data both live in the same main memory. That is why one laptop can be a music player at 9 pm and a Python IDE at 10 pm — you change the instructions in memory, not the hardware.

Worked example 1 — the IPO cycle in code. This program is nothing but Input, Process, Output.

# INPUT: the keyboard (an input device) sends the digits to the CPU
units = int(input("Units consumed: "))
print("Value now in main memory:", units)

# PROCESS: the ALU inside the CPU does the arithmetic
if units <= 100:
    bill = units * 4.5
else:
    bill = 100 * 4.5 + (units - 100) * 7.0

# OUTPUT: the monitor (an output device) shows the answer
print("Electricity bill = Rs", bill)

Output when the value 245 is supplied to the program:

Units consumed: Value now in main memory: 245
Electricity bill = Rs 1465.0

The first line looks squashed for a good reason. The prompt "Units consumed: " is printed without moving to a new line, and here the 245 was fed straight in rather than typed, so nothing was echoed after the prompt and the next print() continued on the very same line. When you run it and type 245 yourself, the digits you type appear after the prompt and the rest follows below. Notice also that input() handed over the characters 2, 4, 5 as a string — int() had to convert them into a number before the ALU could multiply anything.

Worked example 2 — what the ALU actually does. The "A" and the "L" of ALU, in one program.

a = 17
b = 5
# Arithmetic work - the "A" of ALU
print(a + b, a - b, a * b, a // b, a % b)
# Logic work - the "L" of ALU
print(a > b, a == b, a > b and b > 0, not (a < b))

Output:

22 12 85 3 2
True False True True

Every high-level thing your computer does — playing a video, checking an Aadhaar OTP, rendering this page — is finally broken down into millions of these two kinds of operation.

The CPU understands only numbers in binary. So the real job of an input device is translation: it takes something from the human world — a key press, a fingerprint, a spoken word, a printed barcode — and converts it into a pattern of 0s and 1s. An output device does the reverse translation, turning a binary result back into something a person can read, see or hear.

Common input devices

Common output devices. Output comes in two forms. A soft copy is temporary and electronic — it lives on a screen or in a speaker and disappears when you close the window. A hard copy is permanent and physical — printed on paper.

Some devices do both jobs and are called I/O devices: a touchscreen (it displays and it accepts taps), a modem, a network interface card, and a headset with a microphone. In an exam, if a device both accepts and delivers data, say "input as well as output device" and give the reason.

Devices plug into the computer through ports — USB, HDMI, audio jack, Ethernet — and each device needs its matching device driver in software, which you will meet in the software section.

Worked example 1 — a keyboard does not send letters, it sends numbers. The built-in function ord() shows the code number stored for a character, chr() converts a number back into a character, and bin() shows that number in binary.

name = "Anjali"
for ch in name:
    print(ch, "->", ord(ch), "->", bin(ord(ch)))

print()
print("Rebuilt from numbers:", chr(65) + chr(110) + chr(106))
print("Rupee sign code:", ord("₹"))

Output:

A -> 65 -> 0b1000001
n -> 110 -> 0b1101110
j -> 106 -> 0b1101010
a -> 97 -> 0b1100001
l -> 108 -> 0b1101100
i -> 105 -> 0b1101001

Rebuilt from numbers: Anj
Rupee sign code: 8377

Read that carefully. The letter A is not stored as a shape; it is stored as the number 65, which in memory is the bit pattern 1000001. Capital A is 65 and small a is 97 — they are different numbers, which is exactly why the machine treats them as different characters. The rupee sign is 8377, a number far too big for the old 8-bit codes, which is why modern systems use Unicode.

Worked example 2 — controlling what goes to the output device. print() is how a Python program sends characters to the standard output device. Its sep argument decides what is placed between the values and end decides what is placed after the last one.

print("Ravi", "Meena", "Sunil")
print("Ravi", "Meena", "Sunil", sep=", ")
print("Loading", end="")
print(".", end="")
print(".", end="")
print(".")
print("Roll", "Marks", sep="\t")
print(11, 87, sep="\t")

Output:

Ravi Meena Sunil
Ravi, Meena, Sunil
Loading...
Roll	Marks
11	87

The default sep is a single space and the default end is a newline, which is why the first line has gaps and each ordinary print() moves to a fresh line. Setting end="" keeps the cursor on the same line — that is how the three dots of "Loading..." came from three separate statements.

Memory is where the computer keeps data and instructions. It is not one thing but a hierarchy. As you move towards the CPU the memory gets faster, smaller and costlier per byte; as you move away it gets slower, bigger and cheaper. The design exists because fast memory is expensive, so you can only afford a little of it.

Primary memory is the memory the CPU can reach directly. It has two parts.

• RAM (Random Access Memory) — the working memory. Every program you open is copied from the hard disk into RAM before it can run. RAM is volatile: cut the power and everything in it is gone, which is why unsaved work is lost when the light goes. "Random access" means any location can be reached in the same time, unlike a tape you must wind through. Two types: SRAM (static, faster, costlier, used for cache) and DRAM (dynamic, needs constant refreshing, cheaper, used as main memory).
• ROM (Read Only Memory) — non-volatile memory written by the manufacturer, holding the start-up instructions the machine needs the moment it is switched on. Without ROM the computer could not even begin booting, because RAM is empty at power-on. Variants: PROM (programmable once), EPROM (erasable with ultraviolet light) and EEPROM (erasable electrically).

Cache memory is a small block of very fast memory placed between the CPU and RAM. It exists because of a speed gap: the CPU can work far faster than RAM can hand over data, so without cache the processor would spend most of its time waiting. The cache holds the instructions and data the CPU has used recently or is likely to use next — programs tend to reuse the same few things again and again, and cache exploits that. If the CPU finds what it wants in cache that is a cache hit; if not it is a cache miss and the slower trip to RAM happens. Do not confuse cache with RAM: cache is smaller, faster and costlier per byte, and you never buy it separately.

Secondary memory is permanent storage. The CPU cannot execute anything directly from here — the data must first be copied into RAM. It is non-volatile, cheap per byte and removable in many forms.

• Hard disk drive (HDD) — magnetic platters that spin under a read/write head. Large and cheap, but has moving parts.
• Solid state drive (SSD) — flash memory, no moving parts, much faster than an HDD, costlier per GB.
• Pen drive and memory card — flash memory in a small removable package.
• Optical discs — CD (nominally 700 MB), DVD (nominally 4.7 GB for a single layer), Blu-ray. Read by a laser.
• Cloud storage — space on somebody else's server, reached over the internet. Convenient, but it is not on your machine and it needs a connection.

Units of memory. The smallest unit is the bit (binary digit), which is a single 0 or 1. Four bits make a nibble. Eight bits make a byte, and one byte is the space needed for one ordinary character. Above that, every step multiplies by 1024, not by 1000, because computers count in powers of two and 2¹⁰ = 1024. Write it exactly like this in the exam.

Worked example 1 — the conversions, done by the machine itself.

KB = 1024
MB = 1024 * KB
GB = 1024 * MB
TB = 1024 * GB

print("1 KB =", KB, "bytes")
print("1 MB =", MB, "bytes")
print("1 GB =", GB, "bytes")
print("1 TB =", TB, "bytes")
print("1 GB in bits =", GB * 8, "bits")
print()

# How many 5 MB songs fit on a 16 GB pen drive?
drive = 16 * GB
song = 5 * MB
print("Songs that fit:", drive // song)
print("Bytes left over:", drive % song)

Output:

1 KB = 1024 bytes
1 MB = 1048576 bytes
1 GB = 1073741824 bytes
1 TB = 1099511627776 bytes
1 GB in bits = 8589934592 bits

Songs that fit: 3276
Bytes left over: 4194304

Note the two operators doing the real work. // gives the whole number of songs that fit and % gives the unused bytes left over — exactly the pair you need for "how many files fit" numericals.

Worked example 2 — why a photo takes the space it does. An image is a grid of pixels, and a 24-bit colour pixel needs 3 bytes (8 bits each for red, green and blue).

width = 1920
height = 1080
bytes_per_pixel = 3          # 24-bit colour: 8 bits each for R, G and B

total_bytes = width * height * bytes_per_pixel
print("Raw size in bytes:", total_bytes)
print("Raw size in KB   :", total_bytes / 1024)
print("Raw size in MB   :", total_bytes / (1024 * 1024))
print("Rounded to 2 dp  :", round(total_bytes / (1024 * 1024), 2), "MB")

disk = 2 * 1024 * 1024 * 1024 * 1024   # a 2 TB hard disk
print("Such photos on a 2 TB disk:", disk // total_bytes)

Output:

Raw size in bytes: 6220800
Raw size in KB   : 6075.0
Raw size in MB   : 5.9326171875
Rounded to 2 dp  : 5.93 MB
Such photos on a 2 TB disk: 353495

Worked example 3 — why your 1 TB hard disk shows 931 GB. This is the 1024-versus-1000 rule biting in real life. Disk manufacturers count 1 KB as 1000 bytes; the operating system counts it as 1024.

# What a hard-disk box says vs what Windows shows
box_bytes = 1000 * 1000 * 1000 * 1000     # maker counts 1 KB = 1000 bytes
GB = 1024 * 1024 * 1024                   # the OS counts 1 KB = 1024 bytes
print("Box says      : 1 TB")
print("Actual bytes  :", box_bytes)
print("OS shows      :", round(box_bytes / GB, 2), "GB")

Output:

Box says      : 1 TB
Actual bytes  : 1000000000000
OS shows      : 931.32 GB

Nobody has cheated you of the missing 68.68 GB — the two sides are simply using two different meanings of "tera". For the CBSE exam, always use 1024.

Software is grouped into three categories. Getting an item into the right box is a standard one-mark question.

1. System software. It has three kinds.

• Operating system — the master control program, covered in the next section.
• System utilities — small programs that keep the machine healthy: antivirus, disk defragmenter, disk cleanup, file compression tools (7-Zip, WinZip), backup and restore tools, disk checkers. They maintain the computer; they do not do the user's own work.
• Device drivers — a small program that acts as a translator between the OS and one particular piece of hardware. Every printer model, graphics card and scanner speaks its own language, and the OS cannot be built knowing all of them. The driver bridges that gap, which is why a printer that worked yesterday can stop working after a fresh Windows install: the driver is missing. "Plug and play" simply means the OS already carries or automatically fetches the driver.

2. Programming tools and language translators. To understand why translators exist, look at the three levels of language.

A tiny assembly-language fragment looks like this (this is not Python and will not run in Python):

MOV AL, 5      ; put 5 into register AL
ADD AL, 3      ; add 3 to it

The program you write is called source code; what the translator produces is object code or machine code.

• Assembler — translates assembly language into machine code. The translation is essentially one statement to one machine instruction.
• Compiler — reads the entire high-level source program, translates it in one go, and writes out a separate executable file. All errors found during translation are reported together. Once the executable exists, it runs on its own and the compiler is no longer needed. C and C++ use compilers.
• Interpreter — translates and executes one statement at a time. No separate executable is produced, so the interpreter must be present every time the program runs. It stops at the first statement that fails. Python uses an interpreter.

Compiler versus interpreter — learn this table. It is asked almost every year.

3. Application software. Software written to do a job for the user, not for the machine.

• General purpose / packages — usable by anyone: word processor, spreadsheet, presentation tool, web browser, media player, image editor.
• Customised or tailor-made — built for one organisation or one task: Tally for accounting, a school ERP, a railway reservation system, a hospital billing system, a bank's core banking software.

Worked example — proving that Python is interpreted. Run this file, which has a mistake on line 3.

print("Line 1 ran")
print("Line 2 ran")
print(10 / 0)          # run-time error is HERE
print("Line 4 never runs")

Output:

Line 1 ran
Line 2 ran
Traceback (most recent call last):
  File "C:\pytmp\demo1.py", line 3, in 
    print(10 / 0)          # run-time error is HERE
          ~~~^~~
ZeroDivisionError: division by zero

This is the interpreter's signature behaviour. Lines 1 and 2 were translated, executed and printed before Python ever looked at line 3. A compiled language would have refused to produce an executable at all, so nothing would have been printed. Line 4 is never reached.

The sharp detail most students miss. It is not true that Python checks nothing in advance. Before execution begins, CPython reads the whole file and checks its grammar. So a syntax error anywhere kills the program before a single line runs. Same file, but with a missing bracket on line 3:

print("Line 1 ran")
print("Line 2 ran")
print("oops"
print("Line 4")

Output:

  File "C:\pytmp\demo2.py", line 3
    print("oops"
         ^
SyntaxError: '(' was never closed

Notice that "Line 1 ran" did not appear this time. Hold both facts together: a syntax error stops the whole file before anything runs, while a run-time error stops the program only at the line where it happens, after the earlier lines have already done their work.

An operating system (OS) is the system software that controls the whole computer. It has two jobs at once. It is a resource manager, deciding who gets the CPU, the RAM and the printer and for how long, and it is an interface between the user and the hardware, so you never have to know how a hard disk is wired in order to save a file.

The OS is the first major program loaded when you switch on. That process is booting: ROM runs the start-up instructions and a self-check, then the core of the OS, called the kernel, is loaded from the hard disk into RAM and stays there as long as the machine is on. Starting from a powered-off state is cold booting; restarting a machine that is already running is warm booting.

Functions of the operating system

1. Process management — a process is a program in execution. The OS decides which process gets the CPU next and for how long (scheduling), keeps track of every running process, and removes it when it finishes. On a single CPU, only one process actually runs at any instant; the OS switches between them so fast that multitasking looks simultaneous.
2. Memory management — the OS allocates RAM to each program, keeps one program from writing into another's space, and frees that RAM when the program closes. If RAM runs short it can use part of the disk as virtual memory, which is why a machine with too little RAM becomes very slow.
3. File management — creating, naming, opening, reading, copying, moving and deleting files and folders, and remembering where each file physically sits on the disk. It also enforces who may open which file.
4. Device management — controlling every input and output device through its device driver, and using buffering and spooling so a slow device does not hold up the CPU. When you send five documents to a printer, spooling is what queues them.
5. Security and protection — user accounts, passwords, file permissions, and stopping one user or program from interfering with another.
6. Command interpretation and user interface — accepting what the user asks for, whether typed or clicked, and carrying it out.

Types of OS user interface. The interface is how you tell the OS what you want.

Some operating systems you will be asked to name: Windows, Linux and its distributions such as Ubuntu and Fedora, macOS, and for mobile devices Android and iOS. India has its own Linux distribution, BOSS (Bharat Operating System Solutions), developed by C-DAC.

Worked example — what the OS is juggling. Three programs each need the CPU. The OS runs them one after another in the order they arrived, which is the simplest scheduling policy of all. The program below works out how long each one waits.

# Three programs each need the CPU. The OS runs them one after another,
# in the order they arrived - the simplest scheduling policy of all.
burst_chrome = 5          # CPU time each job needs, in milliseconds
burst_vlc    = 3
burst_python = 8

wait_chrome = 0                                 # arrived first, waits for nobody
wait_vlc    = burst_chrome                      # waits while Chrome runs
wait_python = burst_chrome + burst_vlc          # waits for both of them

print("Job", "Burst", "Waiting", sep="\t")
print("Chrome", burst_chrome, wait_chrome, sep="\t")
print("VLC", burst_vlc, wait_vlc, sep="\t")
print("Python", burst_python, wait_python, sep="\t")

total = burst_chrome + burst_vlc + burst_python
average = (wait_chrome + wait_vlc + wait_python) / 3
print("Total CPU time used :", total, "ms")
print("Average waiting time:", round(average, 2), "ms")

Output:

Job	Burst	Waiting
Chrome	5	0
VLC	3	5
Python	8	8
Total CPU time used : 16 ms
Average waiting time: 4.33 ms

Chrome waits nothing because it arrived first, VLC waits the 5 ms Chrome took, and Python waits for both, so the average wait is (0 + 5 + 8) / 3 = 4.33 ms. This is process management in miniature. Change the order and the average waiting time changes — which is exactly the kind of decision a real scheduler makes thousands of times a second, and the reason your machine still responds to the mouse while a large file is copying.