Basics Glossary

Term	Description
Platform
802.11	IEEE standard family defining Wi-Fi. Major generations: 802.11n (Wi-Fi 4, MIMO), 802.11ac (Wi-Fi 5, MU-MIMO, 5 GHz only), 802.11ax (Wi-Fi 6/6E, OFDMA, adds 6 GHz), 802.11be (Wi-Fi 7, multi-link operation).
Access Point	Device that bridges a wireless LAN to a wired network. Broadcasts beacon frames advertising the SSID and supported rates; manages client association, authentication, and channel assignment.
Autonomous System	Collection of IP networks under a single administrative domain that presents a unified routing policy to the internet; identified by a globally unique autonomous system number (ASN).
Band	Frequency range allocated to Wi-Fi. 2.4 GHz offers longer range and better wall penetration but is congested. 5 GHz provides more channels and higher throughput. 6 GHz (Wi-Fi 6E/7) adds 1.2 GHz of unlicensed spectrum.
BGP	Border Gateway Protocol; inter-domain routing protocol that exchanges reachability information between autonomous systems and selects paths based on policy attributes rather than pure metrics.
Cache	Small, fast memory between CPU and RAM that stores recently accessed data to reduce latency. Organized in levels: L1 (fastest, smallest) through L3 (slowest, largest).
CDN	Content Delivery Network; distributed system that caches static assets at edge locations worldwide, directing users via DNS to a nearby server to minimize latency and reduce origin load.
Channel	Frequency slot within a band. 2.4 GHz has 14 partially overlapping 20 MHz channels; only 1, 6, and 11 are non-overlapping in North America. 5 GHz offers many non-overlapping 20/40/80/160 MHz channels.
Colocation	Hosting model where an organization rents rack space, power, and connectivity inside a shared data center facility while owning and operating its own servers.
Congestion Control	TCP algorithms (slow start, congestion avoidance, fast retransmit) that reduce transmission rate in response to packet loss or ECN marks, preventing network collapse under load.
Container	Lightweight, portable runtime that packages an application with its dependencies, sharing the host OS kernel. Starts in milliseconds; smaller overhead than a VM.
Copy-on-Write	Optimization where a forked process shares read-only memory pages with its parent; a write triggers duplication of only the modified page so each process gets an independent copy.
CPU	Central Processing Unit; the processor that fetches, decodes, and executes program instructions in a continuous cycle.
CSRF	Cross-Site Request Forgery; attack exploiting a victim’s authenticated browser session to silently issue state-changing requests to a trusted site on their behalf.
CSMA/CA	Carrier Sense Multiple Access with Collision Avoidance; Wi-Fi’s medium-access protocol. Before transmitting, a station listens for activity; if the channel is busy it backs off a random interval to reduce collisions.
DDoS	Distributed Denial-of-Service; attack that floods a target with traffic from many compromised hosts to exhaust bandwidth or processing capacity and make it unavailable.
DNS	Domain Name System; a distributed, hierarchical database that translates hostnames (example.com) to IP addresses through a chain of recursive and authoritative resolvers.
File System	OS layer that organizes persistent data into named files and directories on storage devices, managing metadata, permissions, and allocation.
Flow Control	TCP mechanism where the receiver advertises a window size limiting how much unacknowledged data the sender may have in flight, preventing the receiver from being overwhelmed.
Forward Secrecy	Cryptographic property where each session uses an ephemeral key pair so that compromise of a long-term key cannot decrypt previously captured sessions.
GPU	Graphics Processing Unit; a processor with thousands of small cores optimized for massively parallel computation - graphics rendering, machine learning, and scientific simulation.
Hyperscale	Massive data center design employed by cloud providers that scales horizontally across hundreds of thousands of commodity servers with software-defined networking and infrastructure.
Hyper-threading	Intel’s simultaneous multithreading implementation where each physical core presents two logical processors to the OS, sharing execution units to reduce pipeline stalls during memory waits.
Hypervisor	Software layer that creates and manages virtual machines by abstracting physical hardware; Type 1 runs on bare metal, Type 2 runs inside a host OS.
I/O	Input/Output; data transfer between memory and external devices such as disks, network interfaces, and keyboards. I/O is orders of magnitude slower than CPU operations.
Inode	Unix filesystem data structure storing file metadata (size, permissions, timestamps, block pointers) separately from the filename; a directory entry maps name to inode number.
IP Address	Numerical label assigned to a network interface. IPv4 is 32 bits (e.g., 192.168.1.1); IPv6 is 128 bits (e.g., 2001:db8::1).
IXP	Internet Exchange Point; neutral physical facility where many autonomous systems connect to exchange traffic directly, reducing latency and eliminating the need to pay transit providers.
Kernel	Core of an operating system that manages hardware resources - CPU scheduling, memory, file systems, and devices - and exposes them to processes through system calls.
LAN	Local Area Network; a network spanning a building or campus where devices share one broadcast domain and communicate at Ethernet or Wi-Fi speeds.
MFA	Multi-Factor Authentication; security practice requiring two or more independent verification factors (e.g., password plus hardware key or TOTP code) to authenticate a user.
MIMO	Multiple Input Multiple Output; uses multiple antennas at transmitter and receiver to send parallel spatial streams, multiplying throughput. MU-MIMO extends this to serve several clients simultaneously on the same channel.
MMU	Memory Management Unit; CPU hardware that translates virtual addresses to physical addresses using page tables maintained by the OS, enforcing process isolation and access protection.
NAT	Network Address Translation; maps many private IP addresses (RFC 1918) to a single public IP by rewriting packet headers and tracking port mappings.
NUMA	Non-Uniform Memory Access; multi-socket server architecture where memory access latency depends on which socket’s memory is accessed, requiring NUMA-aware thread and memory placement.
OFDM	Orthogonal Frequency-Division Multiplexing; Wi-Fi modulation scheme that splits a channel into many narrow parallel subcarriers, improving resistance to multipath interference. Wi-Fi 6 extends this to OFDMA for multi-user access.
Operating System	System software that abstracts hardware and provides services - process isolation, virtual memory, file systems, networking - to applications through a system call interface.
OSI Model	Seven-layer reference model for network protocol design (Physical, Data Link, Network, Transport, Session, Presentation, Application); more useful as a teaching framework than a strict implementation specification.
OSPF	Open Shortest Path First; link-state interior routing protocol that floods topology information to all routers and runs Dijkstra’s algorithm to compute shortest paths within an autonomous system.
Out-of-Order Execution	CPU optimization that dynamically reorders instructions to keep execution units busy while earlier instructions wait on cache misses or other dependencies.
Packet	Unit of data transmitted over a network. Carries a header with source/destination addresses and a TTL, plus a payload. IP provides best-effort datagram delivery.
Page Fault	Exception triggered when a process accesses a virtual address with no current physical mapping; the OS handles it by allocating a page frame or loading the page from disk.
Peering	Direct traffic exchange between two autonomous systems at an IXP or private interconnect, typically without payment when traffic volumes are roughly symmetric.
Process	Running instance of a program with its own virtual address space, file descriptor table, and OS resources. Isolation between processes is enforced by the kernel.
Protocol	Formal agreement on message formats and exchange sequences between communicating systems. TCP provides reliable ordered delivery; UDP provides low-overhead datagram delivery.
QUIC	Transport protocol over UDP providing reliable ordered delivery, stream multiplexing, and integrated TLS 1.3; eliminates TCP’s head-of-line blocking and reduces connection setup latency.
RAM	Random Access Memory; volatile memory holding running programs and active data. Access latency is nanoseconds - much faster than SSDs (microseconds) or HDDs (milliseconds).
Routing	Forwarding packets across networks using routing tables and longest-prefix matching. BGP exchanges routes between autonomous systems on the internet; OSPF routes within one.
RSSI	Received Signal Strength Indicator; vendor-specific measure of received radio power, expressed in dBm. Used by clients to select access points and by both ends to adapt the transmission rate to current link quality.
SIMD	Single Instruction, Multiple Data; CPU instruction set extension (SSE, AVX, NEON) that applies one operation to a vector of values simultaneously, enabling data-level parallelism.
SSD	Solid State Drive; non-volatile flash storage with microsecond access latency. No moving parts; faster and more durable than magnetic HDDs but more expensive per byte.
SSID	Service Set Identifier; the human-readable name of a Wi-Fi network, carried in beacon frames broadcast by the access point. Multiple access points sharing an SSID form an ESS, enabling client roaming across the coverage area.
System Call	Controlled entry point into the kernel that lets a user-space process request privileged operations such as file I/O, memory allocation, or socket communication.
TCP	Transmission Control Protocol; adds reliable ordered delivery, retransmission, flow control, and congestion control on top of IP using a three-way handshake to establish connections.
Thread	Unit of execution within a process. Threads share the process address space, enabling low-latency communication but requiring explicit synchronization to avoid races.
TLB	Translation Lookaside Buffer; per-core hardware cache of recent virtual-to-physical page mappings; a hit avoids a full page-table walk, dramatically reducing address-translation overhead.
TLS	Transport Layer Security; cryptographic protocol that negotiates session keys and encrypts data (typically with AES-GCM) to provide confidentiality, integrity, and server authentication.
TTL	Time-to-Live; field in IP packets decremented by each router hop; when it reaches zero the packet is dropped, preventing routing loops from circulating indefinitely.
UDP	User Datagram Protocol; connectionless transport with no handshake, ordering, or retransmission. Used where low latency matters more than reliability: DNS, games, video streaming.
Virtual Memory	Abstraction giving each process its own address space, backed by physical RAM and disk paging. Enables isolation, memory-mapped files, and programs larger than physical RAM.
WAN	Wide Area Network; a network spanning cities or continents that interconnects multiple LANs through routers. The internet is the largest WAN.
Wi-Fi	Brand name for wireless LAN technology certified under the IEEE 802.11 standard family. Operates in unlicensed spectrum (2.4, 5, and 6 GHz) using OFDM modulation and CSMA/CA medium access control.
WPA3	Wi-Fi Protected Access 3; current Wi-Fi security standard. Uses SAE (Simultaneous Authentication of Equals) instead of WPA2’s PSK handshake, eliminating offline dictionary attacks and providing forward secrecy per session.
XSS	Cross-Site Scripting; injection attack where malicious scripts are embedded in pages served from a trusted site and execute in victims’ browsers, stealing session tokens or redirecting users.
Imperative Languages
Access Modifier	Keyword controlling visibility of a declaration outside its defining scope: `pub` in Rust, `private`/`protected`/`public`/`internal` in C# and C++.
Borrow Checker	Rust compiler component that enforces ownership and borrowing rules at compile time, guaranteeing memory safety without a garbage collector.
Borrowing	Temporary access to a value through a reference without transferring ownership; Rust enforces either any number of shared (`&T`) references or exactly one exclusive (`&mut T`) reference at a time.
Closure	Anonymous function that captures variables from its enclosing scope. Capture mode (borrow, copy, or move) determines whether the captured value is shared or owned.
Concurrency	Composition of independently executing computations. Requires synchronization when threads share mutable state; message passing avoids shared state entirely.
Cooperative Multitasking	Concurrency model where tasks explicitly yield control at suspension points, allowing others to run without OS context switches; the basis of async/await in Rust, Python, and C#.
Crate	Rust’s unit of compilation and distribution; a library or binary with a `Cargo.toml` manifest specifying dependencies, metadata, and build configuration.
Data Race	Concurrent access to shared memory where two threads access the same location simultaneously and at least one writes, with no synchronization; produces undefined behavior.
Deadlock	State where two or more threads each hold a lock the other needs, blocking indefinitely with no progress possible.
Drop Trait	Rust trait whose `drop` method runs automatically when a value goes out of scope, enabling deterministic cleanup of resources without a garbage collector.
Enum	Type representing exactly one of a fixed set of named variants. In Rust, variants can carry data, making enums full algebraic sum types. In C++, enums are integer aliases.
Error Propagation	Forwarding a failure from a callee to its caller without handling it. Done implicitly by exception unwinding in C++/C#/Python; explicitly with Rust’s `?` operator.
Exception	Object representing a runtime error that interrupts normal control flow and unwinds the call stack until a matching handler catches it.
Function	Named, reusable unit of computation taking zero or more parameters and optionally returning a value. Functions are the primary abstraction in imperative programming.
Garbage Collection	Automatic runtime memory management that traces reachable objects and reclaims unreachable heap allocations. Eliminates manual deallocation but introduces pause overhead.
Generic	Type or function parameterized by one or more type variables. Instantiated at compile time (monomorphization in Rust/C++) or via type erasure (Java/C# generics).
Green Threads	Lightweight user-space threads managed by the language runtime rather than the OS scheduler; faster to create and context-switch than OS threads, enabling millions of concurrent tasks.
Heap	Dynamically allocated memory region where objects with runtime-determined lifetimes are stored; allocation and deallocation are explicit (C/C++) or runtime-managed (GC, reference counting).
Lambda	Inline anonymous function expression; in C++ and Rust may capture variables from the enclosing scope (making it a closure) or operate as a plain function pointer when no captures are needed.
Lifetime	Rust annotation describing how long a reference remains valid. The borrow checker enforces that references never outlive the data they point to.
Macro	Compile-time code transformation. Rust declarative macros match token patterns; procedural macros receive a token stream and emit new code. C preprocessor macros are textual.
Memory Leak	Heap allocation that remains live but is no longer reachable by any reference; accumulates over time, eventually exhausting available memory.
Module	Named scope grouping related items and controlling their visibility. Rust modules must be explicitly declared; Python modules map one-to-one to files.
Move Semantics	Transfer of resource ownership from one variable to another, invalidating the source. Avoids deep copies for heap-allocated types. Used in Rust (always) and C++11+ (explicit).
Mutability	Whether a binding’s value can change after initialization. Rust and many modern languages default to immutable; mutation requires an explicit `mut` annotation.
Namespace	Named scope that organizes identifiers and prevents collision between unrelated code; accessed via qualified paths (e.g., `std::io::Read` in Rust, `System.IO` in C#).
Operator Overloading	Defining custom behavior for built-in operators on user types. Rust uses trait implementations (e.g., `impl Add`); Python uses dunder methods; C# uses `operator` keywords.
Option Type	Generic algebraic type encoding a possibly-absent value with `Some(T)` and `None` variants; forces explicit handling of absence at compile time, eliminating null pointer errors.
Ownership	Rust’s rule that every value has exactly one owner; when the owner goes out of scope, the value is dropped. Ownership is the foundation of Rust’s memory safety guarantees.
Panic	Rust mechanism for unrecoverable errors (failed assertions, index out of bounds) that unwinds the stack, runs destructors, and terminates the thread.
Pattern Matching	Structural decomposition of a value in a `match` expression. Rust enforces exhaustiveness at compile time. Can destructure enums, tuples, structs, and apply guards.
Pointer	Variable holding a memory address. Raw pointers in C/C++ carry no lifetime or ownership guarantees. Rust raw pointers (`const T`, `mut T`) require `unsafe` to dereference.
RAII	Resource Acquisition Is Initialization; C++ idiom tying resource lifetime to object lifetime via destructors. Rust’s `Drop` trait is the direct equivalent.
Reference	Borrow of a value without taking ownership. In Rust, shared (`&T`) or exclusive (`&mut T`); the borrow checker enforces that only one exclusive reference exists at a time.
Reference Counting	Memory management strategy that tracks active owners of a heap allocation; when the count drops to zero the memory is freed immediately. Cycles prevent reclamation without supplemental collection.
Result Type	Generic algebraic type encoding a fallible operation with `Ok(T)` for success and `Err(E)` for failure; forces callers to handle both cases explicitly.
Scope	Region of code where a name is valid. In Rust and C++, scope determines when destructors run and heap memory is freed. Nested scopes shadow outer bindings.
Stack	Per-thread memory region that holds function call frames and local variables; allocation and deallocation are automatic (push/pop) and extremely fast relative to heap operations.
Stack Unwinding	Process of exiting nested scopes and calling destructors when an exception or panic propagates, cleaning up resources before the thread terminates or the exception is caught.
Struct	Named composite type grouping related fields by name. A value type on the stack by default in Rust and C++. In C#, `struct` is a value type while `class` is a reference type.
Thread Safety	Property of code that executes correctly when called concurrently from multiple threads; typically achieved via synchronization primitives, immutable shared state, or Rust’s Send/Sync traits.
Trait	Rust abstraction defining a set of method signatures a type must implement. Used for generic bounds (`T: Display`) and dynamic dispatch (`dyn Trait`).
Type Inference	Compiler-deduced type for a variable or expression when not explicitly annotated. Rust infers types from usage context; C++ uses `auto`; Python uses runtime duck typing.
Unsafe	Rust keyword enabling operations the borrow checker cannot verify: raw pointer dereference, calling C FFI functions, and accessing mutable statics. Must be audited manually.
Use-After-Free	Memory safety bug where code accesses heap memory after it has been freed; produces undefined behavior and is a common source of exploitable security vulnerabilities.
Variable	Named binding associating an identifier with a value in memory. In Rust, bindings are immutable by default. In Python, a variable is a reference to a heap object.
Variance	How subtyping of a generic container relates to subtyping of its element type: covariant (read-only), contravariant (write-only), or invariant (read-write).
Declarative Languages
Applicative	Type class for applying wrapped functions to wrapped values: `(<*>) :: f (a -> b) -> f a -> f b`. Stronger than Functor, weaker than Monad; allows parallel effect composition.
Catamorphism	Generalization of fold; recursively reduces an algebraic data structure to a single value by applying a combining function at each node. Called `foldr` on lists.
Combinator	Higher-order function built entirely from other functions, carrying no external state. Combinators compose to build complex behavior from simple pieces: `map`, `filter`, `compose`.
Currying	Transforming a function of N arguments into a chain of N single-argument functions. All Haskell functions are curried by default; partial application is the idiomatic result.
Functor	Type class for structures that can be mapped over: `fmap :: (a -> b) -> f a -> f b`. Lists, Maybe, and IO are all Functors. Preserves structure while transforming contained values.
Higher-Kinded Type	A type that takes another type as a parameter: `* -> *` in Haskell (e.g., `Maybe`, `[]`). Required to abstract over Functor, Monad, and similar classes.
Immutability	Data that cannot be modified after creation. The default in purely functional languages; eliminates a class of aliasing and concurrency bugs. Shared immutable values need no synchronization.
Lazy Evaluation	Deferring computation until the result is demanded. Haskell is lazy by default, enabling infinite data structures. Avoids work for values never consumed but complicates reasoning about space.
Monad	Abstraction for sequencing computations in a context: provides `return :: a -> m a` and `(>>=) :: m a -> (a -> m b) -> m b`. Encodes IO, state, failure, and non-determinism uniformly.
Monad Transformer	Type constructor that stacks one monadic effect on top of another. `StateT s Maybe a` combines stateful computation with possible failure; avoids nested `bind` calls.
Pattern Matching	Structural decomposition of algebraic data types in a `case` or `match` expression. The compiler enforces exhaustiveness, preventing unhandled cases at compile time.
Pure Function	Function whose output depends only on its inputs and that causes no observable side effects. Pure functions are referentially transparent and trivially composable and testable.
Recursion	Primary looping mechanism in functional languages, replacing mutable loop counters. Structural recursion follows the shape of the data; tail recursion avoids stack growth when optimized.
Referential Transparency	Property of an expression: it can be replaced by its value anywhere without changing program behavior. Implies no side effects. Enables equational reasoning and aggressive compiler optimization.
Side Effect	Observable action beyond returning a value: I/O, mutation, exception, or non-determinism. Functional languages isolate side effects in a Monad (Haskell IO) or effect system to maintain purity elsewhere.
Tail Call	Function call in the tail position of its caller. Tail-call optimization (TCO) reuses the caller’s stack frame, enabling tail-recursive functions to run in O(1) stack space. Haskell and Scheme guarantee TCO.
Type Class	Interface-like abstraction in Haskell and Scala defining behavior over types. `Eq`, `Ord`, `Show`, and `Functor` are standard type classes; instances provide implementations per type.
Type Inference	Hindley-Milner algorithm that deduces principal types without explicit annotations. Used in Haskell, ML, F#, and Rust. Produces the most general type for each expression.
Unfold / Anamorphism	Dual of catamorphism; generates a (possibly infinite) structure from a seed value by repeatedly applying a step function. Used to produce streams, trees, and corecursive data.