Chapter 1 — Introduction To Computer Systems

What is a computer system? A computer system is an integrated set of hardware and software that accepts data (input), processes it to produce useful information (output), and stores results for future use. It performs automated, high‑speed, and accurate computations and information processing.

Main components

• Hardware – physical parts such as CPU (processor), memory, storage devices, and input/output devices.
• Software – programs and instructions. Two broad classes: system software (operating system, device drivers, utilities) and application software (word processors, browsers, accounting packages).
• Users – people who interact with the system to get tasks done.

Basic functional units (I‑P‑O‑S model)

• Input – devices that feed data (keyboard, mouse, scanner, sensors).
• Processing – CPU performs arithmetic/logic and controls operations (Control Unit, ALU, registers).
• Output – devices that present information (monitor, printer, actuators).
• Storage – primary (RAM, cache) and secondary (HDD, SSD, optical, cloud) memory for temporary and permanent data.

Von Neumann architecture & Fetch‑Decode‑Execute cycle

Most general‑purpose computers follow the Von Neumann model: a single memory holds both instructions and data. The CPU repeatedly executes the fetch‑decode‑execute cycle:

• Fetch – fetch instruction from memory into Instruction Register (IR).
• Decode – Control Unit decodes the instruction.
• Execute – ALU performs arithmetic/logic or a control action; results stored in registers or memory.

Types of computer systems

• Supercomputers – highest performance for scientific tasks.
• Mainframes – large organizations, transaction processing.
• Minicomputers / Servers – multi‑user services.
• Microcomputers / Personal computers – desktops, laptops.
• Embedded systems – dedicated devices (microwave, washing machine controllers, IoT devices).

Key characteristics: speed, accuracy, automation, storage capability, versatility, reliability.

System software vs Application software

• System software manages hardware and provides services (OS schedules tasks, manages memory, handles I/O).
• Application software performs user‑oriented tasks (document editing, web browsing, games).

Performance factors include clock speed, CPU architecture, number of cores, memory size & speed, cache, storage type (HDD vs SSD), and I/O bandwidth. Tradeoffs often exist between speed, cost, and storage capacity.

Security & networks (brief): Modern computer systems are often networked; security (authentication, authorization, encryption, backups) is essential to protect data and ensure reliable operation.

Computers are electronic machines that accept data (input), process it according to programmed instructions, store results, and produce output. Their behaviour is defined by a set of characteristic properties that explain why they are widely used across science, business and everyday life.

• Speed: Computers perform millions to billions of operations per second. This allows rapid arithmetic and logical processing of large datasets.
• Accuracy: When given correct instructions and data, computers compute results without human error (subject to hardware/software bugs or input errors).
• Diligence: Computers do repetitive tasks tirelessly without loss of performance (no boredom or fatigue).
• Automation / Programmability: A computer executes instructions automatically. Changing behaviour is done by changing the program.
• Versatility: The same hardware can perform diverse tasks — word processing, web browsing, scientific simulation — by running different software.
• Storage capacity: Computers can store and retrieve huge amounts of data in memory and secondary storage.
• Reliability: Modern systems are designed for long continuous operation with error-checking, backups and redundancy to reduce failures.
• Electronic nature: Because they use electronic circuits, response times are extremely fast compared with mechanical systems.
• Determinism: Given the same program and inputs, a computer produces the same output (repeatability).
• Multitasking and parallelism: Computers can run multiple programs or use multiple processors/cores to handle tasks concurrently.
• Connectivity: Networking enables sharing resources and remote communication (internet, clouds), expanding capability beyond one machine.
• Limitations: Computers are not intelligent by themselves — they cannot think or create without human-provided algorithms and data. They require power, correct instructions, and may fail if hardware/software is faulty.

Understanding these characteristics helps explain where computers add value (speed, scale, repeatability) and where human judgment remains essential (creativity, ethics, contextual decisions).

Overview: Computers are classified to understand their size, power, purpose and mode of operation. Common classification schemes used in Class 11 Informatics Practices are by size/performance, by purpose, by type of data processed, by number of users and by mode of processing.

1. By Size and Performance

• Microcomputer (Personal Computer): Small, single-user machines such as desktops, laptops, tablets and smartphones. Used for word processing, web browsing, small-scale programming and personal use. Low cost, low power and low FLOPS compared to larger machines.
• Minicomputer (Midrange Servers): Mid-level machines used by small businesses or departments for moderate workloads, multi-user support and small databases. Often called servers in modern contexts.
• Mainframe: Large, powerful systems used by big organisations (banks, airlines, government) for transaction processing, large databases and critical multi-user tasks. High reliability and throughput.
• Supercomputer: Extremely powerful computers optimized for complex scientific calculations (weather forecasting, simulations, nuclear research, large-scale modeling). Highest FLOPS and cost.

2. By Purpose

• General-purpose computers: Designed to perform a wide range of tasks (e.g., PCs, servers).
• Special-purpose computers: Built for a specific task (e.g., ATM machines, digital watches, embedded controllers in washing machines).

3. By Type of Data Processed

• Analog computers: Work with continuous data (examples: older scientific instruments, analog speedometers).
• Digital computers: Work with discrete (binary) data; most modern computers are digital.
• Hybrid computers: Combine analog and digital features; used in specialized fields like medical equipment and process control.

4. By Number of Users

• Single-user systems: One user at a time (typical PCs, tablets).
• Multi-user systems: Support simultaneous access by many users (mainframes, servers, time-sharing systems).

5. By Mode of Processing

• Batch Processing: Jobs collected and processed together (historical payroll systems).
• Time-sharing / Interactive: CPU time is shared among users so many can interact concurrently (multi-user servers, university systems).
• Real-time Processing: Immediate processing and response (air-traffic control systems, industrial controllers).
• Distributed Processing: Processing distributed across multiple machines connected by a network (cloud computing, clusters).

Key comparisons (conceptual): As you move from micro → mini → mainframe → supercomputer, processing power (FLOPS) and cost generally increase, while portability decreases. Purpose shifts from general personal tasks to highly specialized, large-scale scientific and transaction workloads.

Practical notes for students: When classifying a computer, identify its scale (small/large), intended purpose (general/special), how many users it supports, the nature of data processed, and its processing mode (batch, real-time, etc.).

What is a computer system? A computer system is an integrated set of hardware and software components that accepts data (input), processes it according to instructions (processing), stores results (storage), and provides output. Components work together via buses and firmware to perform tasks.

High-level classification

• Hardware – physical parts: CPU, memory, storage, motherboard, I/O devices, power supply, network interfaces, GPU, etc.
• Software – programs and data: operating system, application software, firmware (BIOS/UEFI).

Major hardware components

• CPU (Central Processing Unit): brain of the computer. Consists of the Control Unit (CU), Arithmetic Logic Unit (ALU), registers, and often on-chip cache (L1/L2/L3). It follows the fetch–decode–execute cycle to run instructions. Key characteristics: clock speed (Hz), number of cores, cache size, instruction set.
• Main memory (Primary): volatile memory used for executing programs. RAM (DRAM) stores running programs and data; ROM/flash contains firmware. Characteristics: access time (ns), capacity (bytes).
• Cache: small, very fast memory between CPU and RAM that reduces average access time. Organized in levels (L1 fastest, L3 larger/slower).
• Secondary storage: non-volatile mass storage (HDD, SSD, optical discs, flash drives). Used for long-term storage. Characteristics: capacity, access time, transfer rate.
• Motherboard & buses: motherboard hosts CPU socket, memory slots, chipset and provides buses (data, address, control) that carry information between components. Expansion buses connect peripherals (PCIe, USB).
• I/O devices: input devices (keyboard, mouse, scanner), output devices (monitor, printer, speakers), and combined (touchscreens). Interfaces include USB, HDMI, Ethernet.
• GPU / Graphics card: specialized processor for graphics and parallel computation (used for gaming, video, machine learning).
• Network Interface: wired/wireless adapters for network connectivity (Ethernet, Wi‑Fi).
• Power supply & cooling: provide stable power and remove heat (fans, heatsinks).

How components interact

• Programs/instructions are stored in secondary storage. When executed, code is loaded into RAM.
• The CPU fetches instructions from memory, decodes them, executes them (ALU), and reads/writes data back to registers or memory.
• Buses carry data, addresses and control signals between CPU, memory and I/O.
• Peripherals communicate through controllers and device drivers (software) managed by the OS.

Memory hierarchy (concept): registers → L1/L2/L3 cache → RAM → SSD/HDD → Removable/Tertiary storage. Lower levels are faster but more expensive per byte; higher levels are slower but larger and cheaper.

Performance factors include CPU clock, number of cores, CPI (cycles per instruction), memory latency, cache hits/misses, I/O throughput and bus bandwidth. Optimising systems often means balancing CPU speed, memory speed/size, and storage performance.

Types of systems: personal computers, laptops, servers (more CPU/RAID/backup & network capacity), embedded systems (appliances, controllers), mobile devices (smartphones with integrated SoC).

Summary: Understanding components, their characteristics and interactions helps explain why some tasks run faster on some systems and how to make informed choices when designing or buying computers.

Definition
Input devices are hardware components that allow users or external systems to enter data and control signals into a computer for processing. They convert human-readable or physical-world information (text, images, sound, motion, biometric data) into electrical signals or digital data the computer can process.

Role in the computer system
Input devices are the first link in the input–process–output cycle. Typical steps: sensing/actuation → signal conditioning (if analog) → analogue-to-digital conversion (ADC) → buffering/transfer → CPU/RAM.

Classification (by data type and use)

• Text/command entry: keyboards, numeric keypads.
• Pointing/navigation: mouse (mechanical/optical/laser), touchpad, trackball, stylus, touchscreen.
• Imaging/graphics: flatbed/handheld/film scanners, digital cameras, webcams, graphic tablets.
• Audio: microphones (analog → ADC), musical MIDI controllers.
• Biometric/security: fingerprint readers, iris scanners, face recognition cameras, voice recognition.
• Machine/automatic data collection: barcode scanners, QR readers, RFID readers, magnetic stripe & smart card readers, MICR for cheques.
• Controls and gaming: joysticks, gamepads, steering wheels.
• Sensors and IoT inputs: temperature, pressure, light, motion sensors feeding microcontrollers/PCs.

How common devices work (brief)

• Keyboard: matrix of switches; pressing closes a row–column circuit; controller encodes key scan code and sends to OS via USB/PS2.
• Mouse: optical mice use an LED/laser and an optical sensor to detect surface motion and translate to X/Y movement; scroll wheel and buttons generate events.
• Touchscreen: resistive (pressure-based) or capacitive (change in electrostatic field) detect touch coordinates; multi-touch for gestures.
• Scanner/digital camera: use CCD/CMOS sensors to sample light; produce pixel arrays. Resolution (DPI or pixels) and color depth determine image quality and file size.
• Microphone: converts sound pressure (analogue) to voltage, then ADC samples and quantizes to digital audio (sample rate, bit depth).
• Barcode/RFID: barcode scanners read reflected light patterns; RFID uses radio-frequency communication with tags; both translate physical identifiers into digital codes.
• Biometric sensors: capture unique biological patterns, preprocess, and convert to numeric templates for matching.

Important performance metrics

• Resolution: DPI (dots per inch) for scanners; pixels (width × height) for cameras.
• Color depth / bit depth: bits per pixel (e.g., 24-bit = true color).
• Sampling rate (audio): samples per second (Hz); affects frequency range.
• Latency & polling rate: important for mice/game controllers (e.g., 125 Hz to 1000 Hz).
• Accuracy & precision: for pointing devices and sensors.
• Throughput / speed: e.g., pages per minute for document scanners, scans/sec for barcode readers.

Interfaces & connectivity
Input devices connect via wired interfaces (USB, PS/2, Serial) or wireless (Bluetooth, RF). Many devices use standard drivers/profiles (HID for keyboards/mice).

Applications / examples
Everyday use includes typing (keyboard), navigating (mouse), smartphone touch interaction (touchscreen), scanning documents (scanner), supermarket checkout (barcode scanner), ATM transactions (card reader, PIN keypad), biometric attendance systems (fingerprint), voice assistants (microphone), photography and video conferencing (digital camera/webcam), and gaming (joysticks/gamepads).

Ergonomics, maintenance & security
Ergonomic design reduces strain (ergonomic keyboards, vertical mice). Maintain by cleaning sensors and connectors. Security: biometric spoofing, card skimmers, and malware-infected input devices are risks—use trusted hardware and encryption where applicable.

Hardware: Output Devices

Output devices are hardware components that present processed data from a computer to the user or another device in human- or machine-readable form. They convert electronic signals into visual, audible or physical forms. Common categories include display devices (monitors, projectors), printing devices (printers, plotters), audio devices (speakers, headphones), and specialized accessibility/haptic devices (braille displays, haptic actuators).

Major types and how they work (brief)

• Monitors / Displays: Show visual output as a grid of pixels. Technologies: CRT (cathode-ray tube), LCD (liquid crystal display) with LED backlight, OLED (organic LED). Key parts: pixel matrix, controller, backlight (for LCD), driver electronics.
• Projectors: Magnify display content onto a screen using optical projection. Types: DLP, LCD, LCoS. Used in classrooms, meetings, cinemas.
• Printers: Produce physical copies on paper. Impact printers (dot-matrix) use pins; non-impact printers include inkjet (spray droplets) and laser (electrostatic toner fused to paper).
• Plotters: Large-format printers for vector-based drawings (engineering, CAD) that move pens or cutters precisely.
• Speakers and Headphones: Convert electrical audio signals to sound via diaphragm movement (dynamic, electrostatic types).
• Braille displays / Haptic devices: Provide tactile output for visually impaired users or force/feedback sensations for VR and devices.

Key characteristics and how they affect output

• Resolution: Number of pixels horizontally × vertically (e.g., 1920 × 1080). Higher resolution = sharper image.
• Pixel density (PPI): Pixels per inch. Higher PPI = finer detail on same-size screen.
• Refresh rate: Measured in Hz (frames per second). Higher refresh rates give smoother motion (important for video and gaming).
• Response time: Time for a pixel to change state (ms). Lower response prevents motion blur.
• Color depth: Bits per pixel (bpp). Number of colors = 2^(bpp). Typical: 24-bit color = ~16.7 million colors.
• Brightness: Measured in candela per square meter (cd/m²). Determines visibility in bright environments.
• Contrast ratio: Ratio of maximum to minimum display luminance; higher means deeper blacks and more vivid images.
• Dot pitch / pixel pitch: Distance between sub-pixels; smaller pitch = sharper image.
• Printer dpi: Dots per inch for printers; higher dpi = finer printed detail.

Typical uses (learning, offices, multimedia)

• Monitors/Projectors for lectures, presentations, graphic design, programming and browsing.
• Printers for reports, assignments, photographs, legal documents.
• Plotters for engineering drawings and large posters.
• Speakers/headphones for audio lessons, multimedia, assistive listening.
• Braille displays for accessibility in exams and learning for visually impaired students.

Practical considerations

• Choose display based on resolution and size (PPI) for clear text and images.
• For printing, select printer type by volume and quality: laser for text speed and low cost per page; inkjet for high-quality photos.
• Match refresh rate and response time to application: gaming needs high refresh and low response; reading needs high resolution and comfortable brightness.
• Consider connectivity (HDMI, DisplayPort, USB, wireless) and driver support for the operating system.

Summary: Output devices present processed data to users in various forms (visual, printed, audio, tactile). Each device type has specific characteristics (resolution, dpi, refresh rate, color depth, brightness) that determine suitability for different tasks such as text editing, graphics work, printing photos, or accessibility.

What is storage? Storage devices and media are hardware components used to record and retain digital information — programs and data — for short-term or long-term use. They differ by capacity, speed, volatility, access method and portability.

Classification

• Primary (volatile) storage: Directly accessible by the CPU. Example: RAM (Random Access Memory). Contents are lost when power is off.
• Secondary (non‑volatile) storage: For long‑term storage connected to the system: hard disk drives (HDD), solid state drives (SSD), optical disks (CD/DVD/Blu‑ray), flash drives. Data persists without power.
• Tertiary & offline storage: Removable or large‑scale archive media used for backups and archiving: magnetic tape libraries, removable disks, external drives, cloud storage.

Types of media and devices (brief)

• Magnetic: HDDs and magnetic tape. Uses magnetized surfaces to store bits. Good capacity and cost per GB, moderate access speed (HDD has moving parts).
• Solid state (flash): SSDs, USB flash drives, memory cards. No moving parts, fast access, more durable, generally higher cost per GB than HDD (though prices change).
• Optical: CD/DVD/Blu‑ray. Read/write/ROM variants. Good for distribution and offline backups, slower access.
• Hybrid/other: SSHD (hybrid HDD+SSD), cloud storage (remote servers accessed over Internet).

Key characteristics and tradeoffs

• Capacity: How much data can be stored (bytes, KB, MB, GB, TB).
• Access time / latency: How quickly a device can start delivering requested data. RAM and SSDs have very low latency; HDDs have higher latency due to seek+rotational delay.
• Throughput / transfer rate: Amount of data moved per unit time (MB/s, GB/s).
• Volatility: Whether data is retained without power (volatile = RAM; nonvolatile = HDD/SSD).
• Access method: Random access (most RAM, SSDs) vs sequential access (magnetic tape).
• Durability & physical sensitivity: SSDs tolerate shocks better than HDDs; optical discs scratchable; flash has limited write cycles.
• Cost per GB: Important for choosing media for backups and archives.

Where each is used (practical roles)

• Registers / Cache / RAM: Fast temporary storage for CPU and running programs.
• SSD/HDD (internal): System/ application files, user documents, games, databases.
• External HDD / USB flash / memory cards: Portable data transport and backups.
• Optical discs / tapes: Distribution, long‑term archiving and backups (tape used in enterprise backup systems).
• Cloud storage: Off‑site storage for collaboration, backup and scaling without physical media management.

Care & best practices

• Keep backups: 3‑2‑1 rule (3 copies, 2 different media, 1 offsite) is common.
• Avoid physical damage (shock, moisture) to removable media and drives.
• Monitor SSD wear and HDD SMART health for failures.
• Encrypt sensitive data on removable or cloud media.

Summary: Choose storage based on required speed, capacity, durability and cost. For OS and frequently used apps choose fast (SSD/RAM); for inexpensive bulk storage choose HDD or tape; for portability choose flash drives or memory cards; for collaboration and redundancy choose cloud with proper backups.

What is a CPU?
The Central Processing Unit (CPU) is the primary component of a computer that performs computation and controls the execution of instructions. It is often called the "brain" of the computer because it interprets program instructions and processes data.

Major components of a CPU

• Control Unit (CU): Directs the operation of the processor by fetching instructions from memory, decoding them, and coordinating the execution steps.
• Arithmetic Logic Unit (ALU): Performs arithmetic (addition, subtraction) and logical (AND, OR, NOT) operations.
• Registers: Small, very fast storage locations inside the CPU used to hold instructions, addresses, counters and intermediate data (e.g., Program Counter, Instruction Register, Accumulator).
• Cache Memory: Small, fast memory (L1, L2, sometimes L3) placed close to the CPU to reduce the average time to access data from main memory (RAM).
• Buses: Communication pathways (data bus, address bus, control bus) that transfer data and signals between CPU, memory and I/O devices.

How the CPU works: The Instruction Cycle
The basic cycle the CPU repeats is Fetch → Decode → Execute (and sometimes Store/Write-back). Steps:

1. Fetch: CU reads the next instruction from memory into the Instruction Register using the address in the Program Counter (PC).
2. Decode: The instruction is decoded to determine required operations and operands.
3. Execute: ALU and other parts perform the operation (compute, read/write memory, I/O operations).
4. Update PC: Move to the next instruction (or change PC if a jump/branch).

Performance factors
CPU performance depends on clock speed (frequency), number of cycles needed per instruction (CPI), instruction count, and architecture (single vs multicore, pipelining, superscalar, etc.). Faster clocks and fewer cycles per instruction improve performance, as does adding parallelism (multiple cores or pipelines).

Modern CPU features

• Pipelining: Overlaps instruction stages so several instructions are in different stages at once; increases throughput.
• Multiple cores: Two or more independent processing units on one chip to run tasks in parallel.
• Superscalar execution: Multiple ALUs allowing more than one instruction to execute per cycle.
• Out-of-order execution and branch prediction: Techniques to keep pipelines busy by reordering or guessing instructions safely.

Analogy: Think of the CPU as a factory manager (CU) and workers (ALU) with short-term note pads (registers) and a nearby supplies cupboard (cache). The manager fetches job orders (instructions), tells workers what to do, and stores results back in the cupboard or sends them out to the warehouse (RAM).

Examples of CPUs: Desktop/Notebook (Intel Core i3/i5/i7, AMD Ryzen), Mobile/Tablet/Phone (ARM Cortex series), Embedded (microcontrollers such as AVR, PIC), and Server processors (Intel Xeon, AMD EPYC).

Overview
The motherboard is the main printed circuit board (PCB) in a computer that holds the CPU, memory, chipset and connectors for peripherals. It provides electrical connections (buses) and protocol implementations (interfaces) that allow components to communicate and work as a system.

Key motherboard components

• CPU socket: Where the processor is installed.
• Chipset / PCH (Platform Controller Hub): Manages data flow between CPU, memory, storage and peripherals (historically called northbridge/southbridge).
• RAM slots: DIMM slots for system memory.
• Expansion slots: PCIe slots for graphics cards, network cards, etc.
• Storage connectors: SATA ports and M.2 slots (NVMe/PCIe) for SSDs/HDDs.
• Power connectors: 24-pin ATX, CPU power, and peripheral power headers.
• BIOS/UEFI and CMOS battery: Firmware and clock/setting backup.
• I/O panel: USB, Ethernet, audio, HDMI/DisplayPort and other external ports.

What is a bus?
A bus is a set of electrical lines (wires/traces) that carry information between components. Traditionally three logical buses are described:

• Data bus: Carries actual data (width measured in bits, e.g. 8, 16, 32, 64 bits).
• Address bus: Carries addresses specifying memory or I/O locations (width in lines determines addressable memory).
• Control bus: Carries control signals (read/write, clock, interrupts).

Parallel vs Serial buses
Parallel buses send many bits at once across multiple lines (older approach). Serial buses send bits sequentially over one or a few high-speed lanes (modern approach). Modern PCs favour high-speed serial point-to-point links (e.g., PCI Express) because they scale better and avoid signal timing issues of long parallel traces.

Types of buses & interfaces used on motherboards

• Front-side/System bus: Historically connected CPU to main memory; modern CPUs use integrated memory controllers and high-speed links.
• PCI Express (PCIe): Point-to-point serial lanes for expansion cards (x1, x4, x8, x16 lanes).
• USB (Universal Serial Bus): External peripheral interface (USB 2.0/3.x speeds).
• SATA & NVMe: Interfaces for storage (SATA is serial, NVMe uses PCIe lanes for very high performance).
• Ethernet, HDMI, DisplayPort, Audio jacks: Standard interfaces for networking, video and sound.
• I2C, SPI, UART, GPIO: Low-level on-board interfaces used by sensors, controllers and embedded devices.

Bus characteristics
Important properties include:

• Width: Number of data lines (bits) — determines how many bits transfer per cycle.
• Frequency (clock): How many cycles per second (Hz).
• Bandwidth: Data per second (depends on width and frequency).
• Latency: Delay between request and response (measured in cycles/time).
• Topology: Shared bus vs point-to-point links (affects contention and arbitration).

Modern trends
Modern motherboards move from shared parallel buses to point-to-point serial links (PCIe, SATA, USB3, NVMe). Memory controllers are integrated into CPUs, reducing the need for a central parallel front-side bus. Chipsets group I/O and lower-speed functions.

How communication works (simplified)
The CPU issues an address on the address bus and control signals on the control bus to indicate read/write. Data is transferred on the data bus. In modern systems, protocols and controllers (e.g., PCIe root complex, NVMe controller) package data into packets and send them over serial links with layered protocols handling ordering, error checking and flow control.

Class-level implications
Understanding motherboards, buses and interfaces helps you choose compatible components (socket, RAM type, PCIe lanes), understand performance limits (bus widths and speeds), and troubleshoot connections (wrong slot, incompatible interface).

What is software? Software is a collection of programs, procedures and associated documentation and data that tells the computer how to perform tasks. Unlike hardware (the physical parts), software is intangible — it consists of code and instructions.

Major types of software

• System software: Provides a platform for running application software and manages hardware. Includes:
  • Operating systems (e.g., Windows, Linux, macOS)
  • Device drivers (printer, graphics drivers)
  • Utilities (disk cleanup, antivirus)
• Application software: Programs that perform specific user-oriented tasks. Categories:
  • General-purpose (word processors, spreadsheets — MS Word, Excel)
  • Specialized/domain-specific (accounting software, hospital management)
  • Web & mobile apps (Google Chrome, WhatsApp)
• Programming software: Tools to create other software. Includes:
  • Compilers, interpreters (GCC, Python interpreter)
  • IDEs (Visual Studio, Eclipse)
  • Linkers, debuggers
• Middleware: Software that connects different applications or services (database middleware, message brokers).

Other classification aspects

• By license and distribution: Proprietary (paid, closed-source), Open-source (free to inspect and modify — e.g., Linux), Freeware (free to use, may be closed-source), Shareware (trial versions), SaaS/Cloud (software accessed online — e.g., Google Docs).
• By deployment: Installed software (desktop apps), web-based apps, mobile apps.

Key software concepts

• Installation & configuration: Process to set up software and make it ready to use on a system.
• Updates, patches and versions: Fixes and new features are delivered as patches or versioned releases (major.minor.patch).
• Maintenance types: Corrective (fix bugs), Adaptive (support new platforms), Perfective (improve features), Preventive (improve future maintainability).
• Software quality attributes: Reliability, availability, usability, efficiency, portability, maintainability, security.
• Software development lifecycle (SDLC): Typical phases — Requirements → Design → Implementation (coding) → Testing → Deployment → Maintenance.

Why software matters (short)

Software is what makes hardware useful: from running school applications and browsing the web to controlling cars and hospitals. Good software is reliable, secure, and easy to use.

Definition: An Operating System (OS) is system software that manages computer hardware and provides services to application programs and users. It acts as an intermediary between users/applications and the physical machine.

Primary Objectives

• Provide a convenient and efficient environment to run programs.
• Manage hardware resources fairly and safely (CPU, memory, storage, I/O).
• Ensure security, reliability and smooth multitasking.

Key Components

• Kernel: Core part that controls hardware, process scheduling, memory and device drivers. Runs in kernel mode.
• Shell/User Interface: Command-line or graphical interface that lets users interact with the OS.
• System Libraries & Calls: APIs that applications use to request OS services.

Main Functions

• Process Management: Create, schedule and terminate processes; context switching; process synchronization and basic deadlock handling.
• Memory Management: Allocate/deallocate RAM, manage virtual memory, paging and segmentation to allow programs to run even if physical memory is limited.
• File System Management: Create, read, write, organize and secure files and directories on secondary storage.
• Device Management: Device drivers and I/O scheduling for peripherals (printers, disks, network cards).
• Security & Access Control: User accounts, authentication, permissions and protection against unauthorized access.
• Resource Allocation: Fair sharing of CPU, memory and I/O among competing programs.

Types of Operating Systems

• Batch: Jobs executed in batches (early systems).
• Time-Sharing / Multi-user: Multiple users share CPU time (e.g., servers).
• Real-Time: Strict timing requirements (industrial controllers, pacemakers).
• Embedded: Built into devices (smart TVs, washing machines, IoT).
• Distributed: Manage resources across multiple networked computers.
• Mobile: Optimized for phones/tablets (Android, iOS).

Simple Analogies

• OS as a traffic controller: directs data and program execution so everything runs smoothly.
• OS as a manager: assigns tasks to workers (CPU), allocates workspace (memory), organizes storage (files).

Booting Process (brief)

When a computer powers on: BIOS/UEFI runs -> loads bootloader -> bootloader loads kernel -> kernel initializes hardware and starts system services and the login shell.

Important Concepts to Remember

• Multitasking: Running multiple programs by rapidly switching CPU among them (time sharing).
• Virtual Memory: Uses disk space to extend apparent RAM using paging; each process appears to have contiguous memory.
• Process States: New, Ready, Running, Waiting (Blocked), Terminated.
• System Calls: Standard interfaces programs use to request services (e.g., open file, create process).

The OS is foundational software: without it, applications cannot use hardware or communicate with users effectively.

What is a Programming Language?
A programming language is a formal set of instructions and rules used to write programs that tell a computer what to do. Languages vary by level of abstraction from the hardware:

• Machine language — binary instructions directly executed by the CPU.
• Assembly language — mnemonic codes representing machine instructions; needs an assembler.
• High-level languages (HLL) — human-readable languages (C, Java, Python) that provide abstractions (variables, functions, objects).
• Very-high-level / Domain-specific languages — SQL, HTML (markup), shell scripts for specific tasks.

Types of Languages (by paradigm): Procedural (C), Object‑oriented (Java, C++), Functional (Haskell), Scripting/Interpreted (Python, JavaScript), Declarative (SQL).

What are Translators?
Translators are programs that convert source code written in one language to another form so that it can be executed. Main kinds:

• Assembler — converts assembly language to machine code.
• Compiler — translates whole high-level source code into object/machine code before execution (e.g., C, C++).
• Interpreter — reads and executes source code line-by-line at runtime (e.g., CPython for Python, some JavaScript engines).
• Linker and Loader — combine object files and libraries (linker) and load executables into memory for running (loader).
• JIT (Just-In-Time) compiler — compiles parts of code at runtime to improve performance (used by JVM, .NET, modern JS engines).
• Transpiler (source-to-source) — converts code from one high-level language to another (TypeScript -> JavaScript, Babel for modern JS).

Compiler Phases (brief) — typical stages a compiler performs:

1. Lexical analysis — breaks source into tokens.
2. Syntax analysis (parsing) — checks grammar, builds parse tree / AST.
3. Semantic analysis — type checking, scope resolution.
4. Intermediate code generation — produces an intermediate representation (IR).
5. Optimization — improves IR or machine code for speed/size.
6. Code generation — produces target machine code or object code.
7. Assembly and linking — produce executable by combining object modules and libraries.

Compiler vs Interpreter — key differences

• Compilation: entire program translated before execution; usually faster execution, slower startup (one-time translation cost).
• Interpretation: program translated/executed line-by-line; good for rapid development and portability, usually slower execution.
• Hybrid: languages like Java or C# use compilation to an intermediate form (bytecode/IL) and then run on a virtual machine with interpretation and JIT compilation.

Practical considerations & trade-offs: Choice depends on development speed, execution speed, portability, platform constraints (embedded systems often need compiled code), and ecosystem (libraries, tooling).

Summary of typical translation flows:

• Source (C) --> Compiler --> Object code --> Linker --> Executable
• Source (Python) --> Interpreter (CPython) --> Execution (sometimes bytecode cached)
• Source (Java) --> javac --> Bytecode (.class) --> JVM (interpreter + JIT) --> Native execution

Common real-life examples (short): C for system software, Python for scripting and data science, Java for cross-platform applications, JavaScript for web browsers, Assembly for low-level embedded code.

Important concept to compare interpreter vs compiler mathematically: Total time to get results when running a program many times:

T_total = T_translate + N_runs * T_exec_per_run

Where for an interpreter T_translate ≈ 0 (or very small), for a compiler T_translate = compilation time. If N_runs is large, compilation tends to pay off because T_exec_per_run (compiled) < T_exec_per_run (interpreted).

Use this chapter to understand how programs become executable instructions, what translators do, and why different languages and translators are chosen for different tasks.

Overview
Data in computers is represented using binary (two symbols: 0 and 1). The smallest unit is a bit. Groups of bits form larger units (bytes, kilobytes, megabytes, ...). Different types of information (numbers, text, images, audio) use specific encoding schemes built on binary.

Basic units

• Bit (b): single binary digit, value 0 or 1.
• Byte (B): typically 8 bits. A byte often represents one character (in ASCII).
• Higher units (binary convention): 1 KB (kibibyte) = 1024 B, 1 MB (mebibyte) = 1024 KB, 1 GB = 1024 MB, 1 TB = 1024 GB.
• Decimal (SI) convention used by some drives: 1 kB = 1000 B, 1 MB = 1000 kB. This causes reported capacity differences.

Binary number representation
A binary number is evaluated as the sum of bit_i × 2^i (i = 0 for least significant bit). For signed integers, two's complement is commonly used: an n-bit two's-complement number has range -2^(n-1) to 2^(n-1)-1.

Text encoding
Characters are encoded into bytes: ASCII uses 7/8 bits per character (128/256 symbols). Unicode (UTF-8, UTF-16) supports many more characters and may use multiple bytes per character.

Images
Digital images are grids of pixels. Each pixel stores color using a color depth (bits per pixel). For example, 24-bit color uses 8 bits per channel (RGB), total 24 bits per pixel. Uncompressed image size ≈ width × height × color_depth (bits) / 8.

Audio
Digital audio is sampled in time. File size (uncompressed) ≈ sampling_rate × bit_depth × channels × duration (in seconds) / 8. Example: CD audio uses 44.1 kHz, 16-bit, stereo (2 channels).

Compression
To reduce storage/transmission size, lossless (ZIP, PNG) or lossy (JPEG, MP3) compression is used. Compressed size depends on content and algorithm.

Common concepts

• Capacity vs rate: storage measured in bytes (B), transfer speeds often in bits per second (bps).
• Overflow: when a value exceeds the representable range for given bits.
• Error detection: parity bits, checksums, and CRCs add bits to detect/correct errors.

What is Performance?
Performance of a computer system describes how quickly and efficiently it completes tasks. Two common performance metrics are response time (time to complete a single task) and throughput (number of tasks completed per unit time).

Key performance measures

• Execution (CPU) time: time the CPU spends to execute a program.
• Response time / Latency: time from request to the first (or complete) response.
• Throughput: jobs processed per second/minute/hour.
• Utilisation: fraction of time a resource (CPU, disk) is busy.

How CPU execution time is determined
Execution time depends on three main components: number of instructions executed (Instruction Count, IC), average clock cycles per instruction (CPI), and clock rate (frequency). These relate as:

• CPU Clock Cycles = Instruction Count × CPI
• CPU Time = Clock Cycles × Clock Cycle Time = (Instruction Count × CPI) / Clock Rate

Factors affecting performance

• Processor (CPU): clock frequency, number of cores, microarchitecture (pipeline depth, superscalar execution), CPI and support for SIMD/parallelism.
• Memory: RAM size, memory speed, bus width, and cache (levels, size, associativity). Cache hit rate strongly affects effective memory access time.
• Storage: HDD vs SSD differences in latency and throughput; access time and transfer rates affect I/O-bound tasks.
• Input/Output devices and buses: bus speeds, controller efficiency, and device latencies impact I/O performance.
• Software: algorithm efficiency, compiled code quality, interpreter/virtual machine overhead and background processes.
• Operating system and resource management: scheduling, context-switch overhead, and I/O handling affect perceived and actual performance.
• Parallelism and concurrency: multithreading and multicore usage can increase throughput but may face synchronization and contention limitations.
• Thermal and power constraints: thermal throttling reduces clock speed; battery-saving modes reduce performance on mobile devices.
• Network: bandwidth and latency are critical for distributed applications (web, streaming, cloud).

Principles and trade-offs
Improving one resource may shift the bottleneck to another (e.g., faster CPU reveals slow disk). Also, adding parallel resources yields diminishing returns due to coordination overhead (see Amdahl's Law).

Practical tips to improve performance

• Use efficient algorithms and data structures.
• Increase RAM and use faster storage (SSD) for I/O-heavy tasks.
• Make effective use of caches and locality (optimize code for cache friendliness).
• Use multicore/parallelism appropriately; avoid excessive locking/contention.
• Keep software updated; use compilers and interpreters that produce optimized code.

Overview

Basic computer operations and maintenance cover the everyday tasks required to operate a computer safely and keep it working reliably. This includes how to start and shut down a system, manage files and peripherals, perform routine software and hardware maintenance, and take steps to prevent failures and data loss.

Basic Operations

• Booting & BIOS/UEFI: Power-on self test (POST), BIOS/UEFI initialization, choosing boot device, and loading the operating system kernel.
• Login & User Accounts: Authentication (username/password), user profiles, permissions and user roles to protect data and resources.
• File Management: Creating, saving, moving, renaming, deleting, compressing files and organizing folders. Use of file extensions and backups for important documents.
• Peripheral Operations: Installing and configuring printers, scanners, external drives and USB devices; using device drivers and troubleshooting common device errors.
• Network Basics: Connecting to LAN/Wi‑Fi, understanding IP addressing briefly, mapping network drives and basic internet connectivity checks.
• Software Management: Installing/uninstalling applications, applying software updates and patches, and understanding system restore points.

Maintenance (Purpose & Types)

Maintenance aims to prevent failures, secure data and keep performance optimal. It is usually classified into:

• Preventive Maintenance: Scheduled tasks to prevent problems (cleaning, updates, backups).
• Corrective Maintenance: Fixing faults after they occur (hardware replacement, OS repair, reinstalling drivers).
• Predictive/Monitoring: Using logs and monitoring tools to detect signs of impending failure (disk SMART status, CPU temperature).

Common Maintenance Tasks

1. Physical cleaning: Remove dust from fans, vents, keyboard and behind monitors. Keep airflow clear to avoid overheating.
2. Update OS & Applications: Install security patches and updates regularly to fix vulnerabilities.
3. Antivirus & Malware Scans: Keep definitions up to date and run scheduled scans.
4. Disk Maintenance: Disk cleanup (remove temporary files), defragmentation for HDDs (not needed for SSDs), and checking disk health (CHKDSK / SMART).
5. Backups: Regularly back up important files to external drives or cloud and test restore procedures.
6. Driver & Firmware Updates: Update hardware drivers and device firmware to fix compatibility/performance issues.
7. UPS & Power Protection: Use a UPS or surge protector and maintain their batteries to protect against power surges and outages.

Safety & Best Practices

• Always power off and unplug before opening a case. Use anti-static precautions (ESD wrist strap).
• Keep software licenses, serial numbers and documentation organized.
• Create restore points before major changes and keep an off-site backup for critical data.
• Limit administrative privileges; use standard user accounts for daily tasks to reduce malware risk.

Troubleshooting Workflow (Simple)

1. Identify problem & collect symptoms (error messages, LEDs, sounds).
2. Isolate the cause (hardware vs software vs network).
3. Try simple fixes (reboot, reconnect cables, update drivers).
4. Escalate: run diagnostics, replace suspect hardware, restore from backup or reinstall OS if needed.
5. Document the fix and preventive steps to avoid recurrence.

When to Call a Technician

Persistent hardware failures (strange noises from HDD, repeated blue screens, burnt smells), inability to boot after simple fixes, or complex network/server issues should be handled by trained technicians.

Summary

Regular basic operations combined with preventive maintenance — cleaning, updates, backups, monitoring and safe handling — keep computers reliable and secure. Simple, regular tasks performed by users and scheduled maintenance by IT staff form the backbone of a healthy computer system.

What are Emerging Trends? Emerging trends are new or rapidly developing technologies and practices that are changing how computers are used, how data is processed, and how people interact with digital systems. These trends are driven by increases in computing power, ubiquitous connectivity, vast amounts of data, and advances in algorithms.

Key trends (introductory overview)

• Artificial Intelligence (AI) and Machine Learning (ML): Systems that learn from data to recognize patterns, make predictions, and automate tasks (e.g., recommendation systems, image recognition). Benefits include automation and personalization; challenges include bias, explainability and ethics.
• Internet of Things (IoT): Network of physical devices (sensors, appliances, wearables) that collect and exchange data. Enables smart homes, industrial monitoring and agriculture automation; challenges include interoperability and security.
• Big Data and Analytics: Handling and analyzing extremely large, varied datasets to extract insights. Techniques include data mining, statistical analysis and visualization. Challenges: storage, processing and privacy.
• Cloud Computing: On-demand delivery of computing resources (storage, processing, platforms) over the internet. Models: IaaS, PaaS, SaaS. Advantages: scalability, pay-as-you-go; challenges: data governance and dependency on providers.
• Edge Computing: Processing data close to its source (on devices or edge servers) to reduce latency and bandwidth use—important for real-time IoT and AR/VR applications.
• 5G and Next-generation Networks: Higher bandwidth and lower latency mobile networks enabling applications like real-time streaming, autonomous vehicles and remote surgery.
• Cybersecurity and Privacy: Techniques and practices to protect systems and data (encryption, authentication, secure design). As technologies spread, attack surfaces grow—security is central to adoption.
• Blockchain and Distributed Ledger: Decentralized, tamper-evident records useful for transparent transactions, supply-chain tracking, and digital identity. Trade-offs: performance and energy use for some implementations.
• Augmented Reality (AR) / Virtual Reality (VR): Immersive or overlayed digital experiences with applications in education, training, gaming and design.
• Quantum Computing (introductory): Uses quantum bits to solve certain types of problems (e.g., optimization, factoring) much faster than classical computers for specific tasks. Largely experimental but promising.

Drivers and Impacts: Faster processors, cheap storage, abundant data, better algorithms and improved connectivity (5G) are accelerating adoption. Impacts include new jobs and skills demand, automation of routine work, smarter services, and increased ethical & privacy concerns.

Challenges to watch: privacy and data protection, cybersecurity risks, digital divide (unequal access), ethical concerns (bias, transparency), regulatory and legal issues, and environmental impacts (energy use).

How to think about adoption: Many technologies follow an adoption curve—from research and early experiments, through rapid growth, to maturity. Evaluate a trend by its maturity, use-cases, ecosystem (tools, standards), and real-world deployments.

Simple formulas useful in this topic (examples shown below):

Moore's law (approximate): N(t) = N0 * 2^(t/T)
(where N(t) = transistor count at time t, N0 = initial count, T ≈ 2 years)

Exponential data growth: D(t) = D0 * e^(k t)

Data transfer time: Time (s) = Size (bits) / Bandwidth (bits/s)

Latency approximation: Latency ≈ Distance / (speed of signal)
(For fiber, speed ≈ 2/3 * speed of light)

These formulas are simplified but help estimate growth, transfer times and latency considerations when designing systems.