Video Notes: Computer Architecture and Operating Systems

Vocabulary flashcards derived from the lecture notes covering computer architecture, hardware, assembly language, operating systems, and popular OS concepts.

Binary system

Base-2 counting system used by computers, using digits 0 and 1.

Bit

A single binary digit; the smallest unit of data (0 or 1).

Byte

8 bits; a common data unit in computing.

Transistor

Electronic switch in a semiconductor used to control electrical current.

MOSFET

Metal-oxide-semiconductor field-effect transistor; common type of transistor in chips.

nMOS

N-type MOS transistor; conducts when the gate is at a positive voltage.

pMOS

P-type MOS transistor; conducts when the gate is at a low voltage.

Logic gate

Digital building block that performs a boolean operation (AND, OR, NOT, NAND, NOR, XOR).

NOT gate

Inverter; outputs the complement of the input.

AND gate

Logic gate that outputs 1 only if both inputs are 1.

OR gate

Logic gate that outputs 1 if at least one input is 1.

XOR gate

Exclusive OR gate; outputs 1 if exactly one input is 1.

NAND gate

NOT-AND; outputs 0 only if both inputs are 1.

NOR gate

NOT-OR; outputs 1 only if both inputs are 0.

Digital circuit

Electronic circuit that processes discrete values (0s and 1s).

Combinational circuit

Output depends only on current inputs.

Sequential circuit

Output depends on current and past inputs (requires memory).

State variable

Bits that store the past state of a system.

Full adder

Circuit that adds two bits plus a carry-in; produces sum and carry-out.

Turing machine

Abstract CPU model with a read/write head, tape, and state table; foundation of computing theory.

ENIAC

Early large-scale digital computer built in 1943; used vacuum tubes.

Jacquard loom

Programmable loom using punched cards; ancestor of punched-card computers.

Babbage machine

Early mechanical calculators (Difference Engine) that influenced later computing ideas.

Hollerith’s tabulator

Electric punched-card system; led to IBM.

COBOL

First high-level business language developed in the 1950s.

UNIX

Unix time-sharing operating system developed at Bell Labs (1969).

GUI

Graphical user interface; enables interaction via visuals and a mouse.

Transistor vs vacuum tubes

Transistors replaced bulky, power-hungry vacuum tubes in computers, enabling smaller, faster machines.

Von Neumann architecture

Computer architecture where CPU, memory, and I/O share a single memory and bus; fetch-decode-execute cycle.

Harvard architecture

architecture with separate data and instruction memories and buses for parallel access.

ISA

Instruction Set Architecture; the programmer-visible interface to the processor.

RISC

Reduced Instruction Set Computer; small, simple, regular instruction set (e.g., ARM).

CISC

Complex Instruction Set Computer; large set of instructions (e.g., x86).

MIPS

A 32-bit RISC ISA used for education; emphasizes regularity and simplicity.

Program counter (PC)

Register that holds the address of the next instruction to fetch.

Instruction Register (IR)

Holds the fetched instruction being decoded/executed.

MAR

Memory Address Register; holds the address to access in memory.

MDR

Memory Data Register; holds data being read from or written to memory.

Accumulator (AC)

Register that stores intermediate results of arithmetic/logic operations.

Machine language

Low-level language consisting of 0s and 1s understood by the CPU.

Assembly language

Human-readable symbolic representation of machine instructions; uses mnemonics.

Mnemonic

Symbolic name for an operation in assembly language.

Immediate instruction

Instruction that uses a constant value encoded in the instruction (e.g., addi).

R-type/I-type/J-type

MIPS instruction formats: R-type (register), I-type (immediate), J-type (jump).

Hexadecimal (hex)

Base-16 number format used for compact machine-language representation.

SPIM

Self-contained simulator for MIPS32 programs.

Sign extension

Extending a smaller signed value to a larger width by repeating the sign bit.

Byte-addressable memory

Memory where each byte has its own address.

Latency/CPI/clock period

CPI: cycles per instruction; clock period (TC): time per clock; latency: overall time.

CPU single-cycle vs multi-cycle vs pipelined

Different approaches to completing instructions per cycle in CPU design.

Hardware Description Language (HDL)

Declarative language (e.g., Verilog, VHDL) used to model hardware structures.

HDL purposes

Logic simulation and logic synthesis to generate gates from high-level descriptions.

Verilog/VHDL

HDL languages used to describe hardware behavior and structure.

ASIC/FPGA

IC design: ASICs are pre-programmed; FPGAs are programmable hardware blocks.

Von Neumann bottleneck

Data and instructions share the same memory and bus, causing potential stalls.

IEEE/Verilog/VHDL standards

IEEE standards governing HDL syntax and semantics.

Unit 2: Architecture vs Organization

Architecture describes capabilities/programming model; Organization covers physical implementation.

Instruction set architecture (ISA)

Defines the machine language visible to programmers and compilers.

MIPS microarchitecture

Implementation of the MIPS ISA, including datapath and control.

RISC vs CISC (recap)

Two ISAs philosophies: simple regular instructions vs complex multi-step instructions.

Registers (MIPS)

32 general-purpose registers with conventional names like $t0–$t9, $s0–$s7, etc.

lw / sw

Load word / store word; memory access instructions in MIPS.

Memory hierarchy (RAM/ROM)

Volatile vs non-volatile memory organized in layers for speed and cost.

I/O devices

Inputs and outputs enabling computer interaction with the outside world.

Monolithic vs Microkernel OS

Two OS architectures: large single kernel vs small core kernel with servers.

MINIX 3

Microkernel OS used as example for modular design and reliability.

File system concepts (MBR, partition, superblock, i-nodes)

Structures governing how data is stored and addressed on disks.

RAID

Redundant Array of Independent Disks; improves reliability/throughput.

Linux kernel and VFS

Monolithic kernel with a Virtual File System layer for multiple FS types.

Darwin/XNU/Mach/ BSD/I/O Kit

Apple macOS kernel environment composition and layers.

POSIX

Standard set of interfaces for OS compatibility.

Process vs Thread

Process: a running program with its own memory; Thread: lightweight unit of execution within a process.

Process states

Ready, Running, Blocked; transitions managed by the scheduler.

Round-robin scheduling

Fair CPU time allocation where each process gets a fixed quantum.

File naming conventions

OS-specific rules for naming files (Windows, UNIX, MS-DOS).

i-nodes

Filesystem data structures storing metadata about files.

MBR/partition table/superblock

Disk structures for booting, partitions, and filesystem metadata.

ACL (Access Control List)

List assigning access rights to users or domains for objects.

POLA (Principle of Least Authority)

Limit rights granted to entities to the minimum necessary.

TCB (Trusted Computing Base)

Hardware/software core trusted for system security.

Reference monitor

Security component that enforces access control on system calls.

OS architecture concepts (Windows/macOS/Linux/Android)

Different OS families and how their kernels, layers, and stacks are organized.

Android runtime (ART)

Android’s runtime system that translates bytecode to machine code (AOT).

Darwin/macOS architecture

Apple’s OS stack: Mach kernel, BSD layer, I/O Kit, and GUI components.

Unix/Linux layers

Hardware → Kernel → Standard library → Shell/GUI; includes VFS and system calls.

Linux command/utilities

Shell tools (cp, ls, mv, cat, chmod, etc.) used for system tasks.

Windows history/generations

MS-DOS → Windows NT → Modern Windows family.

macOS/iOS architecture

Darwin-based macOS with XNU kernel; iOS uses ARM architecture and security layers.

Android architecture stack

Linux kernel, ART, libraries, application framework, and apps.