| Alias |
Two or more identifiers bound to the same or overlapping memory location |
| Arc |
Atomically reference-counted pointer enabling shared ownership of heap data across threads |
| Async / Await |
Cooperative concurrency model where async functions suspend at await points without blocking a thread |
| Atomic Operation |
Hardware-guaranteed indivisible read-modify-write preventing partial states visible to other threads |
| Attribute (#[...]) |
Metadata applied to items like functions or structs to affect compilation or behavior |
| Barrier |
Synchronization primitive blocking a group of threads until all have reached it |
| Blittable Type |
A type stored entirely in contiguous stack memory - primitives, arrays, and tuples of blittable types |
| BNF |
Backus-Naur Form notation for formally specifying programming language grammar |
| Borrow |
Temporary loan of data allowing read or mutable access without transferring ownership |
| Box |
Heap-allocating smart pointer providing unique ownership and automatic deallocation on drop |
| Buffered I/O |
Collecting multiple I/O requests in a buffer before issuing a single kernel call for throughput |
| Cargo |
Rust's package manager and build system for managing dependencies and compiling projects |
| Channel |
A conduit for transferring data or ownership between threads via send and receive operations |
| Class |
An object-oriented construct defining a template for objects with data members and methods |
| Clone |
A trait for making explicit deep copies of data, as opposed to bitwise Copy |
| Closure |
An anonymous function capturing variables from its enclosing scope |
| CMake |
Cross-platform build automation tool generating native build files for C++ projects |
| Colored Functions |
Async/await restriction where async functions can only be called from other async functions |
| Common Intermediate Language |
Bytecode compiled from C# and other .NET languages and executed by the CLR virtual machine |
| Composition |
Design relationship where a class contains instances of other classes as members |
| Condition Variable |
Synchronization primitive allowing a thread to sleep until another thread signals a state change |
| Contravariance |
Variance where a subtype relationship is reversed (useful for function parameter types) |
| Control Flow |
Constructs - if, loop, match - that determine the execution order through a program |
| Conversion |
Type conversion via From, Into, TryFrom, and TryInto traits |
| Copy Type |
A type with value semantics where assignment copies the entire value without transferring ownership |
| Covariance |
Variance where a subtype relationship is preserved (useful for read-only/producer contexts) |
| Crate |
A compilation unit in Rust; can be a library or executable |
| Critical Section |
Code region accessing shared mutable data that must execute under exclusive lock |
| Data Race |
Unsynchronized concurrent access to shared mutable data producing undefined or incorrect results |
| Data Structure |
Standard Rust collections including Vec<T>, HashMap, BTreeMap, and VecDeque from std::collections |
| Derive |
Automatically implements traits using the #[derive(...)] attribute, e.g., #[derive(Debug, Clone)] |
| Drop |
A trait for customizing cleanup when a value goes out of scope; drives RAII in Rust |
| Duck Typing |
Runtime type checking where suitability is determined by available methods, not declared type |
| Dynamic Dispatch |
Runtime resolution of method calls via a vtable, enabling polymorphism at the cost of an indirection |
| Dynamic Link Library |
A library loaded at runtime and shared across processes, reducing executable size |
| Enum |
Aggregate type representing one of several named variants, each optionally carrying associated data |
| Epoll |
Linux kernel interface for scalable monitoring of many file descriptors for I/O readiness |
| Error Handling |
Managing failure via Result<T, E> for recoverable errors and panic! for unrecoverable ones |
| Error Propagation |
Passing errors up the call stack so callers can decide how to handle failures |
| Exception |
An interruption of normal control flow that unwinds the call stack until a matching handler is found |
| False Sharing |
Performance degradation when threads write to different variables sharing the same cache line |
| Fat Pointer |
A pointer with additional metadata - length for slices, vtable pointer for trait objects |
| File I/O |
Reading and writing files using std::fs and types like File and BufReader |
| File Mapping |
Mapping a file's pages directly into process address space for memory-like access |
| for loop |
Iterates over a range or any type implementing IntoIterator |
| Function Pointer |
A reference to a function with a specific signature, e.g., fn(i32) -> i32 |
| Future |
A Rust trait representing a value computed asynchronously that may not be ready yet |
| Garbage Collector |
Runtime mechanism automatically reclaiming heap memory no longer referenced by the program |
| Generic Function |
A function with type parameters enabling it to operate correctly over many types without duplication |
| Generic Type |
A parameterized type whose concrete form is resolved at compile time or instantiation |
| Generics |
Parametric types and functions using type parameters like <T>, resolved at compile time |
| GIL |
Python's Global Interpreter Lock preventing multiple threads from executing bytecode simultaneously |
| HashMap |
A key-value hash table from std::collections with average O(1) lookup and insertion |
| Heap |
Memory allocated dynamically at runtime via the allocator; freed when the owning value drops |
| Hyper-Threading |
Intel's implementation of SMT exposing multiple logical cores per physical core |
| impl |
Block associating method definitions or trait implementations with a specific type |
| Inheritance |
OO relationship where a derived class acquires attributes and methods from a parent class |
| Interface |
An abstract type declaring methods that implementing types must provide, enabling polymorphism |
| Interior Mutability |
Pattern allowing mutation through a shared reference using Cell<T> or RefCell<T> |
| IntoIterator |
A trait used in for loops to produce an iterator from a collection or value |
| Invariance |
Variance property requiring no subtyping relationship; necessary for mutable generic containers |
| io_uring |
Linux ring-buffer interface providing near-zero-overhead asynchronous I/O via shared memory |
| Iterator |
An abstraction enabling sequential access to elements of a collection one at a time |
| JIT Compilation |
Translating bytecode to native machine code at runtime for improved execution speed |
| Lambda |
An inline anonymous function expression, commonly used as a callback or short transformation |
| Lazy Compilation |
C++ property where only the template code actually instantiated by a program is compiled |
| Lifetime |
Compile-time annotation expressing how long a reference is valid, preventing use-after-free |
| LINQ |
Language-Integrated Query providing SQL-like data querying syntax directly in C# code |
| Lock Guard |
A type holding a mutex lock that automatically releases it when dropped, preventing unlock mistakes |
| Loop |
An infinite loop construct in Rust, exited with break and optionally returning a value |
| Macro |
Metaprogramming feature generating code at compile time, e.g., macro_rules! or procedural macros |
| Managed Heap |
Garbage-collected heap memory used for reference types in .NET and JVM languages |
| Memory Management |
Strategies for allocating and releasing program memory - manual, garbage-collected, or ownership-based |
| Memory Ordering |
Specification constraining how atomic operations interact with compiler and CPU instruction reordering |
| Message Passing |
Concurrency pattern where threads communicate by transferring data through channels rather than sharing memory |
| Method |
Function defined in an impl block and called via dot notation on a value or reference |
| Module |
A named scope grouping related items and controlling their visibility within a project |
| Monolithic Kernel |
OS kernel containing all core services in one binary, with loadable modules for drivers |
| Move |
Transfer of ownership from one binding to another, invalidating the original for non-blittable types |
| Move Semantics |
Transfer of ownership when a non-Copy value is assigned or passed to a function, invalidating the source |
| Move Type |
A type that transfers ownership on assignment, invalidating the source binding |
| MPSC |
Multi-Producer Single-Consumer channel permitting multiple senders but only one receiver |
| Mutex |
Synchronization primitive allowing only one thread to hold the lock at a time, protecting shared data |
| Named Kernel Objects |
System-wide OS resources identified by name and shareable between processes and scopes |
| Native Heap |
Programmer-managed heap memory for C and C++ requiring explicit allocation and deallocation |
| Non-Blittable Type |
A type with heap-allocated data managed by a stack-based control block - String, Vec, HashMap |
| Option Type |
A type encoding a value that may be present (Some) or absent (None), replacing nullable references |
| Ownership |
Rust's rule that each value has exactly one owner responsible for dropping it when out of scope |
| Page Fault |
Event triggered when a referenced memory page is not resident in RAM, causing a swap-in |
| Page Table |
OS data structure mapping virtual addresses to physical memory frames |
| Paging |
Memory management scheme swapping fixed-size pages between RAM and disk as needed |
| Panic |
Thread termination triggered by an unrecoverable programming error such as an out-of-bounds index |
| Pattern Matching |
Control structure that destructures values and dispatches execution based on which pattern matches |
| Pointer |
A reference to data: safe borrows (&T, &mut T) or raw pointers (*const T, *mut T) in unsafe code |
| Polymorphism |
The ability to write code that operates uniformly over values of different types |
| Preemptive Scheduling |
OS scheduler policy where a running thread may be suspended to give CPU time to another |
| Priority Inversion |
A high-priority thread blocks because a low-priority thread holds a lock it needs |
| Process Context Block |
OS data structure holding a process's shared resources, file handles, and state |
| Quantum |
The maximum time-slice a thread may run before the scheduler may preempt it |
| RAII |
Resource Acquisition Is Initialization: tying resource lifetime to object scope for automatic cleanup |
| Rc |
Single-threaded reference-counted pointer enabling shared ownership with runtime borrow tracking |
| Ready Queue |
Scheduler's priority-ordered collection of threads ready to run but waiting for CPU time |
| Reference |
A non-owning borrow of a value (&T or &mut T), subject to lifetime and aliasing rules |
| Regular Expression |
Pattern matching on strings via the regex crate; not in the standard library |
| Result Type |
A type encoding either success with a value or failure with an error, making fallibility explicit |
| Ring-based Protection |
CPU hardware privilege levels separating kernel (ring 0) from user-mode (ring 3) code |
| RwLock |
Read-write lock allowing unlimited concurrent readers or a single exclusive writer |
| Semaphore |
Counter limiting the number of threads that may concurrently access a resource |
| Shadowing |
Reusing a variable name in the same scope to rebind it with a new value or type |
| Slice |
A dynamically sized view into a contiguous sequence of elements, e.g., &[T] or &str |
| Smart Pointer |
A RAII wrapper around a raw pointer that manages lifetime and ownership automatically |
| SMT |
Simultaneous Multithreading exposing multiple hardware thread contexts per physical core |
| Spinlock |
Busy-wait synchronization primitive looping until a lock is available, efficient for short waits |
| Stack vs Heap |
Contrast between automatic stack allocation (LIFO, fast) and dynamic heap allocation (flexible, slower) |
| Static Dispatch |
Compile-time resolution of method calls via monomorphization, generating specialized code per type |
| String |
Growable, heap-allocated UTF-8 text owned by the binding; distinct from string slices &str |
| Struct |
Aggregate type grouping named fields of possibly different types into a single named entity |
| Template |
C++ mechanism for parameterizing types and functions with type arguments resolved at compile time |
| Template Instantiation |
Generation of a concrete type or function from a C++ template by supplying specific type arguments |
| Template Metaprogramming |
C++ technique using templates to perform computation and code generation at compile time |
| Thread |
An independently scheduled execution unit within a process sharing its address space |
| Thread Context Block |
OS data structure holding a thread's registers, stack pointer, and scheduling state |
| Time-sharing |
OS technique interleaving multiple processes on a CPU by rapidly switching between them |
| Trait |
A declaration of methods a type must implement, enabling ad-hoc polymorphism in Rust |
| Trait Bound |
A constraint on a generic type parameter specifying required trait implementations |
| Trait Object |
A dynamically dispatched instance of a trait, written as dyn Trait and held behind a pointer |
| Tuple |
A fixed-size ordered collection of values of possibly different types, e.g., (i32, f64, bool) |
| Type Hints |
Optional Python annotations indicating expected types but not enforced by the interpreter |
| Type Inference |
Compiler deduction of a variable's type from its initialization context, eliminating boilerplate annotations |
| Type System |
The set of rules governing which operations are valid on which types and how types relate |
| Unbuffered I/O |
Each I/O request goes directly to the kernel without buffering, useful for precise control |
| Unit Test |
Test function marked #[test] in Rust, collected and run by cargo test |
| Unsafe |
A block or function opting out of Rust's safety guarantees to enable raw pointers and FFI |
| Variable |
A named storage location binding an identifier to a value, with associated type and mutability |
| Variable Binding (let) |
The let keyword declares a variable binding in Rust; add mut for a mutable binding |
| Variance |
Property of a generic type describing how subtyping of a type parameter affects subtyping of the whole type |
| Vec<T> |
A growable, heap-allocated contiguous array; Rust's primary dynamically-sized sequence type |
| Virtual Function |
A C++ function that can be overridden in derived classes, enabling dynamic dispatch through base pointers |
| Virtual Memory |
OS abstraction presenting each process with its own large address space backed by paging |
| Work Stealing |
Thread-pool optimization where idle threads steal pending tasks from other threads' queues |
| Zero-cost Abstractions |
Rust principle that high-level abstractions compile to the same code as equivalent low-level implementations |