Glossary
Every term the topics lean on, defined once in both languages.
814 terms Abstract base class A class that defines a shared interface and can recognize concrete or virtual subclasses. Abstract class A class that cannot be instantiated because at least one pure virtual function lacks a concrete final overrider. Access specifier A class label such as public, protected, or private that controls where member names can be used. Access token A credential presented to a resource server to access a protected resource. Accessible name The computed text that identifies an element to accessibility APIs and assistive technology. Active Record A persistence pattern in which an object represents a database row and exposes queries and writes. Adjacency list A graph representation that stores the outgoing neighbors of each vertex. Agent loop The repeated model, tool execution, and state-update cycle that continues until an agent stops. Aggregate error An Error that groups multiple failure reasons so one operation can report them together. Allocation-size overflow Integer wraparound while computing allocation bytes, which can produce a block smaller than the intended element range. Ambient declaration A declaration telling TypeScript that another runtime source supplies the described variable, function, class, or module. Amortized complexity The average cost per operation over a sequence, accounting for occasional expensive operations such as resizing. Annotation Structured metadata attached to a Java declaration or type use for a compiler, processor, tool, or runtime consumer to interpret. Annotation processing Compile-time rounds in which processors inspect Java language elements, report diagnostics, and may generate files. Anonymous class A nameless inner class declared and instantiated by a class creation expression or an enum constant body. Anti-join A relational operation that keeps left-side rows for which no matching right-side row exists. API contract A versioned statement of the observable requests, responses, and behavior that an API provider promises to consumers. API version A named set of externally observable API behavior that a provider supports as one compatibility contract. Application context The active Flask scope that provides current_app and g independently of a specific view. Application factory A function that creates, configures, and returns an application instance. Approval gate A policy checkpoint that pauses an agent action until a person or higher-authority rule explicitly allows it. Architecture boundary An explicit division that confines change, ownership, data access, or failure impact to a defined part of a system. Architecture decision record A short, versioned record of one significant architecture choice, its context, rationale, and consequences. Architecture fitness function A repeatable check that reports whether an implementation still preserves a chosen architecture characteristic. Argument A value or expression supplied at a call site for binding to a function parameter. Argument unpacking Supplying iterable elements or mapping entries as separate arguments with * or ** at a call site. Argument-dependent lookup Lookup that adds functions from namespaces and classes associated with an unqualified call argument type. Array extent The number of elements in one dimension of an array type. Array shape A tuple giving the element count along each axis of an array. Array stride The byte distance crossed when an array index advances by one position along an axis. Array view An array object that interprets data owned by another array instead of holding an independent element buffer. Array-key normalization PHP conversion of an inserted array key into its final integer or string form. Array-like object An object with a length and indexed properties that can supply an argument list without being an Array. Array-to-pointer conversion The implicit conversion of an array expression to a pointer to its first element. ArrayBuffer A byte-addressed binary storage block that views interpret; it may have a fixed or resizable length. Arrow function A function expression written with => that uses lexical this and is not constructible. ASGI A Python interface between asynchronous-capable web servers and applications, expressed as event messages. Assertion function A function whose asserts return annotation narrows values after the function returns normally. Assignment expression An expression using := that binds a name while also producing the assigned value. Associated type A placeholder type declared by a protocol and fixed by each conforming type, letting requirements refer to related types. Associated value Data supplied when an enum case instance is created, with a type and shape chosen by that case. Async runtime An executor plus I/O and timing facilities that polls futures and wakes tasks when asynchronous operations can advance. asyncio task An event-loop object that schedules one coroutine and stores its result, exception, or cancellation state. Attestation A statement about a named subject, often signed so a verifier can authenticate its issuer and contents. Attribute Structured declarative information attached to a program entity and stored in compiled metadata for a consumer to interpret. Attribute inheritance A retrieval rule that can include attributes declared on base classes or overridden members when an attribute permits it. Attribute target The metadata entity, such as a type, property, field, parameter, or return value, to which an attribute record is attached. Authoritative DNS server A DNS server that answers from authority for a zone it serves rather than recursively resolving arbitrary names. Auto-configuration Conditional Spring configuration selected from the application classpath, beans, properties, and runtime type. Autoboxing An implicit Java conversion from a primitive value to an instance of its corresponding wrapper class. Autoclosure A parameterless closure Swift creates automatically around an argument expression to delay its evaluation. Autoloading Loading a class-like definition on demand when PHP first needs its resolved name. Automatic minimum size The content-aware minimum produced by min-width or min-height auto, which can stop a flex item from shrinking. Automatic reference counting Swift memory management that inserts retain and release operations according to the lifetime of strong references. B-tree A balanced search tree whose nodes hold multiple ordered keys and children, keeping operations height-bounded. Backed enum A PHP enum whose cases each have a unique string or integer backing value. Backing array The array storage whose contiguous elements are exposed through one or more Go slices. Backing field Compiler-managed storage associated with a property whose accessors need to retain a value. Backing storage The private compiler-synthesized _property field that stores a property wrapper instance. Backpressure A capacity signal that makes a producer slow or stop when downstream buffers or consumers cannot keep up. Backtracking A matching strategy that revisits earlier choices after a later pattern part fails and then tries another available path. Backward compatibility The ability of a newer provider to keep satisfying interactions that were valid under an older contract. Base case A recursive definition branch that returns an answer without making another recursive call. Base class A class named in another class's base-clause, contributing a base subobject and inherited interface. Binary floating-point A finite number format that stores a sign, significand, and base-two exponent, so many decimal fractions are approximate. Binding flags Bitwise options that tell .NET reflection which public, non-public, instance, static, declared, or inherited members to consider. Blueprint A deferred collection of Flask setup operations registered on an application. Borrow checker The Rust compiler analysis that verifies reference validity and rejects conflicting accesses. Borrow guard An RAII value that keeps a RefCell shared or exclusive borrow active until the guard is dropped. Borrowing Temporary access to a value through a reference without taking ownership of that value. Bottom type A type with no ordinary values that is a subtype of every type; Kotlin uses Nothing for this role. Bound function A function object created by bind that stores a target, a this value, and optional leading arguments. Boxing A conversion that represents a value type as object or as an implemented interface, usually by creating an object. Branded type An intersection that adds a type-only marker to distinguish otherwise compatible values. Breadth-first search A traversal that visits vertices in increasing edge distance from a chosen start. Breaking change A change that can make a previously valid consumer interaction fail or acquire different observable meaning. Breakpoint A condition boundary where a layout changes mode because its content constraints change. Bridge method A compiler-generated method that preserves overriding after generic signatures are erased. Broadcasting NumPy’s rules for applying element-wise operations to compatible arrays with different shapes. Broken Object Level Authorization An API flaw where a caller can act on an object without permission for that specific object and action. Build context The selected set of local or remote files that a container-image build is allowed to access. Burst Compiler Unity compiler that translates compatible High-Performance C# IL into optimized native CPU code. C enumeration A distinct C type accompanied by named integer constants and compatible with an implementation-selected integer type. C union A C type whose members begin in shared storage, normally representing one valid alternative at a time. Cache invalidation Removing or superseding cached data when its validity contract ends. Cache key A hashable identity used to find the cached result for one call or request. Cache locality The tendency of nearby or recently accessed memory to be available in faster processor caches. Cache policy Rules that determine whether a request may read a cached response, contact the origin, or accept stale data. Call stack The last-in, first-out runtime structure that tracks active function calls and where each caller resumes. Callback A function passed into another function so that the receiver can invoke it during an operation. Callback identity The exact function object an API uses to match registration, deduplication, or removal operations. Cancellation A cooperative request for asynchronous work to stop at a safe suspension point. Canonical constructor The record constructor whose parameter types correspond in order to every component in the record header. CAP theorem An impossibility result relating linearizability, availability, and network partitions in shared-data systems. Capture list Swift closure syntax that initializes named captures and can mark class references weak or unowned. Capture mode How a closure stores an outside place: by shared, unique immutable, or mutable borrow, or by value. Capturing group A parenthesized regex subpattern whose matched text is recorded in a numbered or named result slot. Cargo package A bundle described by one Cargo.toml that contains at least one crate and may define several build targets. Carrier thread A platform thread on which the JDK scheduler mounts a virtual thread while that virtual thread runs Java code. Case guard A Boolean condition after when that must be true in addition to an already matching switch pattern. Cell A runtime container that lets nested Python functions share one captured variable binding. Certificate chain A leaf certificate plus issuer certificates used to build a validated path to a configured trust anchor. Characterization test A test that records existing observable behavior so structural changes can be separated from intentional behavior changes. Checked exception A Throwable type outside the RuntimeException and Error branches that Java requires callers to catch or declare. Claim A name and value asserting a piece of information about a subject. Class invariant A rule that must hold for every observable state of an object after construction and public operations. Clickjacking Deceiving a user into interacting with a concealed or disguised embedded page instead of the interface they perceive. Close code A numeric WebSocket status describing why an endpoint started or observed connection closure. Closure A function that retains access to bindings from its defining lexical scope after that scope returns. Closure call trait One of Fn, FnMut, and FnOnce, describing how a closure is received when called and whether repeat calls are supported. Codable The Swift type alias combining Encodable and Decodable for conversion to and from external representations. Code provenance Evidence recording where code or an artifact came from and which transformations produced its current form. Coding container A keyed, unkeyed, or single-value interface through which a Codable implementation reads or writes representation data. Coding key A typed key that identifies a field inside a keyed encoding or decoding container. Collection pipeline An ordered chain of collection transformations, filters, and aggregations in which each result feeds the next step. Colormap normalization The mapping from domain values into the numeric interval consumed by a colormap. Comma-ok idiom A two-result operation that returns a value and a boolean reporting whether a lookup or assertion succeeded. Command substitution A shell expansion that replaces $(command) with the command's standard output after removing trailing newlines. Common table expression A named query defined by WITH and visible to the single statement that follows it. Compact constructor A canonical record constructor that omits its parameter list and receives implicit component parameters. Compact String An OpenJDK String representation that stores Latin-1 content in a byte array while preserving public UTF-16 semantics. Comparable type A type whose values support == and !=; every Go map key type must satisfy this rule. Comparator A function that returns a negative, zero, or positive number to define relative ordering. Composition Building an object from collaborators it owns or references instead of inheriting their implementations. Conditional conformance A protocol conformance available to a generic type only when its type arguments satisfy declared constraints. Conditional type A type expression that selects one result or another by testing assignability with T extends U. Connection pool A managed set of reusable network connections shared by requests to reduce setup work and bound concurrency. Const assertion The as const assertion that prevents literal widening and gives object and array literals readonly, tuple-like precision. Const enum A TypeScript enum whose constant member accesses can be inlined and whose declaration is removed by default during emit. Constraint validation The browser process that checks form controls against applicable HTML and custom validity rules. Constructor property promotion PHP syntax that declares and initializes a property through a visibility-marked constructor parameter. Container A runnable image instance with its own process, runtime configuration, writable layer, networks, and mounts. Container image A read-only package of filesystem layers and default configuration used to create containers. Container query A CSS condition evaluated against an eligible ancestor query container instead of the viewport. containerd shim A process that adapts containerd task lifecycle operations to a particular low-level runtime or Wasm host. Content block A typed unit inside a model message, such as text, a tool call, an image, or a tool result. Content negotiation HTTP mechanisms for selecting a response representation according to information exchanged by client and server. Content Security Policy A browser-enforced response policy that restricts resource loading, script execution, framing, form targets, and related behaviors. Context local A proxy that resolves to data associated with the currently active execution context. Context manager An object whose enter and exit methods establish and tear down a runtime context around a with block. Context switch The act of saving one execution context and restoring another so a processor can run different work. Context window The bounded token capacity available to a model for input, conversation state, tool definitions, and generated output. Contextual typing Type inference that uses the expected type at an expression’s location to type that expression and its parameters. Contract testing Testing that an API provider and consumer satisfy an agreed set of observable interactions. Contravariance A variance relation that reverses subtype direction, commonly used for values consumed by an API. Control frame A WebSocket frame for connection signaling, including Close, Ping, and Pong, rather than application data. Control-flow narrowing The compiler refining a variable type along reachable paths after checks, assignments, and termination. Convention over configuration A design approach where shared naming and structure supply defaults, leaving configuration for exceptions. Conversation state The prior messages and generated items supplied to a model so a later turn can continue their context. Copy elision Construction rules that omit an otherwise expected copy or move by constructing directly in the result location. Copy-on-write An implementation strategy that shares storage until one logical copy is modified. Coroutine A suspendable computation that can yield control while awaiting another operation. Corpus A collected body of language data used for analysis, training, or evaluation. Covariance A variance relation where a generic producer of a subtype can be used as a producer of its supertype. Crate One Rust compilation unit that produces a library or executable and owns an independent module tree. Crate root The source file where rustc starts a crate and which forms the root module of that crate’s module tree. Cross axis The axis perpendicular to a flex container’s main axis, used for item and flex-line alignment. Cross-Origin Resource Sharing A browser-enforced HTTP protocol through which a server grants selected origins access to cross-origin responses. Cryptographically secure randomness Randomness produced so an attacker cannot feasibly predict future values from observed outputs or practical knowledge of the state. CSP nonce An unpredictable single-response value that authorizes matching inline script or style elements under a CSP. CSS cascade The rule set that chooses a winning CSS declaration when several declarations apply to the same property. CSS custom property A --prefixed CSS property whose value participates in the cascade and can be referenced with var(). CSS preprocessor A build-time language and compiler that produces CSS from source with additional syntax or evaluation features. CSS transition An interpolation generated when a listed CSS property changes between transitionable values. CSS-in-JS A family of techniques that declare styles in JavaScript or TypeScript and produce CSS rules or class names. Currying Transforming a multi-argument function into a sequence of functions that each accept one argument. Dangling pointer A pointer whose referenced object has ended its lifetime, making later use of the saved pointer invalid. Data class A class whose primary-constructor properties drive compiler-generated value members such as equality, components, and copying. Data leakage Use of information unavailable at real inference time while fitting, selecting, or evaluating a model. Data loader A request-scoped utility that batches keyed reads and memoizes repeated keys during one operation. Data type The rule that determines how each array element is stored and interpreted. Data visualization The mapping of data records and fields into graphical marks and visual properties for analysis or communication. DataFrame A two-dimensional labeled table whose columns can have different data types. Datagram One boundary-preserving message sent independently by a datagram transport such as UDP. DataView A view that accesses numeric fields at byte offsets and chooses byte order for each multibyte operation. Daylight saving time A seasonal clock adjustment that can create missing or repeated local times and change a zone offset. Deadline The point after which an operation should stop waiting and report that its time budget is exhausted. Debt interest The extra work or risk paid when a change touches a software element whose technical debt remains in place. Debt principal The work needed to move an indebted software element from its current state to the chosen target state. Decision driver A constraint or goal used to distinguish viable options in an architecture decision. Decision log A versioned collection of decision records whose status and links preserve how design reasoning changed. Decision table A table mapping combinations of conditions to expected actions or outcomes so rules and precedence can be checked. Declaration emit Compiler output that derives public .d.ts signatures from TypeScript or typed JavaScript source. Declaration file A type-only file that describes existing JavaScript modules or globals without implementing their runtime values. Decoding error A structured Swift error for a missing key, absent value, type mismatch, or corrupt representation during decoding. Decorator A callable applied at definition time whose return value replaces the original function or class binding. Decorator factory A callable that accepts decorator configuration and returns the decorator that will receive a function or class. Deep copy A copy that recursively constructs a corresponding object graph while preserving repeated references and cycles. Default method A non-static interface method with a body that implementing classes inherit unless a more specific method overrides it. Defensive copy A copy made at an ownership boundary so later mutation through another reference cannot alter internal state. Deferred call A call registered by defer to run in reverse registration order when the surrounding Go function exits. Deferred execution Execution that waits until a consumer requests results instead of running when the query is defined. Definite assignment Compile-time control-flow proof that a Java variable has been assigned on every path before it is read. Definite assignment assertion A ! on a TypeScript field declaration that asks the compiler to trust later initialization it cannot prove. Delegate A typed callable object that refers to one or more compatible methods. Delegated property A property whose getter and optional setter behavior is supplied by an object named after Kotlin’s by keyword. Deny by default An access-control rule that refuses a request unless an explicit allow policy matches it. Dependency injection A mechanism that resolves and supplies values a component declares it needs instead of constructing them inline. Dependency Inversion Principle High-level policy and low-level detail should depend on abstractions owned by the stable policy side. Deprecation A lifecycle state that warns consumers to migrate away from a resource without itself changing its behavior. Depth-first search A traversal that follows one branch before returning to explore remaining alternatives. Deref coercion An implicit conversion from a reference to a wrapper into a reference to its Deref target. Derived class A class declared with extends that inherits public behavior and initializes its instance through a base constructor. Destructuring pattern A JavaScript pattern that extracts iterable values or object properties into bindings or assignment targets. Dev Container A container environment enriched with metadata for developing, building, testing, and debugging a codebase. Dev Container Feature A reusable package of installation code and metadata applied while a development container image is built. Dispatch receiver The instance of a class that owns a member extension and supplies its surrounding object context. Distributive conditional type A conditional over a naked type parameter that evaluates separately for each member of a union. Django A Python web framework with integrated routing, models, templates, forms, authentication, and administration. DNS rebinding Changing a hostname's DNS answer so validation observes one address while a later connection reaches another. DNS resource record A typed DNS data item with an owner name, class, TTL, and type-specific value. DNS time to live The maximum number of seconds a received DNS record may normally be reused from a cache. Document Object Model A tree-shaped programming interface that represents a document and lets scripts inspect or change its nodes. Domain-specific language A language or API whose vocabulary and constraints are designed for one problem domain. Drop trait The Rust trait whose method runs when a value enters destruction. DSL marker A Kotlin marker annotation that restricts simultaneous implicit access to receivers in the same DSL. Dynamic allocation Runtime creation of storage whose lifetime ends through an explicit deallocation operation. Dynamic array A growable indexed sequence that keeps logical length separate from allocated capacity. Dynamic proxy A runtime-generated Java object that implements interfaces and dispatches their method calls to an InvocationHandler. Dynamic typing A typing model where names have no fixed declared type and operations inspect object types at runtime. Eager loading Fetching known related records in planned queries before code traverses those relationships. ECMAScript edition A numbered or yearly publication of the standard that defines the JavaScript language. ECS archetype The unique component-type combination shared by a group of entities in an ECS world. ECS chunk A fixed-size memory block holding aligned arrays of entities and their components for one archetype. Eden Treaty A typed client interface inferred from an Elysia application type without generating client source files. Edge runtime A distributed server runtime near users, usually with constrained process lifetime and platform-specific bindings. Effectively final A variable without the final modifier whose assignments still satisfy the rules that final would impose. Egress filtering Network policy that restricts which destinations, ports, or protocols a workload may reach outbound. Elvis operator Kotlin’s ?: operator, which returns its left side when non-null and otherwise evaluates its right side. Elysia A Bun-first TypeScript web framework that derives runtime validation and static types from route declarations. Encapsulation Keeping representation behind an API so state changes can preserve the object contract and its invariants. Enclosing instance An object lexically surrounding an inner object and available through a qualified this expression. Enclosing scope The lexical scope around a function that supplies bindings for its free variables. End-of-file indicator Sticky stream state set after an input operation cannot obtain more data because it reached the end. Endianness The order in which a multibyte scalar stores its bytes, commonly big-endian or little-endian. Entity command buffer A queue that records entity operations for safe playback at a defined point after jobs or iteration. Entity Component System An architecture that separates entity identity, component data, and systems that process matching component sets. Entity tag An opaque validator that distinguishes selected representations of a resource. Entry API A map interface that represents an occupied or vacant key so lookup and conditional update share one state branch. Enum case One named singleton value belonging to an enum type. Enumeration A value type whose instances are exactly one case from a closed set, optionally carrying case-specific data. Ephemeron A weak-key association whose value is retained only after its key is found reachable outside that association. Equality comparer An object that defines equality and matching hash codes for values used by a collection. Error chain An error structure connected through Unwrap methods and traversed by errors.Is and errors.As. Error handler A callback that receives eligible PHP diagnostics and decides whether default handling continues. Error level A PHP E_* integer constant that classifies the severity and source of a diagnostic. Error propagation Passing a thrown error outward through calling scopes until code catches and handles it. Error suppression Temporary exclusion of a PHP diagnostic from the active reporting mask, commonly through the @ operator. Error wrapping Embedding an error in another error so new operation context and the original programmatic cause remain available together. Escaping closure A closure permitted to outlive the function call that received it, such as one stored for later invocation. Evaluation set A versioned collection of representative cases and criteria used to compare model-application behavior. Event accessor An add or remove operation that controls how an event stores and releases handlers. Event handler A delegate instance registered to run when a publisher raises a particular event. Event loop A host mechanism that runs queued JavaScript work when the current call stack is empty. Eventual consistency A guarantee that replicas converge if updates stop and relevant messages are eventually delivered. Exception An object that reports a failed operation and transfers control from the normal path to a compatible handler. Exception cause The lower-level Throwable recorded as the reason another Throwable was created. Exception filter A C# when condition that decides whether a type-compatible catch clause handles the current exception. Exception-safety guarantee A promise about resources, invariants, and observable state when an operation exits by throwing. Exclusive ownership An ownership model in which exactly one owner at a time is responsible for an object’s final destruction. Executable specification A behavior agreement encoded as readable examples or checks that can run against an implementation. Execution transcript A structured record of invoked tools, approvals, outputs, exit status, and environmental changes from one automated run. Exhaustive when A when expression whose branches cover every possible value of its subject. Existential type A type spelled with any that can hold a value of any current concrete type conforming to a protocol. Exit status A small integer returned when a command finishes, conventionally zero for success and nonzero for another outcome. Explicit grid The grid tracks and areas declared by grid-template properties rather than created by placement. Explicit this binding Supplying the this value for an ordinary function through call, apply, or a bound function. Expression A language construct made from values, names, calls, and operators that is evaluated with a type and can produce a value. Expression tree An immutable runtime object graph that represents typed code structure for inspection, rewriting, translation, or compilation. Expression visitor A traversal object that examines expression nodes and can return a rewritten tree. Extension function A function declared outside a type and callable with receiver syntax without adding a real member. Extension property A property-style declaration computed through accessors without adding storage to the receiver. Extension receiver The object an extension is called on, whose declared type participates in extension resolution. Externalized configuration Runtime settings supplied outside application code through ordered property sources such as files and environment variables. FastAPI A Python ASGI framework that derives API validation, dependencies, and OpenAPI descriptions from typed declarations. Field promotion The selector rule that lets a uniquely reachable field of an embedded Go type be selected through the outer value. File descriptor A process-local integer handle for an open file, pipe, socket, device, or another kernel-managed object. File stream A stateful C standard-library connection through which a program transfers data to or from an external object. Final overrider The virtual-function implementation selected for a class after considering all overrides in its inheritance graph. First-class function A function treated as a value that can be stored, passed as an argument, and returned. Flask A lightweight Python WSGI web framework for routing requests to views and producing responses. Flex container A box that establishes flex layout for its direct children through a computed display value of flex or inline-flex. Flex item A flex container child whose box participates in that container’s flex formatting context. Flexible array member An incomplete array declared last in a C struct, with element storage supplied beyond the fixed-size portion. Flow control Credit-based limits that regulate how much HTTP/2 DATA a peer can send on a stream and connection. Force unwrapping The postfix Swift ! operation that returns a wrapped value when present and traps when the optional is nil. Forward secrecy The property that later compromise of a long-term key alone does not reveal previously established session keys. Forwarding reference An unqualified deduced T&& or corresponding auto&& that can bind to lvalues and rvalues for forwarding. Free variable A name used in a function but bound in an enclosing scope rather than in that function. Full slice expression A three-index slice expression, a[low:high:max], that sets both the length and capacity of the result. Fully qualified name A symbol name written from the namespace root, independent of the current namespace. Function composition Creating a function that passes each stage’s output to the next compatible function. Function parameter variance The compatibility rule relating a function’s accepted parameter types to those expected by its caller. Function pointer A pointer whose value designates a function of a compatible type and can be used for an indirect call. Function signature The callable interface describing parameter names, kinds, defaults, and annotations. Function type A type that specifies a callable value through its receiver, parameter types, result type, and optional suspension. Functional interface A Java interface whose abstract method set defines one function descriptor, allowing lambdas and method references as instances. GameObject The basic object in a Unity scene; it owns a Transform and any components that provide its data and behavior. Garbage collection Automatic reclamation of storage occupied by objects the runtime determines are no longer reachable. Generator An iterator whose function body can suspend at yield and resume through next, return, or throw. Generator expression A comprehension-like expression in parentheses that creates a lazy, single-pass generator. Generic A declaration that uses type parameters to preserve relationships while accepting more than one concrete type. Generic constraint A bound that limits which types may replace a type parameter and which members generic code may use. Generic function A callable with registered implementations selected by a dispatch rule at runtime. GGUF A model file format that stores tensors and standardized metadata for loading by executors such as llama.cpp. Git index The data structure that records the path, mode, and object selected for each entry in the proposed next snapshot. Git object An immutable, content-addressed blob, tree, commit, or annotated-tag record in a Git object database. Git reference A named pointer to an object ID, used for branches, tags, remote-tracking branches, and other Git state. Global symbol registry A runtime registry that maps string keys to shared registered Symbol values. Graph A set of vertices and edges used to model connections, direction, and optional edge weights. Grapheme cluster A sequence of Unicode scalar values treated as one user-perceived character by text segmentation rules. GraphQL schema The type definitions, directives, and root operations that describe a GraphQL service’s available capabilities. Grid container An element whose grid formatting context lays out its direct child grid items in rows and columns. Grid item A direct child of a grid container that participates in that container's grid layout. Grid track The space between two adjacent grid lines, forming one row or one column of a grid. GroupBy A split-apply-combine operation that groups rows by keys before aggregation or transformation. Guard clause An early check that exits or skips work, leaving the main path at a shallower indentation level. Half-close Closing one sending direction of a bidirectional connection while leaving the opposite direction available. Half-open interval An interval that includes one endpoint and excludes the other, such as the [0, 1) range returned by Math.random(). Hash collision The event in which unequal keys produce the same hash or select the same hash-table bucket. Hash table An associative structure that uses key hashes and equality to organize lookup, insertion, and removal. Hashable Able to provide a lifetime-stable hash and equality behavior suitable for dictionary keys and set members. Head-of-line blocking Delay in which one blocked item prevents independent work queued behind it from advancing. Heap pollution A state where a parameterized variable refers to an object that violates its declared element type. Hidden friend A non-member friend defined in a class and normally found through argument-dependent lookup rather than ordinary lookup. Higher-order function A function that accepts another function, returns one, or does both. Higher-ranked trait bound A for-lifetime bound requiring a trait relationship to hold for every suitable lifetime. Hono Context The per-request Hono object for reading request data, sharing variables, accessing bindings, and constructing a response. Hono RPC Hono’s typed HTTP client pattern, which derives client paths, inputs, and responses from a server application type. Hostname verification Checking that a certificate identity covers the service name the client intended to reach. HPACK HTTP/2 field compression using static and connection-scoped dynamic tables. HTTP Strict Transport Security A host policy that tells browsers to replace future HTTP connections with HTTPS for a declared lifetime. HTTP/2 frame The smallest protocol unit in HTTP/2, with a fixed header and a type-specific payload. HTTP/2 stream An independent, bidirectional sequence of HTTP/2 frames identified within one connection. I/O redirection A shell operation that changes which file or descriptor supplies or receives a command stream. Idempotency The property that repeated identical requests have the same intended server effect as one request. Idempotency key A stable operation identifier used to recognize retries and prevent a side effect from being applied twice. Image layer A content-addressed filesystem change that can be shared by container images. Implicit any An any type introduced when TypeScript lacks enough information to infer a more specific type. Implicit grid Tracks created outside the explicit grid when auto-placement or positioned items require more grid space. Include guard A conditional macro pattern that prevents one header body from being processed repeatedly within a translation unit. Incremental generator A Roslyn source generator expressed as cached dataflow steps whose unchanged values can stop downstream recomputation. Index alignment The pairing of pandas values by row or column labels before an operation runs. Indexed access type A type expression T[K] that retrieves the property value type associated with key K in type T. Inference Running a trained model on supplied input to produce a prediction or generated output. Init accessor A C# property accessor that permits assignment during object construction but rejects later ordinary assignment. Inline namespace A namespace whose members are also exposed to lookup through its enclosing namespace. Inner class A nested class that is not explicitly or implicitly static. Inner exception The lower-level exception retained as the cause when another .NET exception wraps a failure. Instant A unique point on the time line, independent of how a locale or time zone displays it. Integer promotion The conversion of a lower-rank integer type to int or unsigned int before many expressions are evaluated. Interface Segregation Principle A client should depend only on the cohesive operations required by its role, not unused capabilities. Interface value A Go runtime value that pairs a concrete dynamic type with a dynamic value of that type. Interior mutability A Rust pattern that permits controlled mutation through a shared reference while preserving aliasing rules. Internal slot Specification state stored on an object but unavailable through ordinary JavaScript property access. Internationalization Designing software so language, regional formats, and writing direction can change without rewriting business logic. Intersection type A declaration that requires an object to satisfy every member class or interface type. Invariance A variance rule that does not carry a subtype relation through a generic type constructor. Invocation list The ordered sequence of method targets called by a multicast delegate. InvocationTargetException The reflection wrapper thrown when an invoked constructor or method terminates by throwing an exception. Iterable An object capable of returning an iterator that yields its items one at a time. Iterator A stateful producer that yields one item per next call and signals temporary or permanent exhaustion with None. Iterator adapter A usually lazy operation that wraps an iterator and produces another iterator with transformed traversal behavior. Iterator closing The protocol that calls an unfinished iterator return method when a consumer exits early. Iterator protocol The Python contract in which iter() obtains an iterator and next() returns items until StopIteration signals exhaustion. JSON text A Unicode text that conforms to JSON grammar and represents one JSON value. JSON Web Token A compact, URL-safe claims format carried in a signed or encrypted JOSE structure. Key agreement A process in which peers derive the same secret from private inputs and exchanged public values without sending the secret. Keyframe A property-value snapshot at a named percentage within one animation cycle. Keyword argument An argument that selects its destination parameter by name in a function call. KV cache Runtime attention keys and values retained from prior tokens so decoding can reuse them instead of recomputing the full prefix. Lambda with receiver A function literal whose body can access members of a designated receiver through this or implicitly. Landmark A named page region that assistive technology can expose for direct navigation. LangChain Expression Language LangChain composition syntax that connects runnable components with operators such as the pipe. Language Integrated Query C# language features and operators for composing typed queries over sequences and provider-backed data sources. Large language model A model trained on language data to predict tokens and generate or transform content from supplied context. Late binding Resolving a captured variable when a closure runs instead of freezing its value when the closure is created. Lazy evaluation Evaluation delayed until a consumer requests the result, rather than completed when the producer is created. LazyFrame A deferred Polars query whose transformations form a plan executed by collect or a sink. Least privilege Granting a principal only the capabilities and data needed for its current task. LEGB Python name lookup shorthand for Local, Enclosing, Global, and Built-in scopes, searched in that order. Lexical environment The bindings visible at a source-code location, together with the link used to search its enclosing environment. Lexical this The rule that an arrow resolves this through its enclosing lexical environment instead of its call form. Lifecycle command A command assigned to a defined host, creation, start, or attachment event in a Dev Container environment. Lifecycle hook A function registered for a defined phase of request parsing, validation, handling, response mapping, or cleanup. Lifetime A program region in which a reference is valid and may be used safely. Lifetime annotation Rust syntax that names relationships among the valid regions of references in a type or signature. Lifetime elision Deterministic rules that infer omitted lifetime parameters in supported Rust signature positions. Linearizability A model where each operation appears atomic between invocation and response and respects real-time order. Linked list A sequence of nodes whose links identify the next node and, optionally, the previous node. Liskov Substitution Principle A subtype must preserve the behavioral contract and correctness properties expected by callers of its base type. List comprehension An expression that transforms and optionally filters an iterable into a new list. List pattern A C# pattern that tests the length and indexed elements of a countable, indexable input, optionally with one slice. Literal type A type containing one exact string, number, bigint, or Boolean value rather than every value of its primitive type. Literal widening Inference replacing an exact literal with a broader primitive type when a value may need to change. Live binding An import connection whose reads reflect later rebinding performed by the exporting module. Load factor The ratio of stored entries to buckets, used to reason about collision pressure and resizing. Locale A language-and-region convention used to select messages and presentation rules, often represented by a BCP 47 tag. Localization Adapting and validating messages, formats, and presentation for a particular language, region, or market. Loop else An else suite that runs when a for or while loop completes without executing break. Lvalue reference A reference written T& that normally binds to an lvalue and provides access to the same object or function. Macro A named preprocessing replacement that expands to a token sequence, optionally using argument token sequences. Magic method A specially named method that PHP invokes for a defined object operation such as inaccessible member access or cloning. Main axis The primary axis along which a flex container lays out and distributes its items, selected by flex-direction. Mapped type An object type constructed by iterating over a union of property keys and computing each property. Mass assignment Writing several model attributes from one input map, subject to an explicit allowlist or guard policy. Match ergonomics Rust rules that auto-dereference reference subjects and adjust pattern binding modes during matching. Match expression An expression that strictly compares one subject with arms and returns the selected arm value. Match guard A condition evaluated after a case pattern succeeds and before its branch is selected. Materialization Executing a query and storing its results in a concrete container such as a list, array, or dictionary. Matplotlib Artist A visible or layout element in a Matplotlib figure, such as a line, rectangle, text label, or legend. Matplotlib Axes One plotting area in a Figure, with data limits, labels, and the methods that add most artists. Matplotlib backend The layer that connects a Figure canvas to a renderer and, when needed, a GUI event loop or file format. Matplotlib Figure The top-level container that owns a plotting canvas, layout, and one or more Axes. Media query A conditional CSS rule selected from media type, viewport, display, input, or user-preference features. Member information A .NET reflection descriptor for a type member, specialized as metadata objects for methods, constructors, properties, fields, and events. Member initializer list The part of a constructor that initializes bases and members before the constructor body executes. Memberwise initializer An initializer Swift can synthesize for a structure with parameters corresponding to its stored properties. Memo dictionary The identity map deepcopy uses during one traversal to reuse copied objects and close cycles. Memoization Reusing a function result previously stored for the same input key. Memory A storable value type for a contiguous memory region that yields a Span for synchronous access. Memory leak Memory retained by references after the application no longer needs the associated objects. Merge base A best common ancestor used to compare the independent changes leading to two commit tips. Message framing Rules for finding complete application messages in a byte stream, such as delimiters or length prefixes. Meta-annotation An annotation on an annotation interface that defines rules such as its target, retention, inheritance, or repeatability. Method group One or more methods selected by name and converted using a target delegate signature. Method resolution order The ordered class sequence Python uses to look up attributes and resolve inherited behavior. Method set The methods associated with a Go type or pointer type, used to decide which interfaces that type implements. Microtask A high-priority queued job, such as a Promise reaction, drained before the next event-loop task. Middleware A component that wraps Django request and response handling to apply cross-cutting behavior. Migration A versioned Django operation that moves database schema or data from one recorded state to another. Mixin A named Sass block that accepts arguments and emits declarations or rules at an @include call site. Model card Documentation describing a model’s intended uses, limitations, training context, evaluation, and license. Model Context Protocol A protocol through which AI applications discover and use structured tools, resources, and prompts exposed by servers. Model repository A versioned repository containing model weights, configuration, processors, metadata, and documentation. Module namespace object An object-like view containing a module export set, with properties that reflect its exported bindings. Module specifier The string or URL-like value a host resolves to identify the module requested by an import. Move semantics Object initialization and assignment that can transfer resources from a source whose old value may be abandoned. Moved-from state The state of a source object after an operation has transferred some or all of its resources. Multicast delegate A delegate whose ordered invocation list can contain one or more handlers. multipart/form-data An HTTP media type that separates form fields and files into boundary-delimited parts. Multiple enumeration Traversing one enumerable more than once, potentially repeating work, effects, I/O, or remote queries. Multiplexing Interleaving independent streams over one connection while preserving order within each stream. Mutable default argument A mutable object created as a parameter default and reused by calls that omit that argument. Mutable reference A reference written &mut T that grants exclusive access to read and mutate its referenced region. Mutation testing A technique that makes small systematic code changes and checks whether the test suite rejects each changed program. Mutex A synchronization primitive that grants one owner at a time exclusive access to protected state. N-dimensional array NumPy’s homogeneous multidimensional array, described by a shape, dtype, strides, and a data buffer. N+1 query One query for parent rows followed by one additional related-data query for each parent. Name binding The association of a name with an object in a particular Python scope. Named argument An argument that explicitly names its destination parameter, field, or property instead of relying only on position. Named tuple A tuple subclass whose positional fields also have names for attribute access. Named volume A Docker-managed persistent data store whose lifecycle is independent of one container. Namespace A hierarchical part of a declared symbol name that separates otherwise colliding classes, functions, or constants. Namespace alias A file-local alternate spelling for an imported namespace or symbol name. Narrowing conversion A conversion to a type that cannot represent every source value and may discard range or precision. Natural language processing Computing methods that turn human language into representations and outputs for defined tasks. Negative DNS caching Caching authoritative evidence that a DNS name or a requested record type does not exist. Nested class A class declared inside another class or interface, including member, local, and anonymous classes. Network byte order The big-endian byte order convention used to encode multi-byte integers in many network protocols. Network partition A fault in which some nodes remain running but messages between groups are lost or indefinitely delayed. Nil coalescing The Swift ?? operation that unwraps a present optional or lazily evaluates a compatible fallback value. Nil slice A slice whose value is nil; it has zero length and capacity and can be ranged over or appended to. Nominal typing Type compatibility based on declared identity rather than only on the members a value contains. Non-lexical lifetimes Borrow analysis that derives reference-use regions from control flow instead of only lexical block boundaries. Non-local return A return inside an inlined lambda that exits the function enclosing the lambda rather than only the lambda call. Null bubbling Propagation that nulls the nearest nullable parent when a GraphQL Non-Null field fails to produce a value. Null pointer A pointer value that is guaranteed not to point to any object or function and must not be dereferenced. Nullable dtype A pandas data type that represents missing values without abandoning its domain type. Nullable reference type A C# reference-type annotation that declares null as an expected value for compiler flow analysis. Nullable type A Kotlin type marked with ? whose set of permitted values includes null. Nullsafe operator The ?-> operator, which stops a property or method chain and yields null when its left side is null. Numeric promotion Java rules that convert numeric operands to the types used to evaluate unary or binary numeric expressions. Object graph Objects represented as nodes and the references between them represented as directed edges. Object identity The stable property that distinguishes one object from every other object; Python compares it with is. Object key The identifier used by an object store to address one object within a bucket or namespace. Object pointer A pointer value that points to an object or one past an array object, rather than designating a function. Object representation The bytes that occupy a C or C++ object, including value bits and any padding. Object slicing Copying a derived object into a base object and thereby discarding the state and behavior of its derived portion. OCI artifact Non-container content distributed as a content-addressed graph of OCI descriptors, manifests, configuration, and blobs. Opaque type A type spelled with some whose fixed concrete identity is chosen and hidden by the implementation. Open/Closed Principle Stable software should accept expected variation through extension without repeated modification of its core policy. OpenAPI A machine-readable specification for HTTP API operations, parameters, request bodies, responses, and security schemes. Operator function A function declared with an operator-function name that implements one of the overloadable C++ operators. Operator overloading Defining how an existing operator behaves when at least one operand has a class or enumeration type. Optional binding Swift syntax that tests whether an optional contains a value and binds its unwrapped value in one operation. Optional chaining Conditional member access, method calling, or subscripting that returns nil when an optional receiver is nil. Optional value A value that either contains one wrapped value of a declared type or represents absence. Ordered map A key-value container that retains a defined iteration order for its entries. Origin The scheme, host, and port tuple that browsers use as a security boundary for a document or resource. Outlives bound A bound such as a: b stating that one lifetime or type remains valid for at least another lifetime. Overload resolution The process that selects one best viable function from candidates by comparing argument conversion sequences. Ownership The responsibility a variable or place holds for keeping a Rust value valid and running its destruction when that responsibility ends. PACELC A principle adding the healthy-path latency-versus-consistency trade-off to CAP's partition choice. Padding byte Storage inserted by an implementation to satisfy layout requirements but not belonging to the value of a struct member. Page fault An exception raised when a virtual-page access needs kernel handling because translation is absent or disallowed. Panic unwinding The process of running deferred calls while a Go panic moves up the current goroutine call stack. Parameter A named input slot declared by a function definition and bound during a call. Parameter expression An expression-tree node whose object identity binds uses of one parameter or local variable. Partial application Creating a callable by binding some arguments of another callable in advance. Partial move A move of one field or subplace that leaves other initialized parts usable but prevents use of the complete value. Pathname expansion The shell stage that replaces an eligible wildcard pattern with matching pathnames from the filesystem. Pattern matching Checking a value against a structural pattern and optionally binding the data found inside that structure. Pattern variable A variable introduced by a successful Java pattern match and available only where control flow proves it is bound. PHP list A PHP array whose keys are consecutive integers from zero in iteration order. Pin A pointer wrapper whose safe interface prevents moving an address-sensitive pointee before its destruction completes. Pin projection Deriving access to a field from a pinned parent while preserving the field’s declared pinning status. Pinning invariant The requirement that an address-sensitive value stays at one valid location until its destruction finishes. Pipeline A set of commands whose streams are connected so bytes produced by one stage become input to another. Platform type A Java-origin type whose nullability Kotlin cannot determine, so callers may use it as nullable or non-null. Plural category A locale-defined label such as one, few, or other used to select the grammatical message branch for a number. Positional argument An argument whose position selects and supplies the corresponding parameter in an ordered parameter list. Predicate pushdown An optimization that moves filters toward the data source so irrelevant rows can be skipped earlier. Prefab A reusable GameObject hierarchy saved as a Unity asset, from which connected instances can be created. Preflight request An automatic OPTIONS request that asks whether a server permits a planned cross-origin method and headers. Preprocessing directive A logical source line introduced by # that controls inclusion, macro definitions, conditionals, or other preprocessing work. Presigned URL A time-limited URL authorizing a specific storage operation under the signer’s permissions. Preview feature A fully implemented Java feature offered temporarily for feedback and requiring explicit compile-time and runtime opt-in. Primary associated type An associated type named in a protocol’s angle brackets so opaque and existential uses can constrain it concisely. Primitive type A built-in Java value type for Boolean, integral, or floating-point values that cannot hold null. Primitive value A non-object JavaScript value: undefined, null, Boolean, Number, BigInt, String, or Symbol. Private brand An internal class identity checked on the receiver whenever code accesses a private element. Private field A class element named with # whose access is restricted to its declaring class body and checked by receiver brand. Problem Details The standard HTTP API error document format defined by RFC 9457. Process A running program instance with its own identity, virtual address space, descriptors, and lifecycle state. Progressive enhancement A design approach that starts with a useful baseline and adds capabilities without making enhancement failure destructive. Projected value Optional wrapper-defined API exposed through the compiler-synthesized $property name. Projection pushdown An optimization that asks a data source for only the columns required by downstream operations. Prompt injection Untrusted content that attempts to redirect a model away from the application's intended instructions. Property A member that exposes read or assignment behavior through field-like syntax and one or more accessors. Property accessor A get, set, or init body that implements one permitted operation on a C# property. Property delegate An object that provides getValue and, for mutable properties, setValue for a delegated property. Property descriptor Metadata that defines a JavaScript own property as a data or accessor property and controls its flags. Property key A string or Symbol that identifies a property in the JavaScript object model. Property overloading Dynamic handling of reads, writes, existence checks, and deletion for inaccessible PHP object properties. Property pattern A C# pattern that matches readable fields or properties against nested patterns and fails when the required receiver path is null. Property wrapper A Swift type that supplies reusable storage and access behavior for a wrapped declaration. Protocol Buffers A schema language and binary message format built around stable numeric field identifiers. Protocol conformance An explicit checked relationship stating that a type supplies every requirement of a named protocol. Protocol requirement A property, method, initializer, or subscript capability that every conforming type must supply. Prototype chain The linked sequence of prototype objects followed when JavaScript looks up an inherited property. Proxy invariant A consistency rule that constrains trap results according to the target object state. Proxy trap A handler method that intercepts one fundamental operation performed on a JavaScript Proxy. Pseudo-localization A test transformation that expands and alters source text while preserving placeholders to expose internationalization defects. PSR-4 A PHP-FIG convention that maps namespace prefixes and class-name suffixes to filesystem paths. Pure virtual function A virtual function declared with = 0 that keeps a class abstract until a concrete final overrider exists. Quality attribute A measurable property of how a system behaves under a stated condition, such as reliability, security, or maintainability. Quantization Representing model data with fewer or lower-precision values to reduce storage and memory, with task-dependent quality trade-offs. Query plan A structured description of data operations that an engine can inspect and rewrite before execution. Query provider A component that creates or executes queries described by IQueryable expression trees. QuerySet A composable, usually lazy description of a database query and its eventual model results. Quorum A subset of replicas large enough to authorize an operation under a distributed protocol. Race condition A defect in which correctness depends on an uncontrolled ordering of concurrent events. Rate limiting Controlling how much request or work budget an identity may consume during a defined interval. Raw type A generic Java class or interface name used without type arguments, bypassing some generic checks. Raw value A fixed, unique string, character, integer, or floating-point value declared for an enum case. Re-export A public use binding that gives an existing item another externally reachable API path without copying it. Reachability Whether an object can be found by following references from the runtime roots. Read-only collection A collection interface that exposes element access but no mutation operations; its backing object may still be mutable. Receiver The parameter that associates a Go method with a defined base type and supplies the value used by a method call. Record class A Java class declared from record components, with compiler-derived fields, accessors, construction, and value methods. Record pattern A Java pattern that tests a record value and decomposes its components into nested patterns or variables. Record type A C# class or struct declared with record, with synthesized value equality, display, and with-expression support. Recovery boundary An explicit goroutine or API boundary that may stop a panic and report the failed unit of work. Recursion A control technique in which a routine solves a problem by invoking itself on smaller instances. Recursive case A recursive definition branch that reduces the current problem to smaller instances of the same problem. Recursive CTE A CTE whose recursive member repeatedly derives rows from an anchor set until no new round is produced. Recursive DNS resolver A service that answers a client by using cached DNS data or following delegations to authoritative servers. Reduced motion A user preference requesting that non-essential movement be removed or replaced. ref struct A value type governed by ref-safety rules so its instances cannot escape a valid stack context. Reference collapsing The rules that reduce combinations of reference types formed through aliases or deduction to one reference type. Reference counting An ownership strategy that destroys a value when its count of strong owners reaches zero. Reference identity The property that two references point to the same class instance, tested in Swift with === or !==. Reference log A local, expiring log of prior values taken by HEAD or another Git reference. Reference type A Java type whose values refer to objects or arrays, or hold the null reference. Reference-count control block Metadata associated with a shared allocation that tracks strong and weak pointer lifetimes. Reflection Runtime APIs for examining assemblies, types, members, and metadata and, when intended, creating or invoking them dynamically. Reflective access Runtime access to a Java type or member through reflection, subject to language checks and module exports or opens. Refresh token A credential sent to an authorization server to obtain new access tokens. Refutable pattern A pattern that can fail for some values of its input type and therefore needs an explicit failure path. Regular expression A pattern language and matching object used to locate, capture, or transform text according to explicit character and position rules. Reifiable type A Java type with enough runtime representation for operations such as `instanceof` and array creation. Remote procedure call A call-shaped interface whose implementation runs in another process and therefore has network failure semantics. Remote user The container account used for lifecycle scripts and processes launched by a Dev Container supporting tool. Repeatable annotation An annotation type that may occur more than once at one location and is represented through a compatible container annotation. Replacer A JSON.stringify callback or property list that controls which values enter the JSON output. Representation A transferable description of a resource state in a selected media type. Request context The active Flask scope that provides request and session proxies for one request. Request extractor A typed boundary that constructs a handler argument from an HTTP request or its reusable parts. Request ID A provider-assigned identifier that correlates one API request with diagnostics and support records. Required member A C# field or property that ordinary object-creation expressions must initialize. Resident set size An estimate of a process mapping’s pages currently resident in physical memory, with shared-page accounting caveats. Resolver A function that supplies the value of a GraphQL field from its parent, arguments, request context, and data sources. Resource A conceptual object or service capability identified by a URI and manipulated through representations. Resource Acquisition Is Initialization Binding resource ownership to object lifetime so destruction releases the resource on every scope exit. Response item A typed element in a model response output, such as a message, reasoning item, or tool call. Response model A declared public shape used to validate, serialize, document, and filter an API response. Responsive web design An approach that adapts one web document to available space, user preferences, and input capabilities. Rest element The final ... target in a destructuring pattern, collecting remaining values or properties into a new container. Rest parameter A final parameter prefixed by ... that collects remaining call arguments into an Array. Result type A type that stores either a successful value or a typed failure value for later inspection. Retention policy The rule that determines whether annotation metadata remains only in source, in class files, or visible to runtime reflection. Retroactive conformance A conformance declared in a module that owns neither the conforming type nor the adopted protocol. Reverse mapping A runtime mapping from an enum value back to its member name, emitted automatically for numeric TypeScript enums. Revision A branch, tag, or commit hash that selects one version of files in a repository. Reviver A JSON.parse callback that visits parsed properties bottom-up and may replace or delete them. Route model binding Framework resolution of a route parameter into a model instance before the route action runs. Route schema A runtime-validatable declaration of the inputs or per-status outputs attached to an HTTP route. Row-major order A multidimensional layout in which every row array is stored before the next row. Rune Go alias for int32, conventionally used for an integer value representing a Unicode code point. Runnable A LangChain unit with a common interface for invocation, composition, batching, and streaming. RuntimeClass A Kubernetes resource that selects a configured CRI runtime handler and can add scheduling constraints and Pod overhead. Rust module A named container of items inside one crate that participates in Rust path resolution and visibility checking. Rvalue reference A reference written T&& that can bind to an rvalue and participate in selecting move-aware overloads. Safe call Kotlin’s ?. operator, which accesses a member only for a non-null receiver and otherwise returns null. Safe integer An integer that JavaScript Number can represent exactly and compare without rounding ambiguity. Safetensors A tensor serialization format designed for safe, fast loading without Python pickle objects. SAM conversion Conversion of a matching lambda into an instance of an interface whose contract has one abstract method. Same-origin policy A browser security rule that limits how a document or script can interact with resources from another origin. Same-type requirement A generic requirement stating that two type expressions must resolve to exactly the same type. SameValueZero An equality algorithm like strict equality, except that NaN equals itself and positive zero equals negative zero. Sass module A Sass stylesheet loaded once through @use, with public variables, functions, mixins, and emitted CSS. satisfies operator A TypeScript operator that checks assignability against a target while retaining the expression’s contextually inferred result type. Scalar type A PHP type whose value is one Boolean, integer, floating-point number, or string. Scaled time Unity game time whose rate follows Time.timeScale, including stopping when that scale is zero. Scope The region of code where a name is directly visible under the language’s name-resolution rules. Scope function A Kotlin standard-library function that invokes a lambda with an object as its temporary context. ScriptableObject A UnityEngine.Object data type that can exist as a project asset and be referenced independently of scene components. Sealed class A Java class or interface whose declaration restricts which types may directly extend or implement it. Sealed interface A Kotlin interface whose direct implementations are restricted to named types in the same package and module. Selection set The fields and nested fields an operation or fragment asks a GraphQL service to include in a result. Semantic HTML HTML that uses elements according to their defined content and interaction purposes. Semantic model A compilation-bound view that resolves syntax to symbols, types, conversions, and declared meanings. Sendable closure A function value marked @Sendable whose captures satisfy the requirements for transfer across concurrency domains. Sentinel error A stable error value exposed so callers can recognize a documented failure category with errors.Is. Separate chaining A collision strategy that keeps all entries selecting one bucket in a per-bucket collection. Sequence A Kotlin value that produces elements lazily through intermediate operations when a terminal operation consumes it. Sequence unpacking Binding values from an iterable to a matching target structure, optionally with one starred target. Sequenced collection A Java collection with a defined encounter order, operations at both ends, and a reverse-ordered view. Serialization Converting an in-memory value into a representation suitable for storage or transfer. Serialized field A script field whose supported value Unity stores in a scene or asset and can expose for Inspector editing. Series A one-dimensional labeled sequence with one data type and an index. Server-Sent Events An HTTP streaming format in which a server sends a sequence of named events over one response. Server-Side Request Forgery A flaw that lets untrusted input influence a network request made with a server's reach, identity, or credentials. Service container A registry and object factory that maps abstractions to implementations and resolves dependency graphs. Shallow copy A new outer container whose nested objects still share references with the source. Shared ownership An ownership model in which several strong owners keep one object alive until the final owner releases it. Shared reference A reference written &T that permits shared observation without ordinary mutation through that reference. Short count A transfer result smaller than the requested element count, requiring EOF or error handling. Short variable declaration A function-local Go declaration using := that infers types and must introduce at least one non-blank name in its block. Short-circuit evaluation Conditional evaluation in which && or || skips its right operand when the left result already determines the result. Signal A kernel-delivered asynchronous notification whose disposition can terminate, stop, ignore, or invoke handling code. Single dispatch Runtime selection of one implementation from the type of one designated argument. Single Responsibility Principle A module should be responsible to one actor, grouping behavior that changes for the same reason. Slice header The value-level descriptor that records a slice start, length, and capacity over backing storage. Smart cast A compiler-proven narrowing based on type checks, null checks, and control flow, with no explicit cast in source. Smart pointer A pointer-like type that adds ownership, destruction, or other resource-management behavior. Socket An operating-system communication endpoint associated with an address family, protocol, local address, and optional peer. Software bill of materials A machine-readable inventory of software components and their relationships for a defined artifact or system. Source generator A compiler-loaded component that reads declared build inputs and adds source files or diagnostics to a compilation. Span A stack-only value type that provides a type-safe view over a contiguous region of memory. Sparse array An array whose index range contains empty slots where no indexed property exists. Special member function One of the constructors, assignment operators, or destructor whose declaration can be governed by special language rules. Spring bean An object whose construction, dependencies, scope, and lifecycle are managed by a Spring application context. Stable sort A sort that preserves the original relative order of elements that compare equal. Stack trace Diagnostic call-path information recorded as an exception propagates from its throw site. Stack unwinding Destroying completed automatic objects as exception handling transfers control outward to a matching handler. stackalloc A C# expression that allocates a contiguous region of memory in the current stack frame. Standard stream A conventional process input or output channel: standard input, standard output, or standard error. Starter dependency A curated dependency descriptor that brings together compatible libraries for one Spring Boot capability. Statement A complete unit of execution that declares state, performs an action, controls flow, or transfers control. Static dispatch Selection of a callable from compile-time types and scope rather than the receiver runtime subtype. Static extraction Producing CSS assets from analyzable source declarations during the build instead of generating those rules in the browser. Static lifetime The lifetime spanning a program’s complete execution, used by references to static storage. Stop reason The response field that states why a model turn ended and whether the application must continue it. Strict types A per-file PHP mode that disables most scalar coercion for user-defined function calls. String pool The JVM-managed set of canonical String instances used by literals, constant string expressions, and intern(). String slice A borrowed or owned view of contiguous valid UTF-8 bytes represented by Rust str. Strong parameters Rails parameters marked with an explicit field allowlist before they may be used for mass assignment. Strong reference An owning reference that keeps a class instance alive while that reference is still needed. Strong reference cycle A closed path of owning references that keeps its instances alive after outside ownership disappears. Struct tag A string literal attached to a Go struct field for reflection-based packages to interpret by their own conventions. Structural change An ECS operation that changes entity storage shape, such as adding a component or creating an entity. Structural equality Equality based on selected content or structure rather than whether two references point to the same object. Structural pattern matching Branch selection that tests and extracts the shape and contents of one subject value. Structural typing Compatibility based primarily on the members a value has rather than an explicitly declared type identity. Structure type A C aggregate type whose object contains all named members in declaration order, with implementation-selected padding. Structured concurrency A model that binds child-task lifetimes and failure propagation to a lexical scope. Style injection Adding generated CSS rules to a document stylesheet or to a style collector during server rendering. Subgrid A nested grid that adopts the parent grid's track sizing on its rows, columns, or both. Subtype polymorphism Calling behavior through a base type while the runtime subtype selects the overriding implementation. Sunset The expected time after which an HTTP resource may stop responding, communicated as a lifecycle hint. Supersession A relation in which a new accepted decision replaces an older one without deleting or rewriting its history. Suppressed exception A secondary Throwable retained while another primary exception continues propagating. Swift extension A declaration that adds computed members, initializers, nested types, or conformances outside a Swift type’s original declaration. Switch expression A Java switch form that exhaustively selects a branch and produces a value. Symbol A JavaScript primitive with unique identity that can also serve as an object property key. Syntax tree An immutable tree that represents source structure and retains tokens, trivia, and syntax errors. System call A controlled entry from a user-space process into the kernel to request an operating-system operation. Tagged union A discriminant paired with a union payload under an invariant that the tag identifies the member currently holding a value. Tailwind source detection The build step that scans source text for complete candidate class names from which Tailwind can generate CSS. Tailwind theme variable A CSS variable declared with @theme that exposes a design token and controls related Tailwind utilities. Tailwind variant A prefix that makes a utility conditional on a state, media query, attribute, or structural relationship. Technical debt A design or construction choice that makes a future class of software changes more costly than a more suitable choice would. Template literal type A type that combines string literal types through template interpolation to produce new string literals. Temporal dead zone The region where a lexical binding exists but cannot be read before its declaration initializes it. Terminal operation An operation that consumes a sequence and returns a non-sequence result, triggering the sequence’s lazy evaluation. Test oracle A source of expected results or properties that decides whether observed behavior is correct for a test. Text block A multiline Java string literal whose line endings, incidental indentation, and escapes are processed by the compiler. TF-IDF A sparse feature weight that combines a term's frequency in one document with its rarity across documents. this binding The rule that supplies the this value for a JavaScript function call from its function kind and call form. Thread A schedulable execution path within a process, with private execution state and access to shared process resources. Three-way comparison A comparison that reports less, equivalent, greater, or, for a partial order, unordered in one result. Throwable The base interface shared by PHP Exception and Error objects, all of which can be thrown and caught. Throwing function A function whose signature permits it to transfer control to its caller by throwing an error instead of returning normally. Time zone A set of rules that maps instants to local calendar fields and offsets, often identified by an IANA name. Timing function A function that maps linear time progress to the progress used for interpolation. TLS handshake The negotiation that authenticates peers, agrees parameters, and derives traffic secrets before protected application data flows. Token A unit of text or other input produced by a model tokenizer and processed by the model. Token revocation Invalidating a token or its session before its natural expiration. Tokenization The rule-driven conversion of text into the token sequence consumed by a model or feature pipeline. Tool call A structured request from a model to a host to execute a named operation with supplied arguments. Tool use A protocol in which a model requests a named operation and an application or provider executes it. Top-level statement An executable C# statement written at file scope for which the compiler generates the application entry point. Tower layer A composable wrapper that transforms a Tower service to add cross-cutting request and response behavior. Trait A PHP code-reuse unit that composes methods, properties, and constants into classes without becoming an instantiable type. Translation unit A C or C++ source file after preprocessing, including the headers and tokens brought into it. Transport The HTTP client boundary that turns a constructed request into a response through network or in-process I/O. Tree A connected acyclic graph; a rooted tree gives every non-root node exactly one parent. tRPC context Request or call state supplied to tRPC procedures, such as identity, services, tracing, and data access. tRPC procedure A callable tRPC pipeline that parses input, runs middleware and a resolver, and may validate output. tRPC router A named tree of tRPC procedures whose TypeScript type supplies client paths, inputs, and outputs. Truth value testing The protocol Python uses to decide whether an object counts as true or false in a condition. Tuple An ordered Python sequence whose element slots and length cannot change after creation. Tuple packing The construction of one tuple from a comma-separated expression list. Type annotation Explicit type syntax attached to a declaration, parameter, property, or return value for static checking. Type assertion A developer-supplied instruction about a value type that changes static checking without validating or converting the value. Type coercion Automatic conversion of a value to the type an operation requires. Type coverage The share of checked identifiers whose types do not escape to any under a defined tool policy. Type erasure Removal of type-only syntax during emission so it has no direct representation in the runtime JavaScript. Type guard A runtime condition TypeScript uses to narrow a value along one control-flow path. Type inference The compiler deriving an expression or declaration type from its initializer, arguments, and surrounding expected type. Type juggling PHP automatic conversion of a value according to the operation or context using it. Type parameter A placeholder type declared by a generic function, class, interface, or type alias. Type predicate A parameter is Type return annotation that lets a function communicate narrowing to its caller. Type set The non-interface types represented by an interface and allowed by it when the interface is used as a constraint. Type token A runtime type representation passed as a value so generic code can check, inspect, or construct a type. Type-safe builder A construction API whose types restrict the structures or call sequences a client can express. Type-use annotation A Java annotation targeted at a particular occurrence of a type, including a type argument, cast, bound, or array dimension. Typed array A numeric array view with one element type over bytes owned by an ArrayBuffer or SharedArrayBuffer. Typed nil An interface value with a concrete dynamic type and a nil dynamic pointer, which makes the interface non-nil. Typed throws Swift syntax that declares one concrete error type a function or closure is allowed to throw. TypeScript strict mode The compiler-option family that enables TypeScript’s stricter static checks through strict: true. Unboxing A Java conversion from a wrapper reference to its primitive value; unboxing null throws NullPointerException. Unchecked exception A runtime exception or error type that Java does not require a method to catch or declare. Undefined behavior Program behavior for which the C++ standard imposes no requirements. Underlying type The non-named type reached by recursively following a named type declaration, used by assignability and constraint rules. Unicode code point A numbered position in the Unicode codespace, represented in UTF-16 by one code unit or a surrogate pair. Unicode scalar value Any Unicode code point except the surrogate range U+D800 through U+DFFF; represented by Rust char. Union type A declaration that accepts a value satisfying at least one of its member types. unique symbol A TypeScript symbol type whose identity belongs to one const declaration or readonly static property. Unity component One attachable piece of data or behavior owned by a GameObject, including built-in types and MonoBehaviour scripts. Unix epoch The reference instant 1970-01-01T00:00:00Z from which Unix-style timestamps measure elapsed time. Unnamed namespace A unique namespace within one translation unit whose names have internal linkage. Unowned reference A nonowning reference whose ordinary form requires the target to remain alive whenever it is accessed. Unpin An auto trait marking types whose values remain sound to move even after they are placed behind Pin. UnsafeCell Rust primitive that permits mutation through shared references when unsafe code upholds aliasing and data-race rules. Untyped constant A Go constant with an exact value but no explicit ordinary type until context supplies one or its default type is needed. Upload quarantine Non-public storage where uploaded bytes remain unavailable until required checks pass. URLconf An ordered set of Django URL patterns that maps request paths to views. URLRequest A value describing one URL load, including its method, headers, body, cache policy, and timeout. URLSession The Foundation object that coordinates a configured group of network transfer tasks on Apple platforms. Using-declaration A declaration that introduces specified declarations from another scope for name lookup. Using-directive A directive that makes unqualified lookup consider names from a nominated namespace. UTF-16 code unit A 16-bit unit used by Java String indexing; one Unicode code point may require one unit or a surrogate pair. Utility class A CSS class with a narrow styling purpose, such as setting padding, display, color, or one conditional state. Utility type A reusable generic type transformation that derives a new static contract from existing types. Utility-first CSS A styling approach that builds interfaces by composing small, reusable classes around individual declarations. Validation message The localized message a form control exposes when its current value fails constraint validation. ValidityState The DOM object whose Boolean flags describe which constraints a form control currently violates. Value class A Kotlin class with one data property whose instances have no stable object identity and may use the property runtime representation. Value semantics Semantics in which copying a value creates logically independent state, so later mutation of one copy does not change the other. Value type A type whose variable directly contains its value and whose ordinary assignment copies that value. Variadic parameter A parameter that collects zero or more unmatched positional or keyword arguments. Variance How an existing subtype conversion is preserved, reversed, or blocked through a generic interface or delegate type parameter. Vectorization Expressing a calculation as array operations so iteration occurs inside the array implementation. Virtual destructor A destructor that lets deletion through a base pointer begin destruction at the most-derived object. Virtual dispatch Runtime selection of a virtual function’s final overrider according to the complete object’s dynamic type. Virtual function A non-static member function whose final overrider can be selected from an object’s dynamic type. Virtual inheritance Inheritance that lets multiple paths share one virtual-base subobject in the most-derived object. Virtual memory An address-translation system that gives processes protected virtual spaces backed on demand by RAM, files, or swap. Virtual thread A lightweight Java Thread scheduled by the JDK that need not occupy one operating-system thread for its lifetime. Visual channel A perceptible graphical property used to carry data, such as position, size, hue, shape, or opacity. Visual encoding A rule that maps a data field to a visual property such as position, length, color, shape, or opacity. Weak collection A non-enumerable collection whose presence alone does not keep its garbage-collectable keys or members alive. Weak reference A nonowning optional reference that ARC automatically sets to nil after its target is deallocated. Web Server Gateway Interface The Python callable protocol between a synchronous web server and a web application. WebAssembly Component Model A WebAssembly architecture for typed, language-neutral interfaces, composition, and portable application components. WebAssembly module A validated binary containing Wasm definitions, imports, exports, instructions, and data for a host runtime to instantiate. WebAssembly System Interface A standards-track family of host interfaces that lets Wasm applications use explicitly supplied system capabilities. WebSocket handshake The opening exchange that validates WebSocket support and negotiates options before messages flow. WebSocket subprotocol An application protocol selected from values offered during the WebSocket handshake. Well-known symbol A specification-defined Symbol used as a property key for a JavaScript protocol hook. Wildcard A `?` type argument denoting an unknown type, optionally constrained by an upper or lower bound. Wildcard capture The compiler operation that gives one wildcard expression a fresh internal type for type checking. Window frame The row, peer-group, or value-range segment used for a window calculation at the current row. Window function A function evaluated over a partition of query rows while preserving one output row per input row. with expression A C# expression that copies a record or struct and assigns selected members on the resulting copy. Word splitting The shell stage that divides eligible unquoted expansion results into fields according to IFS. Working directory The directory a process uses as the base for relative paths and from which many tools discover project configuration. Wrapped value The value exposed through a wrapped property by the wrapper type’s wrappedValue member. WSGI environ The per-request mapping through which a WSGI server supplies CGI request data, input streams, and execution flags. Yield instruction A value yielded by a Unity coroutine that tells the runtime which condition or player-loop point should resume it. Zero value The value a Go variable receives when its declaration or allocation supplies no explicit initializer.