Computer Science

Welcome to the computer science reference hub. This page mirrors the same neon terminal style as our language pages and delivers a dense glossary of the core ideas you will meet across theory, systems, networking, AI, security, and software engineering.

Keywords & Definitions

Every foundational buzzword with a concise definition so you can translate any syllabus or job spec.

Algorithm – A precise, step-by-step procedure for solving a problem.
Abstraction – Hiding lower-level details so you can reason about a simpler model.
API (Application Programming Interface) – Contract that defines how software components talk to each other.
Architecture – High-level structure of hardware or software systems and how components interact.
Artificial Intelligence – Systems that perform tasks normally requiring human intelligence.
Big-O Notation – Mathematical shorthand describing algorithm growth/complexity.
Bit / Byte – Fundamental units of digital information (1 bit = 0 or 1, 8 bits = 1 byte).
Boolean Logic – Algebra of true/false values used in circuits and conditionals.
Cache – Small, fast memory that stores copies of frequently accessed data.
Cloud Computing – Renting compute/storage/network resources over the internet.
Compilation – Translating high-level code into machine instructions.
Concurrency – Structuring programs to handle multiple tasks that overlap in time.
Cryptography – Science of secure communication (encryption, hashing, signatures).
Data Structure – Organized way to store and access data efficiently.
Database – Structured storage engine with query interfaces.
Debugging – Diagnostic process for finding and fixing defects.
Encapsulation – Bundling state and behavior while restricting direct access.
Event-Driven – Architecture that reacts to incoming events or messages.
Framework – Opinionated toolkit providing scaffolding for applications.
Garbage Collection – Automatic memory reclamation for unreachable objects.
Heuristic – Rule-of-thumb strategy for approximating solutions faster.
Immutable – An object whose state cannot change after creation.
Interface – Shared boundary specifying how to interact with a component.
Latency – Time delay between request and response.
Machine Learning – Algorithms that learn patterns from data.
Microservice – Small, independently deployable service focused on a single capability.
Normalization – Process of organizing database tables to reduce redundancy.
Object-Oriented Programming – Model that organizes code around objects that combine data and behavior.
Protocol – Formal set of rules governing data exchange between peers.
Recursion – Function or definition that refers to itself to solve subproblems.
Scalability – Ability of a system to handle increased load gracefully.
Semaphore – Concurrency primitive used to control access to shared resources.
Stack / Queue – LIFO vs FIFO collections used in memory management and scheduling.
State Machine – Model describing transitions between discrete states.
Thread – Smallest schedulable unit of execution within a process.
Throughput – Amount of work a system completes per unit time.
Virtualization – Abstracting physical hardware into logical resources.
DevOps – Culture and tooling that unifies development and operations.
CI/CD – Continuous integration and continuous delivery pipelines for rapid releases.
Observability – Ability to understand internal state via logs, metrics, and traces.
Zero-Downtime Deployment – Releasing updates without interrupting users.

Data Structures & Use Cases

Arrays – Constant-time index access; great for contiguous numeric or textual data.
Linked Lists – Fast inserts/removals when you already hold a node reference.
Stacks – Manage browser history, undo buffers, DFS traversals.
Queues – Task scheduling, breadth-first search, messaging systems.
Priority Queues / Heaps – Always pull the highest- or lowest-priority element first.
Hash Tables – Average O(1) lookups for dictionaries, caches, symbol tables.
Trees – Represent hierarchical data (DOM, file systems, parse trees).
Binary Search Trees / AVL / Red-Black – Ordered structures with logarithmic operations.
Tries – Prefix search for dictionaries, autocomplete, IP routing.
Graphs – Model networks of relationships (social graphs, road maps, call graphs).
Disjoint Sets / Union-Find – Track connected components efficiently.
Bloom Filters – Probabilistic structure for quick membership tests with low memory.

Algorithm Families

Sorting – Quick sort, merge sort, heap sort, radix sort.
Searching – Binary search, interpolation search, exponential search.
Graph – BFS, DFS, Dijkstra, Bellman-Ford, Floyd-Warshall, A*.
Optimization – Dynamic programming, greedy algorithms, branch and bound.
Divide & Conquer – Split problem into halves (merge sort, FFT, quick select).
Approximation – Provide near-optimal results for NP-hard problems.
Randomized – Use randomness for expected performance (Las Vegas / Monte Carlo).
Parallel – MapReduce, prefix sums, GPU kernels.

Theory & Complexity

Finite Automata & Regular Languages – Simplest formal language model.
Pushdown Automata – Model languages with recursion/stack (context-free grammars).
Turing Machines – Abstract computers used to define decidability.
P vs NP – Open question comparing fast verification vs fast solution.
NP-Complete / NP-Hard – Class of problems believed to require exponential time.
Big-O / Big-Ω / Big-Θ – Upper, lower, and tight bounds on runtime.
Amortized Analysis – Average cost of operations over a sequence.
Information Theory – Quantifies information (entropy, coding, compression).

Systems & Architecture

Von Neumann Architecture – Single memory for instructions and data.
CPU Pipeline – Fetch, decode, execute, memory, write-back stages.
Instruction Set Architecture (ISA) – Machine-level commands (x86, ARM, RISC-V).
Operating System – Manages processes, memory, files, devices, security.
Process vs Thread – Independent execution contexts vs lightweight scheduled units.
Virtual Memory – Abstraction that gives each process its own address space.
Containers – OS-level virtualization sharing the same kernel.
Edge Computing – Running workloads near data sources to lower latency.

Hardware Internals: CPU, ALU, RAM

When you crack open a modern system-on-chip, you find several tightly coupled subsystems that shuttle data between fast logic units and comparatively slow memory arrays. Understanding what physically sits on the die or motherboard helps you reason about performance, power, and thermal trade-offs.

Control Unit (CU) – Microcode or hardwired logic that sequences every instruction: it fetches opcodes, decodes them into micro-operations, drives the register file multiplexers, and orchestrates reads/writes to the ALU, FPU, load/store unit, and caches.
Arithmetic Logic Unit (ALU) – Combinational circuits (adder trees, shifters, boolean networks) that execute integer math, comparisons, bitwise transforms, and set condition flags (ZF, CF, OF, SF) consumed by later instructions.
Floating-Point & Vector Units – IEEE-754 compliant pipelines plus SIMD lanes (SSE, AVX, NEON, SVE) that operate on 128–512-bit registers for dense linear algebra, graphics, and ML kernels.
Register File – Nanosecond-speed SRAM cells holding general-purpose registers, architectural state, instruction pointers, and special-purpose counters; often multi-ported so multiple functional units can read/write simultaneously.
Cache Hierarchy – Private L1 instruction/data caches (32–64 KB, ~1 ns) feed each core, mid-sized L2 caches (~1–2 MB) capture working sets, and a shared inclusive/exclusive L3 (last-level cache) buffers tens of MB before main memory.
Branch Predictor & Speculation – Pattern-history tables, TAGE predictors, and return stacks guess future control flow so the pipeline stays full; mispredictions flush the pipeline and waste cycles, so accuracy directly impacts IPC.
Clock Distribution & Pipeline Depth – Phase-locked loops generate multi-gigahertz clocks, while pipelining splits work into 10–30+ stages; deeper pipelines allow higher clocks but amplify penalties from hazards.
Interconnect & Fabric – Ring buses, meshes, or NoC topologies move cache lines between cores, memory controllers, and IO dies, balancing bandwidth with latency.

Random Access Memory (RAM) complements those compute blocks by providing the working dataset:

DRAM Cell – Each bit sits in a tiny capacitor gated by a transistor; because charge leaks, refresh cycles (tREFI/tRFC) constantly rewrite data, which is why DRAM is slower but denser than SRAM.
Rows, Columns, Banks – Accesses activate a row (RAS), then select columns (CAS); bank interleaving lets controllers overlap operations to hide tRCD, tRP, and tCL latencies.
DIMM Modules & Channels – Multiple dual-inline memory modules sit on independent channels to widen bandwidth; dual/quad-channel controllers double or quadruple the data returned per clock.
Integrated Memory Controller (IMC) – Now inside the CPU package, the IMC queues requests, reorders them for efficiency, performs address mapping, and enforces QoS or NUMA policies across sockets.
ECC & Parity – Data centers favor error-correcting code memory that appends parity bits to detect and correct single-bit faults, dramatically boosting reliability for long-running workloads.
Memory Hierarchy Interaction – The OS page cache and MMU translate virtual addresses into physical frames stored in RAM; TLB misses force page table walks, which is why keeping hot pages resident inside RAM—and ultimately inside caches—matters.

Networking & Web

OSI / TCP-IP Models – Layered abstractions for data transmission.
IP Addressing – Uniquely identifies devices on a network.
Routing – Moving packets across networks (BGP, OSPF).
DNS – Maps human-readable names to IP addresses.
HTTP / HTTPS – Application protocols powering the web.
REST / GraphQL / gRPC – Styles for designing web APIs.
WebSockets – Full-duplex communication channel over a single TCP connection.
CDN – Distributed servers that cache content close to end users.

Software Engineering Workflow

Requirements Gathering – Capture user and business needs.
System Design – Turn requirements into architecture diagrams and interfaces.
Implementation – Build features with clean code and automated tests.
Code Review – Peer feedback for quality and knowledge sharing.
Testing Pyramid – Unit, integration, end-to-end tests to prevent regressions.
Continuous Integration – Automatically build and test every commit.
Continuous Delivery – Keep main branch deployable with automated releases.
Monitoring & Incident Response – Detect issues, page responders, capture postmortems.

Emerging Topics & Disciplines

Quantum Computing – Exploiting qubits and superposition for new algorithms.
Edge AI – Deploying ML models on-device for low-latency inference.
Responsible AI – Fairness, transparency, and governance of machine learning.
Cybersecurity – Threat modeling, penetration testing, zero trust architectures.
Human-Computer Interaction – Designing usable, accessible interfaces.
Data Engineering – Building pipelines, warehouses, and real-time streams.
Site Reliability Engineering – Applying software principles to operations.
Green Computing – Optimizing for energy efficiency and sustainability.

Need syntax-specific help? Jump to our language pages:

Python HTML CSS JavaScript