Reference

Glossary

Every acronym and term used across the handbook, A to Z, with a link back to the topic it comes from.

2167 terms

A

A/B (seamless) update: Two copies (slots) of key partitions; the update is written to the inactive slot and activated on reboot, with rollback on failure. Trace a Path Through the Android Stack
A/B partitions: Two copies of system partitions so an update installs to the inactive slot and the device can fall back if it fails to boot. System Design
A/B slots: Two copies (_a, _b) of updatable partitions so an OTA can install to the inactive copy and roll back on failure. Android Boot Process
A/B test: A controlled online experiment that randomly splits users between variants to measure the effect on business and guardrail metrics. GenAI System Design & Case Studies
A/B test: Randomised online experiment comparing a control and a treatment variant on real users with pre-defined metrics. LLM Evaluation, Safety & Responsible AI
A/B test: A randomized experiment comparing a control and a treatment on a pre-chosen metric using a hypothesis test. Math & Statistics for ML
A/B update: Seamless OTA that writes the inactive slot and reboots into it, with bootloader rollback if the new slot fails. Platform Integration & Release
A/B update: Two copies (slots) of key partitions; the update is written to the inactive slot and the device switches on reboot, with rollback on failure. Wear OS Platform
A2A (Agent2Agent protocol): An open protocol (launched by Google in 2025, now Linux Foundation) that lets independent agents from different teams or vendors discover each other and collaborate on tasks without sharing internals. Agentic AI & Multi-Agent Systems
ABI: Application Binary Interface: sizes, alignments, calling convention and symbol names that compiled objects must agree on. C Language
ABI: Application binary interface: how types, calls, vtables and library objects are laid out so separately compiled files can link. C++ Language
ABL: Android Boot Loader. Qualcomm's Android-aware bootloader (a UEFI application) that handles boot modes, slots, AVB and fastboot. Android Boot Process
Abstention: The model declining to answer when evidence is insufficient. It is designed in to reduce hallucination. GenAI System Design & Case Studies
Abstention: The model declining to answer or saying "I don't know" when it lacks sufficient information. LLM Evaluation, Safety & Responsible AI
AccessNetworksManager: Telephony component that prefers cellular vs IWLAN (and related access) for a data call. Android Data Call: Control, netd, eBPF & Packets
Accuracy: Fraction of all predictions that are correct; misleading on imbalanced data. Machine Learning Fundamentals
ACID: Atomicity, consistency, isolation, durability: the transaction guarantees of relational databases. System Design
ACK: Android Common Kernel: Google's kernel branches from which GKI builds are made. Linux Kernel & BSP
ACK (SIP): Final message confirming a 200 OK to an INVITE; after it, media flows. CS & IMS Call Flows
ACL: Access-control list: per-object list of who may perform which operations. File mode bits are a tiny ACL. Operating System Concepts
Action: In ReAct, the step where the agent interacts with the environment, usually a tool call or a finish command. Agentic AI & Multi-Agent Systems
Activation: The output value of a neuron after its activation function; also used for the function itself. Deep Learning & Neural Networks
Activation quantization: Representing the intermediate outputs of layers with low-bit integers; harder than weight quantization because ranges depend on inputs and contain outliers. Edge AI Deployment & Projects
ActivityThread: The class whose main() is the entry point of every app process; owns the main Looper and handles lifecycle messages from the system. Android Frameworks Internals
AdaBoost: Boosting method that reweights misclassified samples and combines weak learners with weights based on their error. Machine Learning Fundamentals
Adam: Adaptive optimizer combining momentum with per-parameter scaling by the running root-mean-square of gradients, plus bias correction. Deep Learning & Neural Networks
Adam: An optimizer that combines momentum (a running mean of gradients) with per-parameter step sizes from a running mean of squared gradients, plus bias correction. Math & Statistics for ML
AdamW: Adam with weight decay applied directly to weights instead of through the gradient. Deep Learning & Neural Networks
AdamW: Adam optimizer with decoupled weight decay; stores two moment estimates per trainable parameter. Fine-Tuning & Alignment
AdamW: Adam with weight decay applied directly to the weights rather than through the loss; the default for transformers. Math & Statistics for ML
Adapter: A small trainable module inserted into a frozen network; in the narrow sense, a bottleneck MLP added after attention or feed-forward blocks. Fine-Tuning & Alignment
Adaptive Battery: Android feature that predicts app usage to place apps in standby buckets. Power, Thermal & Battery
Adaptive bitrate: Streaming technique where the player switches video quality segment by segment based on bandwidth (HLS, DASH). System Design
Adaptive RAG: A system that decides per query whether to skip retrieval, retrieve once, or retrieve iteratively, based on estimated complexity. Retrieval-Augmented Generation (RAG)
ADC (asymmetric distance computation): PQ search where the query stays full precision and distances to compressed database vectors are summed from precomputed lookup tables. Retrieval-Augmented Generation (RAG)
Address space: The range of logical addresses a process may issue, translated by page tables to physical memory or to a fault. Operating System Concepts
Adjacency list: Graph storage mapping each vertex to the list of its neighbours; O(V + E) space. Data Structures & Algorithms
ADL: Argument-dependent lookup (Koenig lookup): unqualified functions are also searched in the namespaces of the argument types, which is how swap and operators are found. C++ Language
ADPF: Android Dynamic Performance Framework: APIs for performance hints and thermal awareness so apps can sustain steady workloads. Edge AI Fundamentals
ADPF: Android Dynamic Performance Framework: hint sessions (target versus actual work duration) and thermal headroom so apps and HWUI can hold a frame rate without over-boosting. Power, Thermal & Battery
ADR: Architecture decision record: a short document capturing the context, decision and consequences of a technical choice. Leadership, Delivery & Behavioral
ADSP / CDSP: Qualcomm Hexagon digital signal processors for audio and compute workloads; they run non-HLOS firmware. Platform Integration & Release
Adversarial example: An input deliberately perturbed to cause a model to make a mistake at inference time. LLM Evaluation, Safety & Responsible AI
Agent: An LLM wrapped with tools, memory, planning and a control loop so it can act on an environment and react to results. Agentic AI & Multi-Agent Systems
Agent: An LLM-driven loop that chooses and calls tools, observes the results and decides the next step towards a goal. GenAI System Design & Case Studies
Agent Card: A JSON document published by an A2A agent describing its skills, endpoint, supported formats and authentication. Agentic AI & Multi-Agent Systems
Agentic RAG: Retrieval-augmented generation where retrieval, routing and query rewriting are decisions made inside an agent loop rather than fixed pipeline stages. Agentic AI & Multi-Agent Systems
Agentic RAG: RAG in which an LLM plans, calls retrieval and other tools, inspects results and decides the next step in a loop. Retrieval-Augmented Generation (RAG)
Aging: Raising a waiting job's priority over time so a low-priority job cannot starve forever. Operating System Concepts
AI Hub: Qualcomm's hosted service to compile, quantize, profile and run models on real Snapdragon devices, with a model zoo of export scripts. Edge AI Deployment & Projects
AIDL: Android Interface Definition Language; defines Binder interfaces and generates marshalling code. Binder IPC & AIDL
AIDL NDK: C++ backend for AIDL that links libbinder_ndk; required for vendor and APEX HAL code. C++ Language
AIMET: Qualcomm's open-source toolkit for quantization and compression, including cross-layer equalisation, AdaRound, QuantAnalyzer and QAT. Edge AI Deployment & Projects
AKA: Authentication and Key Agreement; challenge-response using the secret key in the USIM/ISIM, which also authenticates the network. Android Telephony, RIL & Modem
AKA: Authentication and Key Agreement: SIM-based challenge-response that authenticates both sides and derives CK and IK. IMS, VoLTE & VoWiFi
AlarmManager: Android API for time-based triggers, inexact or exact, optionally waking the device. Power, Thermal & Battery
ALERTING: CC message (and call state) meaning the called party is being rung; the caller hears ringback. CS & IMS Call Flows
ALiBi: Attention with Linear Biases: adds a head-specific penalty proportional to token distance to attention scores instead of using position embeddings. Transformers & Large Language Models
alignas: Attribute that requests a minimum alignment for a variable, member or type. C++ Language
Alignment: Requirement that an object's address is a multiple of N (often the type's size). Misalignment can be slow or fault. C Language
Alignment: Post-training that shapes a model's behaviour towards human intentions and values, such as helpfulness, honesty and harmlessness. Fine-Tuning & Alignment
Alignment: Making model behaviour match human intentions and values: helpful, honest and harmless. LLM Evaluation, Safety & Responsible AI
Alignment: Post-training that makes a model's behaviour match human intent and values (helpful, honest, harmless), for example via RLHF or DPO. Transformers & Large Language Models
allocator_traits: Traits class that gives containers a uniform way to allocate, construct and destroy through any allocator. C++ Language
Alpha (LoRA): Scaling hyperparameter; the LoRA update is multiplied by α/r. Fine-Tuning & Alignment
Ambient mode: The always-on display state: dim, low-color, updated about once a minute, with the AP mostly asleep. Wear OS Platform
AMF: Access and Mobility Management Function; terminates NAS, handles registration, paging and mobility. 5G NR & 5G Core
AMF: Access and Mobility Function in the 5G core; terminates 5GMM. Android Data Call: Control, netd, eBPF & Packets
AMF / SMF / UPF: 5G core functions for mobility, session management and the user-plane gateway. Android Telephony, RIL & Modem
Amortized cost: Average cost per operation over a worst-case sequence of operations, even if single operations are occasionally expensive. Data Structures & Algorithms
AMR-WB: Adaptive Multi-Rate Wideband codec (50 to 7000 Hz), the baseline HD Voice codec for VoLTE. IMS, VoLTE & VoWiFi
AMS (ActivityManagerService): System service managing processes, services, broadcasts, providers, oom_adj scoring and several ANR types. Android Frameworks Internals
AMS / ATMS: ActivityManagerService and ActivityTaskManagerService; system services that manage processes, activities and tasks. Trace a Path Through the Android Stack
ANBR: Access Network Bitrate Recommendation: the RAN tells the UE a recommended codec bit rate when the GBR cannot be honoured. IMS, VoLTE & VoWiFi
Android.bp: Soong module definition file for userspace binaries, libraries, apps and interfaces. Platform Integration & Release
ANN (approximate nearest neighbour): Search algorithms that find most of the true nearest vectors far faster or with far less memory than exact search. Retrieval-Augmented Generation (RAG)
Anomaly detection: Finding rare observations that deviate from the normal pattern, often without labels. Machine Learning Fundamentals
ANR: Application Not Responding: raised when an app misses a deadline for input, a broadcast, a service or a provider. Android Frameworks Internals
ANR: Application Not Responding: the main thread was blocked too long; a stability KPI. Power, Thermal & Battery
ANR: Application Not Responding; raised when an app's main thread fails to handle input or a broadcast or service call in time. Trace a Path Through the Android Stack
Answer relevance: A generation metric measuring whether the answer addresses the question that was asked. Retrieval-Augmented Generation (RAG)
AOD: Always-on display; the user-visible name for ambient mode. Wear OS Platform
AON co-processor: Always-on low-power processor (MCU or DSP) that runs sensors, batching and display helpers while the AP sleeps. Wear OS Platform
AOP: Always-On Processor. A small Qualcomm core that manages power resources such as rails and clocks; its firmware is loaded by XBL. Android Boot Process
AOSP: Android Open Source Project; Google's open-source Android code base, published on android.googlesource.com. Platform Integration & Release
AOT: Ahead-of-time compilation to native code (dex2oat on Android, jaotc/Graal on some JVMs) before or during install, not only at first execution. Java Language
AP: Application processor: the CPU cluster running Android, as opposed to the modem. Android Telephony, RIL & Modem
AP: Application processor: the main Cortex-A cores that run Wear OS. Wear OS Platform
APE (Automatic Prompt Engineer): Method in which an LLM proposes candidate instructions from input-output examples, scores them on data and refines the best ones. Prompt Engineering
APEX: Container format for updatable system components (Mainline modules), mounted at boot. Android Frameworks Internals
API gateway: The entry point that handles authentication, tenant resolution, rate limits and quotas before requests reach the application. GenAI System Design & Case Studies
API gateway: Entry point that handles authentication, rate limiting, routing and other cross-cutting concerns for backend services. System Design
APN: Access Point Name; the LTE name of a packet data network. 5G name is DNN. Android Data Call: Control, netd, eBPF & Packets
APN: Access Point Name: identifies a packet data network such as ims or internet. IMS, VoLTE & VoWiFi
APN / DNN: Access Point Name (LTE) / Data Network Name (5G): names the gateway and service for a data connection. Android Telephony, RIL & Modem
ApnContext: Pre-Android 13 object tracking one APN type's desire for a DataConnection. Android Data Call: Control, netd, eBPF & Packets
App hibernation: Android 12+ state for unused apps: permissions revoked and cache cleared until the user opens the app again. Power, Thermal & Battery
App Standby bucket: Per-app category (active, working set, frequent, rare, restricted) that limits background jobs and alarms. Power, Thermal & Battery
ApplicationExitInfo: Per-package record of why a process died (reason, status, optional ANR/tombstone), from Android 11. Android Frameworks Internals
apply: pandas method that runs a Python function per element, row or group; flexible but slow compared with vectorized operations. Python & Data Tools for ML
Approval gate: A point in an agent's flow where execution pauses until a human approves, edits or rejects a proposed action. Agentic AI & Multi-Agent Systems
Arithmetic intensity: Operations performed per byte of memory traffic; decides compute-bound versus memory-bound behaviour. Edge AI Fundamentals
ARP: Allocation and Retention Priority; decides admission and pre-emption under congestion. 5G NR & 5G Core
ARP: Allocation and Retention Priority: decides bearer admission and pre-emption under congestion. IMS, VoLTE & VoWiFi
ARQ / HARQ: Automatic Repeat reQuest in RLC (reliable, slower) and Hybrid ARQ in MAC (fast, with soft combining). Android Telephony, RIL & Modem
ART: Android Runtime: the VM that executes dex-derived code, with its own GC (Concurrent Copying on modern releases), JIT and profile-guided AOT. Java Language
ASan: AddressSanitizer: compiler instrumentation plus shadow memory that catches out-of-bounds and use-after-free. C Language
ashmem / memfd: Anonymous shared memory regions shared between processes by passing a file descriptor. Binder IPC & AIDL
ASID: Address Space Identifier: tag on TLB entries so translations from different processes can coexist. Linux Kernel & BSP
asInterface(): Generated static method that returns a local implementation or wraps a remote IBinder in a Proxy. Binder IPC & AIDL
Aspect-based sentiment analysis (ABSA): Sentiment measured per aspect of a product or service (delivery, quality, price) rather than for the text as a whole. GenAI System Design & Case Studies
Aspect-based sentiment analysis (ABSA): Extracting which aspect of a product or service is discussed and the sentiment toward that aspect, rather than one label per document. NLP Fundamentals
Assertion detection: Clinical NLP task that marks whether a mention is negated, uncertain, historical or about someone other than the patient. GenAI System Design & Case Studies
Asset: Binary blob attached to a DataItem in the Data Layer, used for data too large for the DataItem itself. Wear OS Platform
Assistant message: A message with role assistant containing earlier model output, a hand-written example reply, or tool-call requests. LLM APIs, Structured Outputs & Tool Calling
asyncio: Python's standard library for single-threaded concurrency using async/await, ideal for many simultaneous network calls. Python & Data Tools for ML
AT commands: Text modem commands standardized in 3GPP TS 27.007 and 27.005. Android Telephony, RIL & Modem
ATCF / ATGW: Access Transfer Control Function and Gateway: local anchors for signaling and media used by eSRVCC. IMS, VoLTE & VoWiFi
ATMS (ActivityTaskManagerService): Service managing activities, tasks and the back stack; split from AMS in Android 10. Android Frameworks Internals
Attack success rate (ASR): Fraction of adversarial attempts that achieve the attacker's goal; the main red-teaming metric. LLM Evaluation, Safety & Responsible AI
Attention: A mechanism that computes a weighted average of values, with weights from query-key similarity, letting a model focus on relevant positions. Deep Learning & Neural Networks
Attention: A mechanism that computes a weighted average of value vectors, with weights from query–key similarity, letting a model focus on relevant tokens. NLP Fundamentals
Attention: A mechanism that computes a weighted average of value vectors, with weights from query-key similarity. Transformers & Large Language Models
Attention mask: A 0/1 array telling the model which positions are real tokens and which are padding (or, in causal models, which future positions are hidden). NLP Fundamentals
Attention sink: The first few tokens of a sequence, which attract a large share of attention; keeping them in a sliding-window cache keeps long generations stable. Edge AI Deployment & Projects
Attention sink: Initial tokens that receive disproportionate attention; keeping them in the cache stabilises streaming generation. Transformers & Large Language Models
AUC (ROC-AUC): Area under the ROC curve; the probability a random positive is scored above a random negative. Machine Learning Fundamentals
AudioFlinger: The mixer and track server in audioserver that sits between app tracks and the Audio HAL. Trace a Path Through the Android Stack
Audit log: A tamper-evident record of who requested what, which data was used, which model answered and which actions were taken. GenAI System Design & Case Studies
AUSF: Authentication Server Function in the home network. 5G NR & 5G Core
Auto-CoT: Automatic chain-of-thought: cluster questions, pick a representative from each cluster, and generate reasoning demonstrations with zero-shot CoT. Prompt Engineering
auto_ptr: Deprecated C++98 smart pointer that transferred ownership on copy; removed in C++17 in favor of unique_ptr. C++ Language
Autoencoder: Network trained to reconstruct its input through a low-dimensional bottleneck. Deep Learning & Neural Networks
Autograd: Automatic differentiation: the framework records operations and computes gradients via the chain rule. Deep Learning & Neural Networks
Autograd: PyTorch's automatic differentiation engine, which records operations and computes gradients with the chain rule on backward(). Python & Data Tools for ML
Autoregressive: Generating one token at a time, each conditioned on all previously generated tokens. Transformers & Large Language Models
Autosleep: Kernel mode in which the system suspends automatically whenever no wakeup source is active. Power, Thermal & Battery
AUTS: Resynchronisation token the USIM returns on AKA sync failure so the HSS can realign SQN. Android Telephony, RIL & Modem
Availability: Fraction of time a system serves requests successfully, often expressed in nines. System Design
AVB: Android Verified Boot 2.0. The system that verifies vbmeta, boot images and partition hash trees before and during boot. Android Boot Process
AVB: Android Verified Boot: verifies boot images via signed vbmeta; dm-verity checks read-only partitions at runtime. Linux Kernel & BSP
AVB: Android Verified Boot; checks signed vbmeta so that only trusted images boot. Trace a Path Through the Android Stack
Average precision (PR-AUC): Summary of the precision–recall curve; its random baseline equals the positive rate. Machine Learning Fundamentals
AWQ: Activation-aware weight quantization: a PTQ method that protects the weight channels most important to activations by scaling before quantizing. Edge AI Deployment & Projects
AWQ: Activation-aware Weight Quantization: a PTQ method that scales up the most important weight channels (found from activation magnitudes) before low-bit quantization. Edge AI Fundamentals
Axis: A dimension of an array; the axis argument names the dimension an aggregation collapses. Python & Data Tools for ML

B

Backdoor: Hidden behaviour implanted during training that activates only when a specific trigger appears in the input. LLM Evaluation, Safety & Responsible AI
Backdoor attack: A hidden trigger planted through poisoned training, fine-tuning or demonstration data that makes the model misbehave only when the trigger appears. Prompt Engineering
Backpressure: Signalling producers to slow down when consumers cannot keep up. System Design
Backpropagation: Algorithm that computes the gradient of the loss with respect to every parameter by applying the chain rule from output to input. Deep Learning & Neural Networks
Backpropagation: Computing gradients of the loss for all parameters by applying the chain rule backwards through the computation graph. Math & Statistics for ML
Backpropagation through time (BPTT): Training an RNN by unrolling it over time steps and backpropagating through every step. NLP Fundamentals
Backtest: Running a candidate rule or strategy against historical data to estimate its precision, recall and impact before deployment. GenAI System Design & Case Studies
Backtracking: Depth-first search over choices that undoes each choice after exploring it, pruning branches that cannot succeed. Data Structures & Algorithms
BadTokenException: WMS rejected addView because the window token is null, finished, or not an Activity/system token. Android Frameworks Internals
Bag-of-words (BoW): A document vector of word counts or presence flags that ignores word order. NLP Fundamentals
Bagging: Training models on bootstrap samples and averaging them to reduce variance. Machine Learning Fundamentals
Balanced BST: A binary search tree (AVL, red-black) that rebalances itself to keep height O(log n). Data Structures & Algorithms
Banker's algorithm: Deadlock-avoidance check: grant a request only if a safe sequence still exists, given each process's declared maximum claim. Operating System Concepts
Barge-in: A user interrupting a voice assistant while it speaks. The system must stop speech output and listen. GenAI System Design & Case Studies
BASE: Basically available, soft state, eventual consistency: the looser guarantees of many NoSQL systems. System Design
Base model: A pretrained model before instruction tuning or alignment; it continues text rather than following instructions. Fine-Tuning & Alignment
Base model: A model after pretraining only; it continues text rather than following instructions. Transformers & Large Language Models
Baseline: A promoted, tested snapshot of the platform for a chipset that downstream teams and customers build on. Platform Integration & Release
Batch API: An asynchronous, discounted way to submit many model requests that complete within hours. GenAI System Design & Case Studies
Batch API: An endpoint that accepts a file of many requests, processes them asynchronously within a time window, and usually charges less. LLM APIs, Structured Outputs & Tool Calling
Batch normalization: Normalizes each channel using mini-batch statistics, then applies learned scale and shift; uses running statistics at inference. Deep Learning & Neural Networks
Batch size: Number of examples processed before one parameter update. Deep Learning & Neural Networks
Batching: Buffering sensor samples in a hardware FIFO and delivering them in bursts so the AP can stay asleep. Wear OS Platform
Battery Historian: Open-source tool that visualizes batterystats from a bugreport as a timeline. Power, Thermal & Battery
batterystats: Android's battery accounting service; dumpsys batterystats reports estimated energy use per app over a measurement window. Edge AI Deployment & Projects
batterystats: Framework service and dumpsys output that attributes battery use to apps and components. Power, Thermal & Battery
Bayes' theorem: P(A | B) = P(B | A)P(A)/P(B): how to update a prior belief into a posterior after seeing evidence. Math & Statistics for ML
BC_* / BR_*: Binder protocol commands sent to the driver (BC) and returns from the driver (BR). Binder IPC & AIDL
Beam failure recovery: Fast procedure where the UE switches to a new beam through RACH instead of declaring radio link failure. 5G NR & 5G Core
Beam search: A deterministic decoding method that keeps the k most probable partial sequences at each step; rarely exposed by chat APIs. LLM APIs, Structured Outputs & Tool Calling
Beam search: A decoding strategy that keeps the B most probable partial outputs at each step instead of only the single best. NLP Fundamentals
Beam search: Deterministic decoding that keeps the B most probable partial sequences at every step. Transformers & Large Language Models
Belady's anomaly: For some reference strings, FIFO page replacement faults more when given more frames. Stack algorithms such as LRU do not. Operating System Concepts
Benchmark: A fixed public dataset plus scoring rule used to compare model capabilities. LLM Evaluation, Safety & Responsible AI
BERTScore: Similarity metric that greedily matches contextual token embeddings of candidate and reference by cosine similarity. LLM Evaluation, Safety & Responsible AI
BERTScore: A generation metric that matches candidate and reference tokens by cosine similarity of contextual embeddings and reports precision, recall and F1. NLP Fundamentals
Bessel's correction: Dividing by n − 1 instead of n to get an unbiased sample variance. Math & Statistics for ML
BF16: 16-bit floating-point format with FP32's exponent range and reduced precision; preferred for mixed-precision training. Deep Learning & Neural Networks
BF16: Brain float 16: 16-bit floating point with the same exponent range as FP32 but fewer mantissa bits; robust to overflow. Edge AI Deployment & Projects
BF16: bfloat16: a 16-bit float with FP32's 8-bit exponent and a 7-bit mantissa; wide range, low precision. Edge AI Fundamentals
BFS: Breadth-first search; explores a graph level by level using a queue. Data Structures & Algorithms
BGCF: Breakout Gateway Control Function: chooses where a call leaves IMS towards the PSTN. IMS, VoLTE & VoWiFi
Bi-encoder: A model that embeds query and document independently so documents can be pre-indexed for fast similarity search. NLP Fundamentals
Bi-encoder: An architecture that encodes query and document separately into vectors compared by a similarity function; used for first-stage retrieval. Retrieval-Augmented Generation (RAG)
Bias (of an estimator): The difference between an estimator's expected value and the true parameter. Math & Statistics for ML
Bias (parameter): Learnable offset added to a neuron's weighted sum, shifting its activation threshold. Deep Learning & Neural Networks
Bias (statistical): Error from overly simple or wrong assumptions; systematic deviation from the truth. Machine Learning Fundamentals
Bias–variance trade-off: Increasing flexibility lowers bias but raises variance; the best model balances both. Machine Learning Fundamentals
Bidirectional RNN: Two RNNs reading a sequence in opposite directions, with states concatenated per position. Deep Learning & Neural Networks
Big-O: Asymptotic upper bound on how cost grows with input size, ignoring constants. Data Structures & Algorithms
big.LITTLE: ARM design mixing energy-efficient and high-performance CPU cores in one SoC. Linux Kernel & BSP
Binary heap: Complete binary tree in an array where each parent is no larger (min-heap) or no smaller (max-heap) than its children. Data Structures & Algorithms
Binary search on the answer: Binary search over possible answer values using a monotonic feasibility check. Data Structures & Algorithms
Binary semaphore: A semaphore whose count is only 0 or 1. Can signal an event or mimic a mutex, but has no owner. Operating System Concepts
Binder: Android's kernel-mediated, object-oriented IPC and RPC mechanism. Binder IPC & AIDL
Binder: Android's kernel-backed RPC/IPC mechanism with one-copy transfer and caller identity. Linux Kernel & BSP
Binder: Android's kernel-assisted IPC mechanism with single-copy transfer, caller identity and reference-counted objects. Trace a Path Through the Android Stack
Binder thread pool: Threads in each process that execute incoming Binder calls; default maximum 15 plus the main Binder thread. Android Frameworks Internals
Binder thread pool: Threads in a process that execute incoming Binder transactions. Binder IPC & AIDL
BINDER_WRITE_READ: The main Binder ioctl; sends commands and receives work in one system call. Binder IPC & AIDL
binderfs: Filesystem that provides Binder device nodes and debug logs on newer kernels. Binder IPC & AIDL
BinderProxy: Java object representing a remote Binder handle in the client process. Binder IPC & AIDL
BIO tagging: A labelling scheme for spans: B- begins an entity, I- continues it, O is outside any entity. NLP Fundamentals
bionic: Android's C library and dynamic linker, smaller than glibc and with extras such as fdsan. C Language
Bitfield: A struct member occupying a specified number of bits; layout is implementation-defined. C Language
bitsandbytes: Library of 8-bit and 4-bit quantized layers and memory-efficient optimizers used by QLoRA. Fine-Tuning & Alignment
Blameless post-mortem: A review after an incident that focuses on systems and process causes rather than individual blame. Leadership, Delivery & Behavioral
BLASTBufferQueue: Android 10+ buffer path for most app surfaces: still producer-consumer buffers, with a cheaper SurfaceFlinger transaction than classic BufferQueue-only setup. Trace a Path Through the Android Stack
BLEU: Precision-oriented n-gram overlap metric with a brevity penalty, designed for machine translation. LLM Evaluation, Safety & Responsible AI
BLEU: A translation metric based on clipped n-gram precision (n = 1–4) combined geometrically and multiplied by a brevity penalty. NLP Fundamentals
Block (microscaling) format: A format in which a small block of values shares one scale, such as MXFP4, NVFP4 or GGUF blocks. Edge AI Fundamentals
Block table: The mapping from a sequence's logical KV-token ranges to physical KV blocks in a paged cache, analogous to a page table. Edge AI Deployment & Projects
Block table: The mapping from a sequence's logical KV-token ranges to physical KV blocks in paged attention, analogous to a page table. GenAI System Design & Case Studies
Bloom filter: Compact probabilistic set that can say "definitely not present" or "probably present". System Design
Blue team: Defenders who build, harden and monitor systems and respond to incidents. LLM Evaluation, Safety & Responsible AI
BM25: A lexical ranking function extending TF-IDF with term-frequency saturation and document-length normalization. NLP Fundamentals
BM25: A lexical ranking function combining inverse document frequency, saturating term frequency and document-length normalisation. Retrieval-Augmented Generation (RAG)
BODY_SENSORS_BACKGROUND: Runtime permission (API 33+) required to read body sensors such as heart rate while the app is not in the foreground. Wear OS Platform
Boot control HAL: The IBootControl interface used by update_engine and bootctl to read and set slot attributes. Android Boot Process
bootconfig: Android 12+ mechanism for passing androidboot.* parameters from the bootloader to the kernel, separate from the kernel command line. Android Boot Process
Bootstrap: Resampling with replacement to estimate the sampling distribution of a statistic; not a substitute for cross-validation of a training procedure. Machine Learning Fundamentals
Bootstrap: Estimating the variability of a statistic by recomputing it on many resamples drawn with replacement. Math & Statistics for ML
Bounded waiting: A bound on how many times other threads may enter the critical section after you have requested entry. Operating System Concepts
BPE (Byte-Pair Encoding): Tokenizer training method that repeatedly merges the most frequent adjacent symbol pair into a new token. Transformers & Large Language Models
bpfloader: Init service that loads Android's pinned eBPF programs and maps. Confirm paths on the build. Android Data Call: Control, netd, eBPF & Packets
BPTT: Backpropagation through time: backprop on an RNN unrolled over the sequence. Deep Learning & Neural Networks
BR_FROZEN_REPLY: Driver return to a sync caller when the target process is frozen; the target is not unfrozen. Binder IPC & AIDL
Bradley-Terry model: Statistical model converting pairwise win/loss outcomes into strength scores; used by arena leaderboards. LLM Evaluation, Safety & Responsible AI
Bradley–Terry model: Probability model for pairwise preferences: P(A preferred over B) = σ(r_A − r_B). Fine-Tuning & Alignment
Brevity penalty: BLEU factor that reduces the score when the candidate is shorter than the reference. LLM Evaluation, Safety & Responsible AI
Brier score: Mean squared error of predicted probabilities versus 0/1 labels; a proper scoring rule, lower is better. Machine Learning Fundamentals
Broadcasting: Rules that let array operations combine different shapes by virtually stretching size-1 dimensions. Math & Statistics for ML
Broadcasting: NumPy and PyTorch rules for combining arrays of different shapes by virtually stretching size-1 dimensions. Python & Data Tools for ML
BSP: Board Support Package: bootloader, device tree, config and drivers for a specific board. Linux Kernel & BSP
BSP: Board Support Package; kernel, device tree, drivers and low-level software for a specific SoC and board. Platform Integration & Release
BSS: Segment for zero-initialised (or uninitialised) static-duration objects; the file stores a size, not the zeros. C Language
Buddy allocator: Kernel page allocator that splits and merges power-of-two blocks of physical pages. Linux Kernel & BSP
Buffer: Explicit schedule slack placed at the end of a chain of work to absorb uncertainty. Leadership, Delivery & Behavioral
BufferQueue: A shared pool of graphic buffers connecting a producer (app) to a consumer (SurfaceFlinger). Trace a Path Through the Android Stack
Bulkhead: Isolating resources (thread or connection pools) per dependency so one failure cannot exhaust all of them. System Design
Burn-in protection: Shifting pixels and avoiding large bright areas in ambient mode to prevent OLED image retention. Wear OS Platform
BWP: Bandwidth Part; a sub-band of the carrier with its own numerology on which the UE operates. 5G NR & 5G Core
Byte-Pair Encoding (BPE): A subword tokenizer that learns a vocabulary by repeatedly merging the most frequent adjacent symbol pair. NLP Fundamentals
Bytecode: The stack-machine instructions in a class file (or the register-machine instructions in dex). Not CPU machine code until a JIT or AOT compiler emits it. Java Language

C

C-MSISDN: Correlation MSISDN used by the SCC-AS to match the SRVCC transfer to the existing session. IMS, VoLTE & VoWiFi
Cache-aside: Caching strategy where the application reads the cache and, on a miss, loads from the database and fills the cache. System Design
Cadence: The regular operating rhythm of a team: sprints, triage, reviews and status updates. Leadership, Delivery & Behavioral
Calibration: How well predicted probabilities match observed frequencies of being correct. Deep Learning & Neural Networks
Calibration: Agreement between predicted probabilities and observed frequencies. Machine Learning Fundamentals
Calibration: Adjusting a confidence score so that a predicted probability of p matches an empirical accuracy near p, usually with a labelled reliability plot. Prompt Engineering
Calibration dataset: A small, representative set of inputs run through a model to record activation ranges for static quantization. Edge AI Deployment & Projects
Calibration set: A small set of representative inputs used during PTQ to measure activation ranges. Edge AI Fundamentals
CallFailCause: Telephony class holding modem / 3GPP 24.008 call failure codes returned by getLastCallFailCause(). CS & IMS Call Flows
calloc: Heap allocation that zeros memory; the element-count times size product can overflow. C Language
CallsManager: The core of Telecom in system_server; creates and tracks every Call, arbitrates between calls and accounts. CS & IMS Call Flows
Camera HAL3: Request/result camera HAL: each frame is a request with streams and settings, plus a result with metadata and buffers. Trace a Path Through the Android Stack
Canary release: Rolling a change out to a small share of traffic first and monitoring it before a full rollout. GenAI System Design & Case Studies
Canary release: Routing a small share of traffic to a new version to detect problems before full rollout. LLM Evaluation, Safety & Responsible AI
Canary token: A unique secret string placed in a prompt or dataset to detect leakage or contamination. LLM Evaluation, Safety & Responsible AI
CAP theorem: During a network partition a distributed system must choose between consistency and availability. System Design
Capability: A token that is a right (an open file descriptor, a handle). Holding it authorises the operation; the object does not look up your name. Operating System Concepts
CapabilityClient: Data Layer API to advertise and discover which connected node offers a feature. Wear OS Platform
Captive portal: Network that intercepts HTTP(S) until a sign-in; validation marks CAPTIVE_PORTAL instead of a clean VALIDATED. Android Data Call: Control, netd, eBPF & Packets
Carrier ID: Android's canonical identifier for a carrier, resolved from SIM attributes by CarrierResolver. Android Telephony, RIL & Modem
Carrier privileges: UICC-granted rights for an app whose signing certificate is listed in the SIM access-rule applet; checked with hasCarrierPrivileges(). Android Telephony, RIL & Modem
CarrierConfig: Per-subscription bundle of carrier-specific settings exposed by CarrierConfigManager. Android Telephony, RIL & Modem
CarrierConfig: Per-carrier Android configuration (feature flags and values) keyed by MCC/MNC or a carrier app. Platform Integration & Release
CAS: Compare-and-swap: an atomic hardware update used by java.util.concurrent.atomic and ConcurrentHashMap. Java Language
Cascade: A chain of models of increasing cost where each stage runs only if the previous one fires or is unsure. Edge AI Fundamentals
Cascade: A routing pattern that tries a cheap model first and escalates to a stronger one when confidence checks fail. GenAI System Design & Case Studies
Catastrophic forgetting: Loss of previously learned abilities when a network is trained on new data. Fine-Tuning & Alignment
CatBoost: Gradient-boosting library with ordered target statistics for categorical features and symmetric trees. Machine Learning Fundamentals
Categorical dtype: pandas type storing each distinct value once plus integer codes per row, saving memory for repetitive values. Python & Data Tools for ML
Causal language modelling (CLM): Pretraining objective of predicting each next token from the tokens before it. Transformers & Large Language Models
Causal mask: Lower-triangular attention mask that prevents a position from attending to future positions. Transformers & Large Language Models
CBOW: Continuous bag of words: word2vec variant that predicts a centre word from its context words. Deep Learning & Neural Networks
CBOW: Continuous bag of words: the word2vec variant that predicts a center word from its averaged context words. NLP Fundamentals
CC (Call Control): 3GPP TS 24.008 protocol for CS calls: SETUP, CALL PROCEEDING, ALERTING, CONNECT, DISCONNECT, RELEASE. CS & IMS Call Flows
CCB: Change Control Board; group that approves changes after code freeze. Platform Integration & Release
CCCI: Cross Core Communication Interface: MediaTek's kernel framework for AP to modem channels. Android Telephony, RIL & Modem
CCMNI: MediaTek cellular netdev family (ccmniN), one interface per data call. Android Data Call: Control, netd, eBPF & Packets
ccmni: MediaTek cellular network interfaces carrying user-plane IP traffic. Android Telephony, RIL & Modem
CDD: Compatibility Definition Document; the written requirements an Android-compatible device must meet. Platform Integration & Release
CDN: Content delivery network: edge servers that cache content close to users. System Design
Cell state: The LSTM's long-term memory vector, updated additively under gate control. Deep Learning & Neural Networks
Central limit theorem: The distribution of a sample mean approaches a normal distribution with standard deviation σ/√n as n grows. Math & Statistics for ML
CFS: Completely Fair Scheduler: vruntime-based fair scheduler for normal tasks (replaced by EEVDF in 6.6). Linux Kernel & BSP
CFS: Completely Fair Scheduler: Linux's fair class. Tasks are scheduled by virtual runtime so each gets a fair CPU share. Mention only; internals are on the kernel page. Operating System Concepts
cgroup: Linux control group: a resource limit and accounting on a set of tasks (CPU, memory, I/O). A container building block. Operating System Concepts
cgroup skb: eBPF hook on packets associated with a cgroup; Android's UID firewall and accounting attach here. Android Data Call: Control, netd, eBPF & Packets
Chain of trust: A sequence where each boot stage verifies the next before running it, anchored in an immutable hardware root. Android Boot Process
Chain rule: The derivative of a composition is the product of the derivatives of its parts. Math & Statistics for ML
Chain-of-thought: Intermediate reasoning steps written before the final answer, prompted or trained. Transformers & Large Language Models
Chain-of-thought (CoT): Prompting a model to write intermediate reasoning steps before its answer; closed-book, so factual errors can compound. Agentic AI & Multi-Agent Systems
Chain-of-thought (CoT): Prompting the model to write intermediate reasoning steps before the final answer, improving multi-step problem solving. Prompt Engineering
Chain-of-verification (CoVe): Draft an answer, plan verification questions, answer them independently, then revise the answer to match verified facts. Prompt Engineering
Change data capture: Streaming a database's committed changes (from its log) to other systems. System Design
ChannelClient: Data Layer API for streaming or file transfer between two nodes. Wear OS Platform
Chat template: The exact special-token layout a chat model uses to mark system, user, assistant and tool turns. Fine-Tuning & Alignment
Chat template: The model-specific format, with special tokens, that turns a list of role-tagged messages into one token sequence. LLM APIs, Structured Outputs & Tool Calling
Chat template: The model-specific format with special tokens that turns a list of role-tagged messages into one token sequence. Prompt Engineering
Checked exception: An Exception that is not a RuntimeException; the compiler requires throws or a catch. Java Language
Checkpointer: A component that saves graph state after each step to a store, keyed by thread id, enabling pause, resume and recovery. Agentic AI & Multi-Agent Systems
Cherry-pick: Applying a single commit from one branch onto another. Platform Integration & Release
Chinchilla scaling: Finding that compute-optimal training uses roughly 20 tokens per parameter, scaling model and data together. Transformers & Large Language Models
Choreographer: Per-thread coordinator that runs input, animation and drawing callbacks once per vsync. Android Frameworks Internals
Choreographer: Framework class that schedules input, animation and drawing work on vsync. Trace a Path Through the Android Stack
CHRE: Context Hub Runtime Environment: runs small nanoapps on the low-power sensor hub. Power, Thermal & Battery
Chunk: A contiguous slice of a document stored and retrieved as one unit, with its own embedding and metadata. Retrieval-Augmented Generation (RAG)
Chunk overlap: Tokens shared between adjacent chunks so facts at boundaries appear intact in at least one chunk. Retrieval-Augmented Generation (RAG)
Chunking: Splitting documents into retrievable pieces, ideally along structural boundaries, with sizes tuned for retrieval quality. GenAI System Design & Case Studies
CIA triad: Confidentiality, integrity and availability: the classic goals of information security. LLM Evaluation, Safety & Responsible AI
CID: Connection id assigned by the modem for a data call; argument to deactivate and list queries. Android Data Call: Control, netd, eBPF & Packets
Circuit breaker: A mechanism that stops calling a repeatedly failing dependency for a cooldown period instead of retrying endlessly. Agentic AI & Multi-Agent Systems
Circuit breaker: A mechanism that stops calling a failing dependency for a period and routes to a fallback instead. GenAI System Design & Case Studies
Circuit breaker: A resilience pattern that stops calling a failing dependency for a cool-down period and serves a fallback instead. LLM APIs, Structured Outputs & Tool Calling
Circuit breaker: Pattern that stops calling a failing dependency for a while and fails fast, then probes for recovery. System Design
Circular wait: Coffman condition: a cycle of processes, each waiting for a resource the next one holds. Operating System Concepts
Citation: A reference from an answer sentence to the source chunk, document and page that supports it. Retrieval-Augmented Generation (RAG)
Class file: The binary javac emits: header, constant pool, fields, methods and bytecode. Java Language
Classloader: The object that locates bytes and defines a Class. Identity of a class includes its defining loader. Java Language
CLAT: Customer-side translator: IPv4 (typically 192.0.0.0/29) to IPv6 toward a NAT64 prefix. Android Data Call: Control, netd, eBPF & Packets
CLAT / 464XLAT: Customer-side translator that lets IPv4-only apps work on IPv6-only cellular: the phone NATs IPv4 sockets onto IPv6 toward the network. Trace a Path Through the Android Stack
Cleaner: A post-mortem cleanup facility built on phantom reachability; the replacement for finalize. Java Language
CLIP: A model that learns a shared image-text embedding space with a contrastive loss, enabling zero-shot image classification. Transformers & Large Language Models
Clock algorithm: Page replacement that walks a circular list and gives a second chance to pages with the referenced bit set. Practical LRU. Operating System Concepts
Closure: A function that remembers variables from the scope in which it was defined. Python & Data Tools for ML
CMA: Contiguous Memory Allocator: reserved region lent to movable pages and reclaimed for large contiguous DMA buffers. Linux Kernel & BSP
CMR: Codec Mode Request: an in-band AMR/EVS signal asking the sender to change bit-rate mode. IMS, VoLTE & VoWiFi
Code freeze: Milestone after which only approved fixes may enter a release branch. Platform Integration & Release
Code-mixing: Mixing two or more languages within one sentence or conversation, often in a non-native script. GenAI System Design & Case Studies
Code-mixing: Switching between two or more languages within a sentence or conversation, often in a single script (for example Romanized Hindi with English). NLP Fundamentals
CodeAct: An approach where the agent's actions are small programs that call tools, executed in a sandbox, instead of JSON tool calls. Agentic AI & Multi-Agent Systems
Coffman conditions: The four necessary conditions for deadlock: mutual exclusion, hold and wait, no preemption, circular wait. Operating System Concepts
Cohen's kappa: Chance-corrected agreement between two raters: κ = (p_o − p_e)/(1 − p_e), with p_e from the product of each rater's label frequencies. LLM Evaluation, Safety & Responsible AI
ColBERT: A late-interaction retriever that stores one vector per token and scores with MaxSim. Retrieval-Augmented Generation (RAG)
Cold / warm / hot start: App starts that need a new process, a new activity in an existing process, or only a resume, respectively. Android Frameworks Internals
Cold start: Launching an app when no process exists, so it must be forked from Zygote and fully initialised. Trace a Path Through the Android Stack
Collaborative filtering: Recommending based on patterns of similar users or items in interaction data. Machine Learning Fundamentals
Collision: Two different keys hashing to the same bucket; resolved by chaining or open addressing. Data Structures & Algorithms
ColumnTransformer: scikit-learn tool that applies different transformers to different column subsets and concatenates the results. Python & Data Tools for ML
Compaction: Sliding allocated memory together to coalesce free holes. Needs relocatable addresses; paging mostly makes it unnecessary for process placement. Operating System Concepts
Companion app: Phone app that pairs, sets up and manages the watch and bridges notifications. Wear OS Platform
CompiledModel: LiteRT Next's compiled-model API that binds a .tflite (or a vendor-compiled artifact) to an accelerator. Class names and options are release-specific; confirm in current LiteRT docs. Edge AI Deployment & Projects
Completion: One-shot kernel signal: one side wait_for_completion, the other complete. Linux Kernel & BSP
Completion-only loss: Computing the training loss only on response tokens, masking prompt tokens. Fine-Tuning & Alignment
Complication: Small data slot on a watch face, fed by a complication data source. Wear OS Platform
Compounding error: The effect whereby small per-step failure rates multiply over long tasks, so success falls roughly as p to the power n. Agentic AI & Multi-Agent Systems
Compressed oops: HotSpot packing of heap references into 32 bits when the heap is within a limited range (typically under ~32 GB). Java Language
concept: C++20 named set of requirements on a template argument; failed concepts drop or rank overloads with readable errors. C++ Language
Concept drift: Change in the relationship between inputs and the target over time. Machine Learning Fundamentals
Concurrent Copying (CC): ART's moving collector: bump allocation, concurrent mark and copy, short STW root pauses. Java Language
ConcurrentHashMap: A thread-safe hash map using CAS and per-bin coordination; null keys and values are forbidden. Java Language
Condition: A wait-set attached to a Lock, analogue of wait/notify with multiple named queues. Java Language
Condition number: Ratio of the largest to smallest singular value (or curvature); high values mean numerical instability and slow gradient descent. Math & Statistics for ML
Condition variable: A wait queue used with a mutex: wait atomically drops the mutex and sleeps; signal wakes a waiter who must re-check the predicate. Operating System Concepts
Conditional edge: A routing function in a graph that inspects state and returns which node should run next. Agentic AI & Multi-Agent Systems
Conditional probability: P(A | B) = P(A ∩ B)/P(B): the probability of A within the world where B happened. Math & Statistics for ML
Conditional random field (CRF): A probabilistic sequence model that scores whole tag sequences, enforcing valid transitions; often placed on top of BiLSTMs for NER. NLP Fundamentals
Confidence interval: A range built by a procedure that captures the true parameter in a stated fraction (e.g. 95%) of repeated samples. Math & Statistics for ML
Confused deputy: A security flaw where a privileged component (the agent) is tricked into using its authority on behalf of someone who lacks it. Agentic AI & Multi-Agent Systems
Confusion matrix: Table of actual versus predicted classes showing TP, FP, FN and TN counts. Machine Learning Fundamentals
Conjugate prior: A prior that yields a posterior in the same family, e.g. Beta for a binomial rate. Math & Statistics for ML
CONNECT: CC message meaning the call was answered; the receiver replies CONNECT ACKNOWLEDGE. CS & IMS Call Flows
ConnectionService: android.telecom service a calling stack implements so Telecom can create and control its calls; Telephony's is TelephonyConnectionService. CS & IMS Call Flows
ConnectivityService: system_server owner of Networks, requests, scoring, validation and binding. Android Data Call: Control, netd, eBPF & Packets
Consensus: Protocol (Raft, Paxos) for a group of nodes to agree on a value or leader despite failures. System Design
Consistent hashing: Mapping keys and nodes onto a ring so adding or removing a node moves only a small fraction of keys. System Design
const: Type qualifier meaning the object will not be modified through this lvalue. Casting it away and writing can be UB. C Language
Constant pool: The class-file table of literals and symbolic references that bytecode indexes. Java Language
consteval: C++20: the function must be evaluated at compile time (immediate function). C++ Language
constexpr: May be evaluated at compile time when arguments allow; the same function can still run at runtime. C++ Language
constinit: C++20: this variable must have static initialization, avoiding the dynamic initialization order fiasco. C++ Language
Constitutional AI: Alignment approach in which a model critiques and revises outputs, and an AI judge ranks them, according to a written set of principles. Fine-Tuning & Alignment
Constitutional AI: Alignment method using written principles for model self-critique and AI-generated preference feedback. LLM Evaluation, Safety & Responsible AI
Constrained decoding: Restricting generated tokens so the output must match a grammar, regular expression or JSON schema. GenAI System Design & Case Studies
Constrained decoding: Restricting which tokens may be generated at each step so the output must satisfy a regex, grammar or JSON Schema. LLM APIs, Structured Outputs & Tool Calling
Constrained decoding: Restricting which tokens can be generated (for example to match a JSON Schema or grammar) so output is valid by construction. Prompt Engineering
Contamination: Presence of benchmark or test data in a model's training data, inflating scores. LLM Evaluation, Safety & Responsible AI
Context binary: A serialized, fully compiled QNN graph for a specific Hexagon architecture that loads without on-device graph compilation. Edge AI Deployment & Projects
Context engineering: Deliberately deciding what information enters the model's context at each step: instructions, tools, memories, retrieved data and history. Agentic AI & Multi-Agent Systems
Context engineering: Designing the full conditioning window for a call: instructions plus retrieval, memory, tool results, ordering, token budget and trust boundaries. Prompt Engineering
Context manager: The process reachable at handle 0 in a Binder domain (servicemanager on /dev/binder). Binder IPC & AIDL
Context manager: Object used with with that sets something up in __enter__ and guarantees cleanup in __exit__. Python & Data Tools for ML
Context precision: A metric for how many retrieved chunks are relevant, weighted towards those ranked highest. Retrieval-Augmented Generation (RAG)
Context recall: A metric for how much of the information needed for the reference answer is present in the retrieved context. Retrieval-Augmented Generation (RAG)
Context switch: Saving one task's CPU state and restoring another's, possibly switching page tables. Linux Kernel & BSP
Context switch: Saving one thread's CPU state and loading another's. Process switches also switch address spaces and disturb the TLB and caches. Operating System Concepts
Context window: The maximum number of tokens, input plus output, a model can process in a single call. LLM APIs, Structured Outputs & Tool Calling
Context window: The maximum number of tokens (prompt plus output) a model can process in one request. Prompt Engineering
Context window: Maximum number of tokens (input plus output) a model can attend to in one pass. Transformers & Large Language Models
Contextual embedding: A token vector computed from the whole sentence, so the same word gets different vectors in different contexts. NLP Fundamentals
Continued pretraining: Further next-token training on large unlabelled domain text; also called domain-adaptive pretraining. Fine-Tuning & Alignment
Continuous batching: A serving technique that adds and removes sequences from the running batch at every decode step to keep the GPU busy. GenAI System Design & Case Studies
Continuous batching: A serving technique that adds and removes sequences from the GPU batch at every decoding step, maximizing throughput. LLM APIs, Structured Outputs & Tool Calling
Continuous batching: Serving technique that adds and removes requests from a running batch at every step to keep the GPU busy. Transformers & Large Language Models
Contrastive learning: Training that pulls matching pairs together and pushes non-matching pairs apart in embedding space. Retrieval-Augmented Generation (RAG)
control block: Heap object beside a shared_ptr that stores strong and weak counts, the deleter and the allocator. C++ Language
Convex function: A function whose chords lie above its graph; every local minimum is global. Math & Statistics for ML
Convolution: Sliding a small learnable kernel over an input and computing a dot product at each position. Deep Learning & Neural Networks
Convoy effect: FCFS failure: a long CPU job at the head forces many short jobs to wait, then they all block and re-form the convoy. Operating System Concepts
Cooling device: Kernel thermal object that can reduce heat, such as CPU frequency, GPU frequency or charge current. Power, Thermal & Battery
copy elision: Skipping a copy or move by constructing the target in place; guaranteed for many prvalues since C++17. C++ Language
copy-and-swap: Assignment implemented as construct-a-temporary then swap, giving the strong exception guarantee. C++ Language
Copy-on-write: Share a physical page among mappings until a write; the write faults and the kernel copies the page. Operating System Concepts
Copy-on-Write: pandas behaviour (default from version 3.0) where derived objects act as copies, so modifying one never silently changes another. Python & Data Tools for ML
Copy-on-write (COW): Memory or storage pages are shared until someone writes, then a private copy is made. Used by Zygote forks and virtual A/B snapshots. Android Boot Process
Copy-on-write (COW): Memory pages shared after fork until one side writes, at which point that page is copied. Android Frameworks Internals
Core ML: Apple's on-device inference framework, running on CPU, GPU and the Neural Engine. Edge AI Fundamentals
CORESET: Control Resource Set; the time-frequency region where PDCCH is sent. 5G NR & 5G Core
Corrective RAG: A pattern that grades retrieved documents and, when they are poor, discards them and uses an alternative source such as web search. Agentic AI & Multi-Agent Systems
Corrective RAG (CRAG): A pattern that grades retrieved documents and refines them, or falls back to another source such as web search, when they are poor. Retrieval-Augmented Generation (RAG)
Correlation: Covariance divided by the product of standard deviations; measures linear association on a [−1, 1] scale. Math & Statistics for ML
Cosine similarity: Dot product of two vectors divided by the product of their lengths; measures directional similarity. Deep Learning & Neural Networks
Cosine similarity: The cosine of the angle between two vectors; the standard closeness measure for embeddings. LLM APIs, Structured Outputs & Tool Calling
Cosine similarity: The dot product of two vectors divided by the product of their lengths; the cosine of the angle between them. Math & Statistics for ML
Cosine similarity: The dot product of two vectors divided by the product of their lengths; measures the angle between them. NLP Fundamentals
Cosine similarity: The cosine of the angle between two vectors; ignores magnitude and ranges from −1 to 1. Retrieval-Augmented Generation (RAG)
Cost function: The aggregated loss over the dataset, often plus a regularization penalty, that training minimises. Machine Learning Fundamentals
Cost of delay: The value lost for each unit of time a feature or release is late. Leadership, Delivery & Behavioral
Cost of quality: The total cost of preventing, finding and fixing defects, including field escapes. Leadership, Delivery & Behavioral
Coulomb counting: Measuring charge in and out by integrating current over time. Power, Thermal & Battery
CountDownLatch: A one-shot synchronizer that blocks until a count reaches zero. Java Language
Counterfactual fairness test: Comparing outputs for prompts that differ only in a demographic attribute. LLM Evaluation, Safety & Responsible AI
Covariance: E[(X − μ_X)(Y − μ_Y)]: whether two variables move together, in their product units. Math & Statistics for ML
Covariance matrix: A symmetric positive semi-definite matrix of pairwise feature covariances with variances on the diagonal. Math & Statistics for ML
COW: Copy-On-Write: pages shared read-only after fork and copied only when written. Linux Kernel & BSP
CPU fallback: Execution of operators the accelerator cannot run on the CPU instead, creating partitions and data transfers. Edge AI Deployment & Projects
cpufreq: Kernel subsystem that sets CPU frequency and voltage (DVFS) via a governor such as schedutil or interactive. Power, Thermal & Battery
cpuidle: Kernel subsystem that puts idle CPUs into low-power idle states between tasks, chosen by latency and target residency. Power, Thermal & Battery
CQRS: Command query responsibility segregation: separate models for writes and for reads. System Design
CR: Change Request; a tracked issue or request, often from a customer. Platform Integration & Release
CRDT: Conflict-free replicated data type that merges concurrent updates automatically and deterministically. System Design
Critical path: The longest sequence of dependent tasks; any delay on it delays the whole project. Leadership, Delivery & Behavioral
Critical section: The fragment of code that must appear atomic with respect to other threads sharing the same data. Operating System Concepts
Cross-attention: Attention with queries from one sequence (decoder) and keys/values from another (encoder output). Transformers & Large Language Models
Cross-encoder: A model that reads a query and a document together and outputs a relevance score; accurate but cannot pre-compute document vectors. NLP Fundamentals
Cross-encoder: A model that reads query and document together and outputs a relevance score; used for reranking. Retrieval-Augmented Generation (RAG)
Cross-encoder reranker: A model that scores a query and a passage together for precise relevance, used on a short candidate list. GenAI System Design & Case Studies
Cross-entropy: Loss equal to the negative log-probability assigned to the correct class; negative log-likelihood. Deep Learning & Neural Networks
Cross-entropy: −Σp log q: the average surprise of true outcomes under predicted distribution q; the standard classification loss. Math & Statistics for ML
Cross-entropy (log loss): Loss for probabilistic classifiers that heavily penalises confident wrong predictions. Machine Learning Fundamentals
Cross-entropy loss: Negative log-probability assigned to the correct token, averaged over positions. Transformers & Large Language Models
Cross-layer equalization: Rescaling consecutive layers so per-channel weight ranges are even, improving quantization without changing FP32 outputs. Edge AI Fundamentals
Cross-validation: Repeatedly splitting data into training and validation folds to estimate performance reliably. Machine Learning Fundamentals
Cross-validation: Repeatedly splitting training data into training and validation folds to estimate performance more reliably than a single split. Python & Data Tools for ML
CRTP: Curiously Recurring Template Pattern: Derived inherits Base<Derived> for static polymorphism without a vtable. C++ Language
CS (circuit-switched): Voice carried on a dedicated channel reserved for the whole call (GSM/UMTS domain). CS & IMS Call Flows
CS_FALLBACK: Sentinel string in Phone.java thrown in a CallStateException to tell GsmCdmaPhone to redial on CS. CS & IMS Call Flows
CSFB: Circuit-Switched Fallback: leaving LTE for 2G/3G to make a CS voice call. Android Telephony, RIL & Modem
CSFB: CS Fallback: 3GPP procedure moving an LTE UE without VoLTE to 2G/3G for a voice call via EXTENDED SERVICE REQUEST. CS & IMS Call Flows
CSFB: Circuit-Switched Fallback: an LTE UE without VoLTE moves to 2G/3G to make or receive a voice call. IMS, VoLTE & VoWiFi
CSFB: Circuit-Switched Fallback; moving a call from LTE to 3G or 2G when VoLTE is not available. Trace a Path Through the Android Stack
CTAD: Class template argument deduction (C++17): the compiler infers class template parameters from a constructor call. C++ Language
CTS: Compatibility Test Suite; tests public Android APIs and behaviour. Platform Integration & Release
CTS-Verifier: Mostly manual CTS tests for hardware-dependent behaviour that automation cannot fully judge. Platform Integration & Release
CUPS: Control and User Plane Separation; splitting SMF-type control from UPF forwarding. 5G NR & 5G Core
Curse of dimensionality: As dimensions grow, data becomes sparse and distances lose meaning. Machine Learning Fundamentals
CyclicBarrier: A reusable barrier: N parties must await before any proceeds; optional barrier action. Java Language

D

DAG: Directed acyclic graph; a directed graph with no cycles, which always has a topological order. Data Structures & Algorithms
Dalvik / dex: Dex is the APK bytecode format (historically Dalvik). Modern devices run it on ART, not the old Dalvik VM. Java Language
DAPS: Dual Active Protocol Stack handover; UE keeps the source link until the target is ready. 5G NR & 5G Core
DARE: Model-merging pre-processing that randomly drops most delta parameters and rescales the remainder. Fine-Tuning & Alignment
Data augmentation: Creating label-preserving variations of training examples to improve generalization. Deep Learning & Neural Networks
Data drift: Change in the input feature distribution between training and production. Machine Learning Fundamentals
Data exfiltration: An attack that tricks the model into leaking private data to an attacker, for example via an auto-loaded image URL. Prompt Engineering
Data Layer: Wear OS API (DataClient, MessageClient, ChannelClient, CapabilityClient) for syncing data between watch and phone. Trace a Path Through the Android Stack
Data leakage: Information unavailable at prediction time that contaminates training and inflates scores. Machine Learning Fundamentals
Data leakage: Information unavailable at prediction time (often from the test set or the target) sneaking into training, inflating reported performance. Python & Data Tools for ML
Data parallelism: Each device holds a model copy and processes a different data slice; gradients are averaged across devices. Deep Learning & Neural Networks
Data race: Two threads touch the same memory, at least one writes, with no happens-before. UB in C11. C Language
data race: Conflicting concurrent accesses to a non-atomic object, at least one a write, without happens-before; undefined behavior. C++ Language
Data race: Conflicting accesses to a non-volatile location with no happens-before order; the JMM gives almost no guarantees. Java Language
Data residency: A requirement that data is stored and processed only in specified geographic regions. GenAI System Design & Case Studies
Dataclass: Class decorated with @dataclass, which auto-generates __init__, __repr__ and __eq__ from annotated fields. Python & Data Tools for ML
DataClient: Data Layer API for persistent, synced key-value DataItems. Wear OS Platform
DataFrame: pandas two-dimensional labelled table made of columns (Series) sharing one index. Python & Data Tools for ML
DataItem: A small, versioned piece of data at a path, synced across all nodes. Wear OS Platform
DataLoader: PyTorch utility that batches, shuffles and optionally loads data in parallel worker processes from a Dataset. Python & Data Tools for ML
DataNetwork: Android 13+ state machine for one active telephony data connection. Android Data Call: Control, netd, eBPF & Packets
DataNetworkController: Android 13+ per-Phone orchestrator that replaced DcTracker. Android Data Call: Control, netd, eBPF & Packets
DataNetworkController: Android 13+ framework class managing all data connections of one phone. Android Telephony, RIL & Modem
DataProfile: Framework object for an APN/DNN plus protocol, auth and 5G extras (slice, traffic descriptor). Android Data Call: Control, netd, eBPF & Packets
DataRetryManager: Applies carrier retry/backoff and network-provided timers such as T3396. Android Data Call: Control, netd, eBPF & Packets
DataService: android.telephony.data.DataService: pluggable implementer of setup/teardown (RIL or IWLAN). Android Data Call: Control, netd, eBPF & Packets
DBSCAN: Density-based clustering that finds arbitrary shapes and labels sparse points as noise. Machine Learning Fundamentals
DcTracker: Pre-13 data connection tracker; still in logs and older branches. Android Data Call: Control, netd, eBPF & Packets
DDR training: Calibration of the LPDDR interface (impedance, CA training, Vref, DQS timing) done by XBL before DRAM can be used. Android Boot Process
DDS: Default Data Subscription: the SIM that carries internet data on a multi-SIM phone. Android Telephony, RIL & Modem
Dead-letter queue: Queue that holds messages that repeatedly failed processing, for inspection. System Design
Deadlock: A set of processes where each waits for a resource another in the set holds, and nobody can proceed. Operating System Concepts
DeadObjectException: RemoteException thrown when calling a Binder whose hosting process has died. Binder IPC & AIDL
DeathRecipient: Callback object registered with linkToDeath(); its binderDied() runs when the remote process dies. Binder IPC & AIDL
Debate: A multi-agent pattern where agents argue or critique each other over rounds, with a judge or vote deciding the answer. Agentic AI & Multi-Agent Systems
Decision tree: Model that predicts by a sequence of threshold questions on features. Machine Learning Fundamentals
Declaration: Introduces a name and type without necessarily reserving storage or providing a body. C Language
Decode: The token-by-token generation phase of an LLM; memory-bandwidth-bound. Edge AI Fundamentals
Decode: The generation phase of inference that produces one token per step. It is limited by memory bandwidth. GenAI System Design & Case Studies
Decode phase: The token-by-token generation phase of an LLM; memory-bandwidth-bound because all weights and the KV cache are read for each token. Edge AI Deployment & Projects
Decoder-only: Transformer with only causally masked self-attention blocks, used by GPT-style LLMs. Transformers & Large Language Models
Decorator: A callable that takes a function and returns a modified or wrapped function, applied with @name. Python & Data Tools for ML
Dedicated bearer: Extra LTE EPS bearer for QoS on an existing PDN (for example QCI 1 voice). Android Data Call: Control, netd, eBPF & Packets
Dedicated bearer: Extra bearer with specific QoS (e.g. QCI 1 GBR for voice), activated by the network for a flow defined by a TFT. CS & IMS Call Flows
Dedicated bearer: An on-demand EPS bearer, often GBR, with a TFT; voice uses a QCI 1 dedicated bearer. IMS, VoLTE & VoWiFi
Dedicated bearer: A cellular connection with guaranteed QoS, used for VoLTE voice media. Trace a Path Through the Android Stack
DeepSpeed ZeRO: Memory optimization that shards optimizer states (stage 1), gradients (stage 2) and parameters (stage 3) across GPUs. Fine-Tuning & Alignment
Default bearer: The always-on non-GBR bearer created with each PDN connection; QCI 5 on the IMS APN. IMS, VoLTE & VoWiFi
Default EPS bearer: The always-on bearer created at LTE attach (or additional PDN connect) that carries general IP. Android Data Call: Control, netd, eBPF & Packets
Default method: An interface method with a body, used to evolve APIs without breaking existing implementors. Java Language
Defensive copy: A copy of mutable state taken on the way in or out so callers cannot mutate your internals. Java Language
Deferred probe: Retrying a driver's probe later when it returns -EPROBE_DEFER because a dependency is missing. Linux Kernel & BSP
Definition: The unique place that reserves storage or provides a function body (plus C's tentative-definition rules). C Language
Delegate: A LiteRT plug-in that takes over supported parts of a graph and runs them on a GPU, NPU or DSP. Edge AI Deployment & Projects
Delegate: A runtime plug-in that executes supported parts of a model graph on an accelerator such as a GPU or NPU. Edge AI Fundamentals
deleter: Callable stored in a smart pointer that releases the resource (default: delete). C++ Language
Delimiter: A marker such as XML-style tags, triple quotes or fences that separates data from instructions in a prompt. Prompt Engineering
Demand paging: Bring a page into RAM only when it is first referenced (or when a prefetch policy chooses to). Operating System Concepts
Denormalisation: Storing redundant copies of data to make reads faster at the cost of more complex writes. System Design
Dense retrieval: Retrieval by similarity between learned dense embeddings of query and documents. Retrieval-Augmented Generation (RAG)
Dependency parsing: Predicting a tree where each word points to its grammatical head with a labelled relation such as subject or object. NLP Fundamentals
Depthwise separable convolution: A per-channel spatial convolution followed by a 1×1 convolution; far cheaper than a standard convolution. Deep Learning & Neural Networks
Depthwise-separable convolution: A per-channel spatial convolution followed by a 1x1 convolution; far cheaper than a standard convolution. Edge AI Fundamentals
Deque: Double-ended queue with O(1) insertion and removal at both ends. Data Structures & Algorithms
Determinant: A scalar giving the volume scaling of a linear map; zero means the matrix is singular. Math & Statistics for ML
Developer message: A message role for application-level instructions that rank below platform system rules and above user input. Prompt Engineering
Device tree (DT): Data structure describing non-discoverable hardware; compiled from .dts to .dtb. Linux Kernel & BSP
Device tree (DTB/DTBO): A data structure describing the board's hardware for the kernel; DTBO overlays patch it for variants. Android Boot Process
dexopt: Ahead-of-time compilation of app dex code to native code (dex2oat), guided by profiles. Android Frameworks Internals
DFS: Depth-first search; follows one path as deep as possible before backtracking, using recursion or a stack. Data Structures & Algorithms
Dialog: A long-lived SIP peer relationship identified by Call-ID, From tag and To tag. IMS, VoLTE & VoWiFi
Diarization: Identifying who spoke when in an audio recording. GenAI System Design & Case Studies
Differential privacy: A mathematical guarantee, parameterized by epsilon and delta, that one individual's data barely changes a computation's output. Edge AI Fundamentals
Diffusion model: Generative model trained to reverse a gradual noising process by predicting the added noise. Deep Learning & Neural Networks
Dijkstra's algorithm: Greedy single-source shortest-path algorithm for non-negative edge weights using a min-heap. Data Structures & Algorithms
Directional stimulus prompting: Adding instance-specific hints, such as keywords, to guide a frozen LLM; hints can be produced by a small trained policy model. Prompt Engineering
Disagree and commit: Voicing disagreement openly before a decision, then fully supporting it once made. Leadership, Delivery & Behavioral
DisconnectCause: Reason a call ended; android.telephony.DisconnectCause internally, mapped to android.telecom.DisconnectCause for the UI. CS & IMS Call Flows
Distillation: Training a small student model to imitate a larger teacher model's outputs. Edge AI Fundamentals
Distillation: Training a smaller student model to imitate a larger teacher's outputs or probability distributions. Fine-Tuning & Alignment
Distillation: Training a smaller model to imitate a larger one on a task, to cut cost and latency. GenAI System Design & Case Studies
Distributional hypothesis: The idea that words occurring in similar contexts have similar meanings. NLP Fundamentals
Divide and conquer: Split a problem into independent subproblems, solve each, and combine the results (merge sort). Data Structures & Algorithms
dm-verity: Device-mapper target that verifies each block of a read-only partition against a hash tree at read time. Android Boot Process
dm-verity: Kernel feature that checks each block of a read-only partition against a hash tree when it is read. Trace a Path Through the Android Stack
DMA: Direct Memory Access: a device transfers data to or from RAM without the CPU copying it. Linux Kernel & BSP
DMA: Direct memory access: a device copies to or from RAM as bus master; the CPU is interrupted on completion or error. Operating System Concepts
DMA-BUF: Kernel framework for sharing buffers between devices and processes via file descriptors. Linux Kernel & BSP
DNN: Data Network Name; the 5G equivalent of an APN. 5G NR & 5G Core
DNN: Data Network Name; 5G name for APN. Android Data Call: Control, netd, eBPF & Packets
DnsResolver: Android stub resolver (DoT, per-netId servers, DNS64). Split out of classic netd. Android Data Call: Control, netd, eBPF & Packets
Document frequency (df): The number of documents in a corpus that contain a given term. NLP Fundamentals
Domain selection: Android 14+ service deciding whether a call goes over CS or PS (IMS), and over which access. CS & IMS Call Flows
DoRA: Weight-decomposed LoRA: learns a magnitude vector and applies LoRA to the normalized direction of each weight. Fine-Tuning & Alignment
DoT: DNS-over-TLS; what Private DNS uses. Android Data Call: Control, netd, eBPF & Packets
Dot product: The sum of element-wise products of two vectors; measures alignment and underlies neurons and attention. Math & Statistics for ML
Double quantization: Quantizing the per-block quantization constants themselves to save memory. Fine-Tuning & Alignment
Double-checked locking: A lazy-init pattern that checks a reference outside and inside a lock; the reference field must be volatile. Java Language
Doze: Device-wide idle mode that defers apps' network, jobs and alarms into maintenance windows. Power, Thermal & Battery
DPO: Direct Preference Optimization: aligns a model with preference pairs using a closed-form loss on policy-to-reference log-probability ratios. Fine-Tuning & Alignment
DPO: Direct Preference Optimization: trains a model on preference pairs without a separate reward model or RL loop. LLM Evaluation, Safety & Responsible AI
DPO (Direct Preference Optimization): Alignment method that trains directly on preferred/rejected response pairs without a separate reward model or RL loop. Transformers & Large Language Models
DPR (Dense Passage Retrieval): The canonical dual-encoder retriever trained with in-batch and BM25 hard negatives for open-domain QA. Retrieval-Augmented Generation (RAG)
Draft acceptance rate: The per-token probability that a speculative draft token is accepted by the target model; it sets expected tokens per verification pass. Edge AI Deployment & Projects
Draft acceptance rate (α): The per-token probability that the target model accepts a speculative draft token. It sets the expected tokens per target pass. GenAI System Design & Case Studies
DRB: Data Radio Bearer carrying user data over the air. 5G NR & 5G Core
DRB: Data Radio Bearer on the air interface; carries user plane after PDCP. Android Data Call: Control, netd, eBPF & Packets
DRI: Directly responsible individual: the single named owner of an outcome or decision. Leadership, Delivery & Behavioral
DRI: Directly Responsible Individual; the single person accountable for driving an item to closure. Platform Integration & Release
Drift: Change over time in inputs, retrieved content or model behaviour that degrades quality. GenAI System Design & Case Studies
Drift: Change over time in inputs, knowledge, model behaviour or outputs that degrades a deployed system. LLM Evaluation, Safety & Responsible AI
DriverCall: The modem's description of one call (index, state, number) returned by getCurrentCalls(). CS & IMS Call Flows
Dropout: Regularizer that randomly zeroes activations during training and is disabled at inference. Deep Learning & Neural Networks
DRX: Discontinuous reception; modem sleeps between monitoring occasions. Chatty traffic defeats it. Android Data Call: Control, netd, eBPF & Packets
DRX / eDRX: Modem sleep cycles between paging occasions; extended DRX gives longer sleep. Power, Thermal & Battery
DRX / eDRX: Discontinuous reception: the modem sleeps between paging occasions; extended DRX lengthens the cycle for more savings. Wear OS Platform
DSCP: Differentiated Services Code Point: IP header marking for QoS; voice uses EF (46). IMS, VoLTE & VoWiFi
DSD: Qualcomm QMI Data System Determination example: which RAT should carry data. Android Data Call: Control, netd, eBPF & Packets
DSDS / DSDA: Dual SIM Dual Standby (shared radio) / Dual SIM Dual Active (both SIMs active at once). Android Telephony, RIL & Modem
DSP: Digital signal processor: a power-efficient processor for fixed-point vector maths, often used for audio and always-on models. Edge AI Fundamentals
DSPy: A framework where you declare LLM programs as signatures and modules with a metric, and optimizers compile the instructions and examples. Prompt Engineering
DSS: Dynamic Spectrum Sharing; LTE and NR on the same carrier, split dynamically. 5G NR & 5G Core
DTBO: Device Tree Blob Overlay: patch applied to a base DTB for a board variant. Linux Kernel & BSP
dtype: The data type of array or column elements, such as float32, int64 or category. Python & Data Tools for ML
Dual mode: Hardware privilege split: user mode cannot execute privileged instructions; kernel mode can. Crossings are traps, IRQs and exceptions. Operating System Concepts
dumpsys: Tool that calls a Binder service's dump() to print its internal state. Android Frameworks Internals
DUN: Dial-Up Networking APN type used by some carriers for tethering. Android Data Call: Control, netd, eBPF & Packets
Dunder method: A "double underscore" special method like __len__ that Python calls to implement built-in syntax and functions. Python & Data Tools for ML
DVFS: Dynamic voltage and frequency scaling: clock and supply voltage move together; dynamic power scales about as V²f. Power, Thermal & Battery
Dying ReLU: A ReLU unit whose input is always negative, so it outputs zero and receives no gradient. Deep Learning & Neural Networks
Dynamic programming: Solving problems with overlapping subproblems by storing and reusing sub-answers. Data Structures & Algorithms
Dynamic quantization: Quantizing activations at runtime with scales computed from each tensor's actual values; common on CPUs, not possible on most NPUs. Edge AI Deployment & Projects
Dynamic quantization: Quantization where activation scales are computed at runtime for each input. Edge AI Fundamentals

E

E-CSCF: Emergency CSCF: routes emergency sessions to the correct PSAP. IMS, VoLTE & VoWiFi
Early media: Media such as ringback tones or announcements sent before the call is answered. IMS, VoLTE & VoWiFi
Early stopping: Halting training when validation performance stops improving, keeping the best checkpoint. Deep Learning & Neural Networks
Early stopping: Halting training when validation performance stops improving, keeping the best checkpoint. Fine-Tuning & Alignment
Early stopping: Halting training when validation performance stops improving. Machine Learning Fundamentals
EAS: Energy Aware Scheduling: places tasks using a per-CPU energy model. Linux Kernel & BSP
EAS: Energy Aware Scheduling: places tasks using a per-CPU energy model and PELT utilization; pairs with schedutil. Power, Thermal & Battery
EBO: Empty base optimization: an empty base subobject may take no storage, unlike an empty standalone object. C++ Language
eBPF: Extended Berkeley Packet Filter; in-kernel programs Android uses for UID policy, stats, tethering and CLAT. Android Data Call: Control, netd, eBPF & Packets
eBPF: Extended Berkeley Packet Filter; programs that the kernel runs on packets, sockets and cgroups. Android uses it for UID traffic stats, firewall, tethering and CLAT instead of much of the old iptables/qtaguid path. Trace a Path Through the Android Stack
ECBM: Emergency Callback Mode: a period after an emergency call when the device stays reachable for a PSAP callback. CS & IMS Call Flows
ECM: EPS Connection Management: ECM-IDLE (no NAS signalling connection) versus ECM-CONNECTED (NAS connection up). Distinct from EMM registration state. Android Telephony, RIL & Modem
EDA: Exploratory data analysis: systematic inspection of data quality, distributions and relationships before modelling. Python & Data Tools for ML
Eden: The HotSpot young-generation space where most new objects are allocated before a minor GC. Java Language
Edge server (MEC): A server near users, on premises or at a telecom site (multi-access edge computing), offering low-latency compute. Edge AI Fundamentals
EDL: Emergency Download mode. Qualcomm ROM-level USB rescue mode (QDLoader 9008) that accepts a signed Firehose programmer. Android Boot Process
EEVDF: Earliest Eligible Virtual Deadline First: Linux's default fair scheduler since 6.6. Linux Kernel & BSP
Effective batch size: Micro-batch size × gradient-accumulation steps × number of data-parallel GPUs. Fine-Tuning & Alignment
Effective type: The type C uses for aliasing rules: how an object may be read. Strict aliasing is the informal name. C Language
efSearch: The HNSW query-time parameter setting how many candidates are kept during search; higher means more recall and latency. Retrieval-Augmented Generation (RAG)
eFuse / QFPROM: One-time-programmable fuses in the SoC that store the OEM key hash, secure-boot enable, anti-rollback and debug settings. Android Boot Process
Eigenvector / eigenvalue: A direction v that a matrix only scales, Av = λv; λ is the scale factor. Math & Statistics for ML
Elastic Net: Regularization combining L1 and L2 penalties. Machine Learning Fundamentals
Elo rating: Rating system updated after each pairwise comparison based on expected versus actual outcome. LLM Evaluation, Safety & Responsible AI
Embedding: A learned dense vector representing a discrete item such as a word, token, user or product. Deep Learning & Neural Networks
Embedding: A fixed-length numeric vector representing the meaning of text or other content, used for search and similarity. LLM APIs, Structured Outputs & Tool Calling
Embedding: A dense, learned vector representing a token, word, sentence or document so that geometric closeness reflects similarity. NLP Fundamentals
Embedding: A fixed-length dense vector representing text (or images) such that similar meanings are close. Retrieval-Augmented Generation (RAG)
Embedding: A learned dense vector representing a token (input embedding) or a piece of content (sentence embedding). Transformers & Large Language Models
Embedding router: A router that matches a query embedding against example-query profiles for each route using cosine similarity. GenAI System Design & Case Studies
EmergencyNumberTracker: Telephony component merging emergency numbers from SIM, network, modem and database. CS & IMS Call Flows
Emergent ability: A capability that appears only in models above a certain scale, such as in-context learning. Transformers & Large Language Models
EMM / ESM: LTE NAS mobility and session management. Attach is EMM; PDN/bearer is ESM. Android Data Call: Control, netd, eBPF & Packets
EMM / ESM: EPS Mobility Management and EPS Session Management: the LTE NAS protocols. Android Telephony, RIL & Modem
eMMC: embedded MultiMediaCard. Parallel, half-duplex managed NAND storage, up to about 400 MB/s. Android Boot Process
EN-DC: E-UTRA NR Dual Connectivity; the NSA mode with LTE master and NR secondary. 5G NR & 5G Core
EN-DC: E-UTRA NR Dual Connectivity: 5G NSA with an LTE anchor and NR secondary cell group. Android Telephony, RIL & Modem
enable_shared_from_this: Mixin that lets an already shared object produce more shared_ptrs to itself via a weak back-pointer. C++ Language
Encoder-decoder: Architecture where an encoder builds a representation of the input and a decoder generates the output from it. Deep Learning & Neural Networks
Encoder-decoder: Transformer with a bidirectional encoder for the input and a causal decoder with cross-attention for the output (T5, BART). Transformers & Large Language Models
Encoder-only: Transformer with bidirectional self-attention only, used for understanding tasks and embeddings (BERT). Transformers & Large Language Models
Endianness: Byte order of a multi-byte integer in memory or on the wire. Host and protocol may differ. C Language
Energy per inference: Average power above idle multiplied by latency; the right metric for comparing backends on battery devices. Edge AI Fundamentals
Entity linking: Mapping a text mention to a unique entry in a knowledge base or ontology. NLP Fundamentals
Entity resolution: Linking extracted mentions to canonical records (accounts, assets, tickers) and merging duplicates. GenAI System Design & Case Studies
Entropy: Measure of impurity or uncertainty: −Σ p log₂ p. Machine Learning Fundamentals
Entropy: −Σp log p: the average uncertainty or information content of a distribution. Math & Statistics for ML
EP context cache: An ONNX Runtime feature that saves a compiled execution-provider graph (for example a QNN context) so later sessions skip compilation. Edge AI Deployment & Projects
ePDG: Evolved Packet Data Gateway; IPsec peer for IWLAN. Android Data Call: Control, netd, eBPF & Packets
ePDG: Evolved Packet Data Gateway: terminates the UE's IPsec tunnel over untrusted Wi-Fi and connects to the P-GW. IMS, VoLTE & VoWiFi
Episodic memory: Memory of specific past experiences or runs; in some material, the current conversation thread. Agentic AI & Multi-Agent Systems
Epoch: One complete pass through the training dataset. Deep Learning & Neural Networks
EPS fallback: Moving a 5G SA UE to LTE at voice call setup so the call runs as VoLTE. 5G NR & 5G Core
Erasure: The compile-time-only nature of Java generics: List<String> is a raw List at runtime. Java Language
erofs: Enhanced Read-Only File System: compressed read-only filesystem used for Android system partitions. Linux Kernel & BSP
errno: Thread-local error code set by many failing libc/POSIX calls. Inspect it only after a documented failure. C Language
Error budget: The allowed amount of unreliability implied by an SLO, spent on launches and risk. System Design
Escape: A defect that reaches customers or a later stage after passing the checks meant to catch it. Leadership, Delivery & Behavioral
Escape analysis: A JIT analysis that may allocate an object on the stack or in registers if it never escapes the method or thread. Java Language
Escape hatch: An explicit allowed response for missing information, such as "Not found", which prevents forced guessing. Prompt Engineering
Escaped defect: A bug found by customers or in the field that internal gates missed. Platform Integration & Release
ESR: EXTENDED SERVICE REQUEST, the NAS message an LTE UE sends to trigger CSFB. CS & IMS Call Flows
eSRVCC: Enhanced SRVCC with ATCF/ATGW anchoring for a shorter voice interruption. IMS, VoLTE & VoWiFi
Estimator: Any scikit-learn object that learns from data via fit. Python & Data Tools for ML
ETDump and ETRecord: ExecuTorch developer-tool artifacts: runtime profiling and debug data (ETDump) and export-time graph metadata (ETRecord) used together by the Inspector. Edge AI Deployment & Projects
eUICC / EID: Embedded UICC that stores downloadable profiles, and its unique identifier. Android Telephony, RIL & Modem
eUICC / eSIM: Embedded SIM chip that can store carrier profiles downloaded over the air. Wear OS Platform
Eval-driven development: Defining evaluations first and accepting prompt, model or code changes only when evals show improvement without regressions. LLM Evaluation, Safety & Responsible AI
Evaluation set (golden set): A curated, versioned collection of inputs with expected outputs or rubrics, used to measure and gate changes. GenAI System Design & Case Studies
Evaluator-optimizer: A loop where one component generates output and another evaluates it against criteria and returns feedback until it passes. Agentic AI & Multi-Agent Systems
eventfd: Linux kernel object used as a lightweight wake-up signal; MessageQueue sleeps on it through epoll. Android Frameworks Internals
EventHub: Component of the input system that reads raw events from /dev/input devices. Trace a Path Through the Android Stack
Eventual consistency: Guarantee that replicas converge to the same value if writes stop. System Design
EVS: Enhanced Voice Services codec: up to fullband audio, 5.9 to 128 kbit/s, robust channel-aware mode. IMS, VoLTE & VoWiFi
Exact match (EM): Metric scoring 1 when the normalised prediction equals the gold answer, else 0. LLM Evaluation, Safety & Responsible AI
Exact match (EM): A QA metric scoring 1 when the normalised prediction equals the normalised reference answer. Retrieval-Augmented Generation (RAG)
Exception: A synchronous unusual condition caused by the current instruction (fault, trap, abort), as opposed to an asynchronous IRQ. Operating System Concepts
Exception level (EL0-EL3): Arm privilege levels: apps (EL0), kernel (EL1), hypervisor (EL2), secure monitor (EL3). Android Boot Process
exception safety: What state remains if a throw occurs: no-throw, strong (rollback), basic (no leaks, invariants hold), or none. C++ Language
Excessive agency: Granting an agent more tools, permissions or autonomy than its task requires, enlarging the damage of any mistake or attack. Agentic AI & Multi-Agent Systems
Excessive agency: Giving an LLM more tools, permissions or autonomy than necessary, enlarging the damage of errors or attacks. LLM Evaluation, Safety & Responsible AI
Exchange argument: Proof technique for greedy algorithms showing any optimal solution can be changed to include the greedy choice. Data Structures & Algorithms
Execution provider: An ONNX Runtime backend (CPU, QNN, Core ML, XNNPACK and others) that executes the subgraphs assigned to it. Edge AI Deployment & Projects
Execution provider: ONNX Runtime's term for a hardware backend (CPU, QNN, Core ML, XNNPACK, TensorRT and so on). Edge AI Fundamentals
Executor: The component that performs one planned step by making the actual tool calls, often using a cheaper model. Agentic AI & Multi-Agent Systems
ExecuTorch: PyTorch's on-device runtime that executes .pte programs produced from torch.export, with pluggable hardware backends. Edge AI Deployment & Projects
ExecuTorch: PyTorch's runtime for on-device inference, using models exported with torch.export into .pte files. Edge AI Fundamentals
ExecutorService: An API to submit tasks to a thread pool and obtain Futures, instead of constructing Threads by hand. Java Language
ExerciseClient: Health Services API for active workouts with high-rate metrics. Wear OS Platform
Expectation: The probability-weighted average of a random variable. Math & Statistics for ML
Expectation–Maximization (EM): Iterative algorithm alternating soft assignment and parameter re-estimation, used to fit GMMs. Machine Learning Fundamentals
Exploding gradient: Gradients growing exponentially through depth or time, causing unstable updates or NaN. Deep Learning & Neural Networks
Exponential backoff: A retry policy in which the wait before each retry grows exponentially, usually with a cap. LLM APIs, Structured Outputs & Tool Calling
Exposure bias: The mismatch between training with true previous tokens (teacher forcing) and inference with the model's own, possibly wrong, predictions. NLP Fundamentals
Exposure bias: Mismatch between training on gold prefixes (teacher forcing) and generating from the model's own possibly wrong outputs. Transformers & Large Language Models
extern: Specifies external linkage, or (with an initialiser) a definition. In headers, usually a declaration only. C Language
extern "C": Linkage specification that disables C++ name mangling so C, JNI and dlsym can see the symbol. C++ Language
External fragmentation: Free memory exists but is split into holes too small for the next variable-size request. Operating System Concepts

F

F1 score: Harmonic mean of precision and recall. Machine Learning Fundamentals
F1 score: The harmonic mean of precision and recall. NLP Fundamentals
f2fs: Flash-Friendly File System: log-structured filesystem used for /data. Linux Kernel & BSP
Fail-fast iterator: An iterator that throws ConcurrentModificationException if it sees a modCount change it did not make. Java Language
Faithfulness: The fraction of an answer's claims supported by the retrieved context; also called groundedness. Retrieval-Augmented Generation (RAG)
Faithfulness (groundedness): The degree to which every claim in an output is supported by the provided source or context. LLM Evaluation, Safety & Responsible AI
Fake failure: A behavioral story labelled as a miss that had no real cost; interviewers treat it as avoidance. Leadership, Delivery & Behavioral
Fake quantization: Simulating quantization in floating point (quantize then dequantize) to measure or train for its effect on a host. Edge AI Deployment & Projects
Fake quantization: Quantize-then-dequantize operations inserted during QAT to simulate rounding in floating point. Edge AI Fundamentals
Fallback: Running an operator on the CPU because the accelerator does not support it. Edge AI Fundamentals
Fallback chain: An ordered list of alternative models or behaviours used when the primary fails. GenAI System Design & Case Studies
FAM: Flexible array member: last struct member T data[], sized by the allocation, not by sizeof. C Language
Fan-out: Delivering one event or request to many recipients or backends. System Design
Fancy indexing: Indexing an array with lists or arrays of integers; always returns a copy. Python & Data Tools for ML
Fast Message Queue (FMQ): Shared-memory queue used by HALs (such as Sensors) to pass high-rate data without Binder calls. Trace a Path Through the Android Stack
Fastboot: USB protocol and bootloader mode for flashing partitions, switching slots and changing the lock state. Android Boot Process
fastbootd: User-space fastboot running in recovery, required for flashing logical partitions inside super. Android Boot Process
FastText: A word-embedding method that represents words as sums of character n-gram vectors, enabling vectors for unseen words. NLP Fundamentals
Fault: A restartable exception. The textbook example is a page fault: the kernel repairs the mapping and retries the instruction. Operating System Concepts
FBE: File-Based Encryption. Per-file encryption with device-encrypted and credential-encrypted storage, enabling Direct Boot. Android Boot Process
fdsan: Android file-descriptor sanitizer: tags fds and aborts on use-after-close or mismatched owner. C Language
Feature engineering: Creating or transforming input variables to expose signal to the model. Machine Learning Fundamentals
Feature flag: A runtime or build-time switch that hides unfinished features so code can merge early (aconfig in AOSP). Platform Integration & Release
Feature map: The 2D output of applying one convolutional filter across an input. Deep Learning & Neural Networks
Feature store: Shared, versioned feature definitions with offline (training) and online (serving) paths, using point-in-time joins to avoid leakage and skew. Machine Learning Fundamentals
Federated learning: Training across many devices by sharing model updates instead of raw data, then aggregating them on a server. Edge AI Fundamentals
Feed-forward network (FFN): The per-token two-layer MLP in each block that expands, applies a non-linearity and projects back. Transformers & Large Language Models
Fence: A synchronisation object that signals when a GPU or display operation on a buffer has finished. Trace a Path Through the Android Stack
Fencing token: Monotonically increasing number issued with a lock so storage can reject writes from stale lock holders. System Design
Fenwick tree: Binary indexed tree supporting prefix sums and point updates in O(log n). Data Structures & Algorithms
Few-shot prompting: Including a small number of input-output demonstrations in the prompt to show the task and format. Prompt Engineering
FIFO: First-in first-out. As a scheduler it is FCFS. As a page-replacement policy it evicts the oldest loaded page and can Belady-anomaly. Operating System Concepts
FILE: Opaque libc stream with buffering, sitting on top of a file descriptor. C Language
File descriptor: Small integer index in a process's open-file table. Capability-like: the right to operate on that open file description. Operating System Concepts
Fill-in-the-middle (FIM): A code model that completes text between a given prefix and suffix, used for inline completions. GenAI System Design & Case Studies
Final-field safety: The JMM guarantee that a fully constructed object's final fields are visible to other threads that see the reference, if this was not leaked. Java Language
Finalize: An obsolete Object method queued for a finalizer thread; unpredictable, can resurrect objects; do not use. Java Language
Fine-tuning: Continuing training of a pretrained model on a new task, usually with a small learning rate. Deep Learning & Neural Networks
finish_reason: The field explaining why generation stopped: stop, length, tool_calls or content_filter (names vary by provider). LLM APIs, Structured Outputs & Tool Calling
Firehose: Signed Qualcomm programmer loaded in EDL mode that reads and writes flash using an XML protocol. Android Boot Process
FLAG_IMMUTABLE: PendingIntent flag (required to choose mutability from Android 12) that prevents the holder from changing the Intent. Android Frameworks Internals
FLAG_ONEWAY: Transaction flag meaning the caller does not wait for a reply. Binder IPC & AIDL
FlashAttention: Exact, I/O-aware attention kernel that tiles work in on-chip memory to avoid materialising the n × n matrix. Transformers & Large Language Models
flat_binder_object: Parcel entry describing a Binder object or fd that the driver translates for the receiver. Binder IPC & AIDL
FLOPs: Floating-point operations; a measure of compute work (one multiply-accumulate is about two FLOPs). Edge AI Fundamentals
Focal loss: Cross-entropy scaled by (1 − p_t)^γ to focus training on hard, misclassified examples. Deep Learning & Neural Networks
fold expression: C++17 pack expansion that reduces a parameter pack with a binary operator. C++ Language
Follow-the-sun: Passing work between sites in different time zones so progress continues around the clock. Leadership, Delivery & Behavioral
Foreground service: Service with a visible notification that the system keeps alive for user-visible work. Power, Thermal & Battery
ForkJoinPool: A work-stealing pool for divide-and-conquer tasks; hosts the common pool used by parallel streams. Java Language
forwarding reference: A template parameter T&& that binds to both lvalues and rvalues and is forwarded with std::forward. C++ Language
FP16: Half-precision float with a 5-bit exponent and 10-bit mantissa; maximum value 65,504. Edge AI Fundamentals
FP8: 8-bit floating point, in E4M3 (more precision, max 448) and E5M2 (more range) variants. Edge AI Fundamentals
FR1 / FR2: Frequency Range 1 (sub-7 GHz) and Frequency Range 2 (mmWave). 5G NR & 5G Core
Frequency penalty: A parameter that lowers a token's logit in proportion to how many times it has already appeared. LLM APIs, Structured Outputs & Tool Calling
Frequency penalty: Decoding control that lowers a token's logit in proportion to how often it has already appeared. Transformers & Large Language Models
FSDP: Fully Sharded Data Parallel: PyTorch's native sharding of parameters, gradients and optimizer states. Fine-Tuning & Alignment
FSDP / ZeRO: Sharded data parallelism that splits parameters, gradients and optimizer state across devices. Deep Learning & Neural Networks
ftrace: Kernel's built-in tracer for functions, tracepoints and latency. Linux Kernel & BSP
Fuel gauge: Hardware and algorithm that estimate battery state of charge and health. Power, Thermal & Battery
Function calling: An API feature where the model returns a structured request to call a described function instead of plain text. Agentic AI & Multi-Agent Systems
Function calling: Another name for tool calling: the model outputs a function name and JSON arguments for your code to execute. LLM APIs, Structured Outputs & Tool Calling
Function calling: API feature where the model returns a structured request to call a declared tool; the application executes it and returns the result. Prompt Engineering
Function pointer: Pointer to a function; type includes return and parameter types. Not an object pointer. C Language
FUSE: Filesystem in Userspace. Android 11+ uses MediaProvider FUSE for emulated shared storage; it replaced sdcardfs. Linux Kernel & BSP
Fused location provider: Framework provider that combines GNSS, network location and sensors so apps do not talk to the chip themselves. Trace a Path Through the Android Stack
Futex: Fast userspace mutex: syscall used by pthread locks only when contention occurs. Linux Kernel & BSP
fwmark: 32-bit firewall mark on a socket/skb used with ip rule to select a Network's routing table. Android Data Call: Control, netd, eBPF & Packets
fwmark: Firewall mark on a socket; Android uses it with ip rule so traffic for a UID or a specific Network takes the matching routing table. Trace a Path Through the Android Stack

G

G-Eval: LLM-judge method that generates evaluation steps via chain-of-thought and fills a score form, optionally weighting by token probabilities. LLM Evaluation, Safety & Responsible AI
G-Eval: LLM-based evaluation that generates evaluation steps with chain-of-thought and then scores the output, optionally weighting by token probabilities. Prompt Engineering
G1: Garbage-First, HotSpot's default region-based collector since Java 9. Java Language
GAIA: A benchmark of real-world assistant questions requiring reasoning, browsing and tool use, with short verifiable answers. Agentic AI & Multi-Agent Systems
GAN: Generative adversarial network: a generator and a discriminator trained against each other. Deep Learning & Neural Networks
Gaussian mixture model (GMM): Probabilistic model of data as a weighted mix of Gaussian components, giving soft cluster memberships. Machine Learning Fundamentals
GBA: Generic Bootstrapping Architecture: reuses SIM AKA to create keys for HTTP services such as XCAP on Ut. IMS, VoLTE & VoWiFi
GBR: Guaranteed Bit Rate: a bearer or QoS flow with reserved capacity. IMS, VoLTE & VoWiFi
GC root: A reference the collector starts from: locals, statics, JNI globals, and certain VM handles. Java Language
GCF: Global Certification Forum; industry cellular-device certification catalogue used widely outside PTCRB. Platform Integration & Release
GCG: Greedy Coordinate Gradient: white-box optimisation of an adversarial suffix that makes an aligned LLM comply. LLM Evaluation, Safety & Responsible AI
GELU: Smooth activation x·Φ(x), standard in Transformers. Deep Learning & Neural Networks
Generator: A function using yield that produces values lazily, one at a time, suspending between values. Python & Data Tools for ML
Genie: Qualcomm's generative AI runtime in QAIRT that wraps tokenizer, QNN execution, KV-cache management and sampling behind a dialog API. Confirm headers, JSON keys and CLI names against the SDK samples for your release. Edge AI Deployment & Projects
Geohash: Encoding of latitude and longitude into a string where shared prefixes mean nearby locations. System Design
Gerrit: Web-based code review system used by AOSP and most platform teams. Platform Integration & Release
GFP flags: "Get Free Pages" flags telling the allocator whether it may sleep, do I/O, etc. Linux Kernel & BSP
GGUF: llama.cpp's single-file model format containing tensors, quantization types, tokenizer and metadata. Edge AI Deployment & Projects
GGUF: llama.cpp's single-file model format containing quantized weights, tokenizer and metadata. Edge AI Fundamentals
GGUF: Single-file model format with metadata and many quantization types, used by llama.cpp-family runtimes. Fine-Tuning & Alignment
GGUF: A file format for quantized model weights used by llama.cpp and Ollama. LLM APIs, Structured Outputs & Tool Calling
GIC: ARM Generic Interrupt Controller: routes interrupts to CPU cores. Linux Kernel & BSP
GID: Group identifier on a UNIX-style process, used with UID for access checks and for group ownership of objects. Operating System Concepts
GIL: Global Interpreter Lock: a CPython mutex allowing only one thread to execute Python bytecode at a time per process. Python & Data Tools for ML
Gini impurity: 1 − Σ p²; the chance of mislabelling a random sample by labelling randomly from the node's class mix. Machine Learning Fundamentals
GKI: Generic Kernel Image. Google-built common kernel with vendor code in loadable modules against a stable KMI. Android Boot Process
GKI: Generic Kernel Image: Google-built Android core kernel with vendor code in modules. Optional in Android 11; required for new Android 12+ devices on 5.10+. Linux Kernel & BSP
GKI: Generic Kernel Image; Google-built kernel core with vendor code in modules against a stable kernel module interface. Same-KMI updates do not require those modules to rebuild. Platform Integration & Release
GLINK / SMD / SMEM: Qualcomm shared-memory transports and memory region used between processors. Android Telephony, RIL & Modem
GloVe: Global Vectors: embeddings learned by fitting dot products to the logarithm of global word co-occurrence counts. NLP Fundamentals
glvalue: A generalized lvalue: either an lvalue or an xvalue (an expression with identity). C++ Language
GMS: Google Mobile Services; licensed Google apps and services such as Play. Not part of AOSP. Platform Integration & Release
gNB: The NR base station; en-gNB when it serves as secondary node in EN-DC. 5G NR & 5G Core
Golden build: The exact build approved for release and certification. Platform Integration & Release
Golden dataset: Curated, versioned set of test inputs with expected outputs or grading criteria. LLM Evaluation, Safety & Responsible AI
Golden dataset: A curated set of questions with labelled relevant evidence and reference answers used for evaluation. Retrieval-Augmented Generation (RAG)
GOT / PLT: Global Offset Table and Procedure Linkage Table: indirection used by position-independent code to reach data and functions. C Language
GPTQ: A post-training weight quantization method that quantizes weights column by column while compensating the error using second-order information from calibration data. Edge AI Deployment & Projects
GPTQ: A post-training quantization algorithm that quantizes weights column by column while compensating the error using second-order information. Edge AI Fundamentals
GQA: Grouped-query attention: several query heads share one key/value head, shrinking the KV cache. Edge AI Fundamentals
GQA (grouped-query attention): Attention where several query heads share each key/value head, shrinking the KV cache in proportion. Edge AI Deployment & Projects
GQA (Grouped-Query Attention): Attention variant where groups of query heads share one key/value head to shrink the KV cache. Transformers & Large Language Models
Gradient: Vector of partial derivatives of the loss with respect to the parameters; points toward steepest increase. Deep Learning & Neural Networks
Gradient: The vector of partial derivatives; points in the direction of steepest increase. Math & Statistics for ML
Gradient accumulation: Summing gradients over several micro-batches before one optimizer step to simulate a larger batch. Deep Learning & Neural Networks
Gradient accumulation: Summing gradients over several micro-batches before one optimizer step to simulate a larger batch. Fine-Tuning & Alignment
Gradient boosting: Sequentially adding trees fitted to the negative gradient of the loss. Machine Learning Fundamentals
Gradient checkpointing: Saving only some activations and recomputing the rest during backward to save memory. Fine-Tuning & Alignment
Gradient clipping: Rescaling gradients whose norm exceeds a threshold to prevent explosions. Deep Learning & Neural Networks
Gradient clipping: Rescaling the gradient when its norm exceeds a threshold, to prevent exploding updates. Math & Statistics for ML
Gradient descent: Optimisation that repeatedly steps parameters opposite the gradient of the cost. Machine Learning Fundamentals
Grammar (GBNF): A formal description of allowed output syntax; llama.cpp uses the GBNF notation for grammar-constrained generation. LLM APIs, Structured Outputs & Tool Calling
Graph of thoughts: Reasoning framework where thoughts form a graph that supports branching, merging and refinement loops. Prompt Engineering
Graph partitioning: Splitting a model graph into subgraphs for different processors; each boundary adds transfer and synchronisation cost. Edge AI Deployment & Projects
GraphRAG: RAG over a knowledge graph of entities and relationships extracted from the corpus, often with community summaries for global questions. Retrieval-Augmented Generation (RAG)
Greedy decoding: Always choosing the single most probable next token. LLM APIs, Structured Outputs & Tool Calling
Greedy decoding: Always choosing the highest-probability next token. Transformers & Large Language Models
GRF: Google Requirements Freeze (also discussed as a vendor-API freeze window): vendor implementations may stay on a frozen vendor API while the system image moves forward for a documented period. Check current release notes for the window length. Platform Integration & Release
Grid search: Exhaustive evaluation of every combination of listed hyperparameter values. Machine Learning Fundamentals
GridSearchCV: scikit-learn search that cross-validates every combination of a hyperparameter grid and refits the best. Python & Data Tools for ML
GRO: Generic Receive Offload; kernel merging of incoming segments before TCP. Android Data Call: Control, netd, eBPF & Packets
Groundedness (faithfulness): The degree to which every claim in an output is supported by the provided context. GenAI System Design & Case Studies
Grounding: Constraining an LLM's answer to supplied evidence rather than its parametric memory. Retrieval-Augmented Generation (RAG)
Group-wise quantization: Using one scale (and zero-point) per small block of weights, for example 32 or 128, to follow local ranges more closely. Edge AI Deployment & Projects
groupby: pandas split-apply-combine operation that groups rows by keys and aggregates, transforms or filters each group. Python & Data Tools for ML
GRPO: Group Relative Policy Optimization: PPO-style RL without a value model, using rewards standardized within a group of samples per prompt. Fine-Tuning & Alignment
GRPO: Group Relative Policy Optimization: RL method that scores each sampled answer relative to its group's average reward, used for reasoning training. Transformers & Large Language Models
GRU: Gated recurrent unit: an RNN cell with update and reset gates and a single state. Deep Learning & Neural Networks
GRU: Gated recurrent unit: a recurrent cell with update and reset gates, lighter than an LSTM. NLP Fundamentals
GRUU: Globally Routable User agent URI: addresses one specific device among several sharing an identity. IMS, VoLTE & VoWiFi
GSI: Generic System Image; pure AOSP system image used to validate Treble compliance. Platform Integration & Release
GsmCdmaCallTracker: CS call state machine; talks to the RIL and owns CS connections and calls. CS & IMS Call Flows
GsmCdmaPhone: Main Phone implementation per SIM slot; the place where CS vs IMS is decided. CS & IMS Call Flows
GTP-C: GTP control plane in LTE EPC (session/bearer signalling between core nodes). Android Data Call: Control, netd, eBPF & Packets
GTP-U: GTP user plane; tunnels UE IP packets (S1-U, S5, N3, N9). Android Data Call: Control, netd, eBPF & Packets
GTS: GMS Test Suite; tests requirements for shipping Google Mobile Services. Platform Integration & Release
Guardrail: A check around the model (classifier, rule, validator or policy) that blocks or modifies unsafe inputs, actions or outputs. Agentic AI & Multi-Agent Systems
Guardrail: Runtime check or constraint around a model that enforces policy on inputs, outputs or actions. LLM Evaluation, Safety & Responsible AI
Guardrails: Checks and constraints on inputs, processing and outputs that keep an LLM system within policy. GenAI System Design & Case Studies
Guardrails: Controls that keep model behaviour within intended limits: prompt rules, classifiers, filters, validators and policy checks. Prompt Engineering

H

H-SMF / V-SMF: Home and visited Session Management Functions in a home-routed roaming PDU session, connected over N16. 5G NR & 5G Core
HAL: Hardware Abstraction Layer: vendor code behind a stable interface (legacy C vtable or AIDL). C Language
HAL: Hardware Abstraction Layer: stable interface between the Android framework and vendor code. Linux Kernel & BSP
HAL: Hardware Abstraction Layer; a versioned interface between the Android framework and vendor code. Trace a Path Through the Android Stack
Hallucination: Fluent output not supported by facts, the provided source or the user's input. LLM Evaluation, Safety & Responsible AI
Hallucination: Generated content that is fluent but not supported by the source or by facts. NLP Fundamentals
Hallucination: Fluent output that is false, unsupported by the provided sources, or fabricated, stated with apparent confidence. Prompt Engineering
Hallucination: Fluent generated content that is false or unsupported by the provided sources. Retrieval-Augmented Generation (RAG)
Hallucination: Fluent output that is not supported by facts or by the provided context. Transformers & Large Language Models
Hand-off: Transfer of control and context from one agent to another, usually implemented as a special tool call. Agentic AI & Multi-Agent Systems
Handle: Per-process integer that refers to a Binder node owned by another process. Binder IPC & AIDL
Handler: Object bound to a Looper that enqueues Messages/Runnables and handles them on that Looper's thread. Android Frameworks Internals
HandlerThread: A Thread that creates its own Looper, used for serialized background work. Android Frameworks Internals
Happens-before: The JMM partial order that defines visibility and ordering between actions in different threads. Java Language
Hard link: A directory entry that names an existing inode. Same data, same inode number; last unlink (and last close) frees the file. Operating System Concepts
Hard negative: A training passage that looks relevant to a query but does not answer it. Retrieval-Augmented Generation (RAG)
HARQ: Hybrid ARQ; fast MAC-layer retransmission with soft combining. 5G NR & 5G Core
Hash function: Function mapping a key to an integer, used to pick a bucket in a hash table. Data Structures & Algorithms
Hashable: An object with a stable hash and equality, which can therefore be a dict key or set member. Python & Data Tools for ML
HashMap treeify: Conversion of a long collision chain into a red-black tree when length ≥ 8 and table capacity ≥ 64. Java Language
He initialization: Random weights with variance 2/fan_in, designed for ReLU networks. Deep Learning & Neural Networks
Health Connect: On-device store and sharing layer for health data on the phone. Wear OS Platform
Health HAL: HAL that reports battery and charger information to BatteryService. Power, Thermal & Battery
Health Services: Wear OS API that provides batched, power-efficient access to health and fitness sensor data. Trace a Path Through the Android Stack
Health Services: Wear OS system service and API that exposes health and fitness data with batching and offload handled for the app. Wear OS Platform
Heap pollution: A generic variable whose runtime contents violate its static type, usually via raw types; fails later on a cast. Java Language
heapprofd: Perfetto's native heap profiler that attributes allocations to call stacks in a running process. Edge AI Deployment & Projects
HELM: Holistic benchmark framework evaluating many scenarios across accuracy, calibration, robustness, fairness, toxicity and efficiency. LLM Evaluation, Safety & Responsible AI
Heroics: Delivery that depends on one person working nights instead of on WIP limits, gates and a bench; a common interview smell. Leadership, Delivery & Behavioral
Hessian: The matrix of second partial derivatives, describing the curvature of a function. Math & Statistics for ML
Hexagon HTP: The Hexagon Tensor Processor, the matrix/tensor accelerator in Snapdragon NPUs, reached through QNN/QAIRT. Edge AI Deployment & Projects
Hexagon NPU: Qualcomm's neural processor, combining scalar, vector (HVX) and tensor (HMX) units. Edge AI Fundamentals
Hidden state: The vector an RNN carries between time steps, summarizing the sequence so far. Deep Learning & Neural Networks
HIDL: HAL Interface Definition Language (Android 8-12), carried over hwbinder; now deprecated in favour of stable AIDL. Android Frameworks Internals
HIDL: HAL Interface Definition Language used over hwbinder in Android 8-12; now deprecated. Binder IPC & AIDL
HIDL: Legacy HAL interface language generating C++ over hwbinder; replaced by stable AIDL for new HALs. C++ Language
Hierarchical agents: A multi-agent structure in which supervisors delegate to sub-supervisors or specialists, forming a tree. Agentic AI & Multi-Agent Systems
Hinge loss: max(0, 1 − y·f(x)); the SVM loss that ignores points beyond the margin. Machine Learning Fundamentals
Hinted handoff: A replica temporarily accepts writes for an unavailable node and forwards them when it returns. System Design
HIPRI: High-priority mobile APN/type used to request cellular while another default exists. Android Data Call: Control, netd, eBPF & Packets
Hit rate (Hit@k): The fraction of queries with at least one relevant result in the top k. Retrieval-Augmented Generation (RAG)
HLOS: High-Level Operating System; the Linux kernel plus Android or Wear OS on the application processor. Platform Integration & Release
HNSW: Hierarchical Navigable Small World: a layered proximity-graph ANN index with roughly logarithmic search. Retrieval-Augmented Generation (RAG)
Hold and wait: Coffman condition: a process holds at least one resource while waiting for another. Operating System Concepts
Hot key: A single key receiving a disproportionate share of traffic, overloading one shard or cache node. System Design
HotSpot: The usual desktop and server JVM: classloading, C1/C2 JIT, Metaspace, and a choice of collectors. Java Language
HSS: Home Subscriber Server: master subscriber database for identities, keys and service profiles. IMS, VoLTE & VoWiFi
Human-in-the-loop (HITL): Designing points where a person reviews, approves or corrects the agent before it continues. Agentic AI & Multi-Agent Systems
HWC: Hardware Composer HAL; decides how layers are combined by the display hardware. Trace a Path Through the Android Stack
hwservicemanager: Context manager for /dev/hwbinder, used by HIDL HALs. Binder IPC & AIDL
Hybrid interface: Design where a small RTOS on the co-processor handles basic watch functions while Wear OS on the AP sleeps. Wear OS Platform
Hybrid search: Combining keyword (BM25) and dense vector retrieval, often fused by reciprocal rank fusion. GenAI System Design & Case Studies
Hybrid search: Combining sparse (keyword) and dense (semantic) retrieval results, typically with RRF. Retrieval-Augmented Generation (RAG)
HyDE: Hypothetical Document Embeddings: embed an LLM-written hypothetical answer instead of the raw question. Retrieval-Augmented Generation (RAG)
HyperLogLog: Tiny probabilistic structure that estimates the number of distinct items in a stream. System Design
Hyperparameter: A setting chosen before training (learning rate, batch size, depth) rather than learned. Deep Learning & Neural Networks
Hyperparameter: Setting chosen before training, such as learning rate, depth, k or C. Machine Learning Fundamentals
Hypervisor: Software that virtualises a machine for guest OS instances. Type 1 runs on hardware; type 2 runs as a host process. Operating System Concepts
Hypothesis test: A procedure that decides whether data provide enough evidence to reject a null hypothesis at level α. Math & Statistics for ML

I

I-CSCF: Interrogating CSCF: home-network entry point that finds the right S-CSCF using the HSS. IMS, VoLTE & VoWiFi
I-RNTI: Identifier of a suspended UE context, used to resume from RRC_INACTIVE. 5G NR & 5G Core
i.i.d.: Independent and identically distributed: samples drawn independently from the same distribution. Math & Statistics for ML
IA3: PEFT method that learns vectors rescaling keys, values and feed-forward activations. Fine-Tuning & Alignment
IApplicationThread: Binder interface an app gives AMS so the system can call back into the app (bind, launch, pause, trim memory). Android Frameworks Internals
IBCF: Interconnection Border Control Function: border towards other IMS networks. IMS, VoLTE & VoWiFi
IBinder: Base interface for remotable objects; provides transact, linkToDeath, pingBinder. Binder IPC & AIDL
ICCID: Integrated Circuit Card Identifier: the SIM card serial number. Android Telephony, RIL & Modem
IConnectionService: Binder interface Telecom uses to talk to a ConnectionService in another process. CS & IMS Call Flows
Idempotency: Property that repeating an operation has the same effect as performing it once. System Design
Idempotency key: A unique token sent with a write request so that retries do not repeat the side effect. Agentic AI & Multi-Agent Systems
Idempotency key: A unique request identifier that makes repeated calls perform an action only once. GenAI System Design & Case Studies
Idempotency key: A unique identifier for a logical operation so repeated requests with the same key are applied only once. LLM APIs, Structured Outputs & Tool Calling
iFC: Initial Filter Criteria: rules in the user profile telling the S-CSCF which application servers to invoke. IMS, VoLTE & VoWiFi
ifname: Kernel interface name returned in SetupDataCallResult. Android Data Call: Control, netd, eBPF & Packets
IKEv2: Internet Key Exchange version 2: sets up the IPsec tunnel between the UE and ePDG. IMS, VoLTE & VoWiFi
iloc: pandas position-based indexer; slice ends are exclusive. Python & Data Tools for ML
IMEM / SRAM: Small on-chip static RAM usable immediately after reset; used by PBL and early XBL before DDR works. Android Boot Process
IMPI: IP Multimedia Private Identity: the authentication identity, never used for routing. IMS, VoLTE & VoWiFi
Implementation-defined: The implementation must choose and document a behaviour (for example plain char signedness). C Language
Importance matrix: Per-weight importance statistics from calibration text, used by llama.cpp to reduce low-bit quantization error. Edge AI Fundamentals
IMPU: IP Multimedia Public Identity: SIP or tel URI used to reach the user. IMS, VoLTE & VoWiFi
IMS: IP Multimedia Subsystem: SIP-based core network for VoLTE, VoNR, Wi-Fi calling and RCS. Android Telephony, RIL & Modem
IMS: IP Multimedia Subsystem: the 3GPP SIP-based core for voice, video and messaging over IP. IMS, VoLTE & VoWiFi
IMS: IP Multimedia Subsystem; the network core that handles SIP-based voice (VoLTE, VoNR), video and SMS over IP. Trace a Path Through the Android Stack
IMS: IP Multimedia Subsystem: the network core used for VoLTE and VoNR calls. Wear OS Platform
ImsCall: Framework object representing one IMS call session over an IImsCallSession. CS & IMS Call Flows
ImsCallProfile: Attributes of an IMS call: service type, call type (voice/video), media profile, extras. CS & IMS Call Flows
IMSI / SUPI / SUCI: Permanent subscriber identity (IMSI; SUPI in 5G) and its concealed 5G form (SUCI). Android Telephony, RIL & Modem
ImsPhone: IMS "shadow" phone owned by GsmCdmaPhone; entry point for IMS calls and silent redial. CS & IMS Call Flows
ImsPhoneCallTracker: IMS call state machine; builds profiles, starts ImsCalls, handles start failures. CS & IMS Call Flows
ImsReasonInfo: Code and extra info explaining why an IMS call failed or ended. CS & IMS Call Flows
ImsResolver: Phone-process component that finds and binds the vendor ImsService for each slot and feature. CS & IMS Call Flows
ImsService: Vendor APK implementing AOSP's IMS API; hosts MmTelFeature and runs or drives the SIP stack. CS & IMS Call Flows
In-batch negatives: Using the other positives in a training batch as negatives for each query, at no extra encoding cost. Retrieval-Augmented Generation (RAG)
In-context learning: A model's ability to perform a task from instructions and examples in the prompt without updating its weights. Prompt Engineering
In-context learning: Performing a new task from instructions or examples in the prompt without updating weights. Transformers & Large Language Models
In-place: An algorithm that uses O(1) (or very little) extra memory beyond the input. Data Structures & Algorithms
InCallService: android.telecom service bound by Telecom to show and control calls; the Dialer's in-call UI implements it. CS & IMS Call Flows
Include guard: #ifndef / #define / #endif wrapper so a header's body is pasted at most once per translation unit. C Language
Independence: Two events or variables where knowing one gives no information about the other: P(A ∩ B) = P(A)P(B). Math & Statistics for ML
Indication: Unsolicited event from a HAL to the framework, e.g. callStateChanged. Binder IPC & AIDL
Indirect prompt injection: Malicious instructions hidden in content the agent reads through tools, such as web pages, emails or documents. Agentic AI & Multi-Agent Systems
Indirect prompt injection: Malicious instructions hidden in content the model reads (documents, web pages, emails) rather than typed by the user. GenAI System Design & Case Studies
Indirect prompt injection: Malicious instructions hidden in content the model reads (web pages, emails, documents, tool results) rather than typed by the user. LLM APIs, Structured Outputs & Tool Calling
Indirect prompt injection: Malicious instructions embedded in third-party content (web pages, documents, emails, tool outputs) that the LLM processes. LLM Evaluation, Safety & Responsible AI
Indirect prompt injection: Malicious instructions hidden in content the model reads (web pages, emails, documents, tool results) rather than typed by the user. Prompt Engineering
Induction head: An attention-head circuit that finds a previous occurrence of the current token and copies what followed it. Transformers & Large Language Models
INetd: AIDL interface to the netd daemon. Android Data Call: Control, netd, eBPF & Packets
InfoNCE: A softmax cross-entropy contrastive loss that makes the positive score beat all negatives. Retrieval-Augmented Generation (RAG)
Information gain: Reduction in entropy achieved by a split. Machine Learning Fundamentals
init: PID 1. Mounts partitions, loads SELinux policy, runs the property service and starts and supervises all native services. Android Boot Process
init_boot: Partition holding the generic ramdisk with first-stage init (devices launching with Android 13+). Android Boot Process
inline: Permission for a definition to appear in multiple translation units; the linker merges them. C++ Language
inode: Filesystem object holding a file's metadata and data location, but not its name. Linux Kernel & BSP
Inode: On-disk (and in-core) index node: owner, mode, timestamps, size, and the map from file offsets to blocks. Names live in directories. Operating System Concepts
InputDispatcher: Native thread in system_server that sends input events to windows and detects input ANRs. Android Frameworks Internals
InputDispatcher: Part of the input system that delivers events to the correct window and detects input ANRs. Trace a Path Through the Android Stack
installd: Privileged native daemon that performs file operations for PMS (create data dirs, dexopt triggers, delete). Android Frameworks Internals
Instruction hierarchy: Training and prompting convention that ranks system over developer over user over tool content when instructions conflict. Prompt Engineering
Instruction tuning: Supervised fine-tuning on diverse instruction–response pairs so a model follows natural-language commands. Fine-Tuning & Alignment
Instruction tuning: Supervised fine-tuning on instruction-response pairs so a model follows requests. Transformers & Large Language Models
Instructor: A library that returns validated Pydantic objects from LLM calls, handling schema generation, parsing and retries. LLM APIs, Structured Outputs & Tool Calling
INT4: 4-bit integer format with 16 levels; used mainly for LLM weights with per-group scales. Edge AI Fundamentals
Integer promotion: Conversion of narrow integer types to int or unsigned int before most arithmetic. C Language
Interface token: Header written first in a call: interface descriptor plus StrictMode and work-source data. Binder IPC & AIDL
Intern pool: The set of canonical String instances returned by literals and String.intern(); on the heap since Java 7. Java Language
Internal fragmentation: Wasted slack inside an allocated block or page because the allocator handed out more than the request needed. Operating System Concepts
Interquartile range (IQR): Q3 − Q1, the spread of the middle half of the data. Math & Statistics for ML
Interrupt: A graph feature that pauses execution before or inside a node and resumes later with supplied input. Agentic AI & Multi-Agent Systems
Interrupt: Asynchronous signal from a device or timer that vectors into the kernel independently of the current instruction. Operating System Concepts
intptr_t: Signed integer type guaranteed to hold a pointer. Pair is uintptr_t. C Language
Inverse document frequency (idf): log(N / df): a weight that is high for rare terms and zero for terms in every document. NLP Fundamentals
Inverted index: A map from each term to the list of documents containing it; the core of lexical search. Retrieval-Augmented Generation (RAG)
Inverted page table: One entry per physical frame, recording which (process, virtual page) owns it. Saves table space; lookup is a search, not an index. Operating System Concepts
IOMMU / SMMU: Translates device DMA addresses and isolates devices from each other's memory. Linux Kernel & BSP
IPA: IP Accelerator; Qualcomm example of hardware data-path offload. Other SoCs have equivalents. Android Data Call: Control, netd, eBPF & Packets
IPA: Qualcomm IP Accelerator: hardware that moves user-plane packets between AP memory and the modem. Android Telephony, RIL & Modem
IPA: IP Accelerator; Qualcomm hardware block that offloads the data path (routing, filtering, NAT, aggregation) from the CPU. Other vendors have equivalent offload engines. Trace a Path Through the Android Stack
IPC: Inter-process communication: pipes, message queues, shared memory, signals, sockets, and platform RPCs such as Binder on Android. Operating System Concepts
IRadio*: Radio HAL interfaces (Network, Data, Voice, Sim, Modem, Messaging, Ims, Config) with Response and Indication partners. Android Telephony, RIL & Modem
IRadioData: Radio HAL interface for data calls: setup, deactivate, profiles, keepalive, slicing helpers. Android Data Call: Control, netd, eBPF & Packets
IRadioVoice: AIDL radio HAL interface for voice requests (dial, accept, hangup, getCurrentCalls, emergencyDial). CS & IMS Call Flows
Iron triangle: The trade-off between scope, schedule and resources, with quality at the centre. Leadership, Delivery & Behavioral
ISIM: IMS Subscriber Identity Module: SIM application holding IMS identities and the home domain. IMS, VoLTE & VoWiFi
Isolation Forest: Anomaly detector that flags points isolated by few random splits. Machine Learning Fundamentals
Iterator: Object implementing __next__ (and __iter__) that yields successive values and raises StopIteration when done. Python & Data Tools for ML
iterator invalidation: Rules describing when a container operation makes existing iterators, pointers or references unusable. C++ Language
IVF (inverted file index): An ANN index that clusters vectors with k-means and searches only the nearest clusters. Retrieval-Augmented Generation (RAG)
IWLAN: Untrusted WLAN access to the packet core via IPsec to an ePDG; still a cellular session. Android Data Call: Control, netd, eBPF & Packets

J

Jacobian: The matrix of first partial derivatives of a vector-valued function. Math & Statistics for ML
Jailbreak: A prompt crafted to make a model bypass its safety training and produce restricted content. LLM Evaluation, Safety & Responsible AI
Jailbreak: A prompt designed to bypass a model's safety training, for example through role-play, encoding, many-shot examples or adversarial suffixes. Prompt Engineering
JEITA: Industry guideline that adjusts charge current and voltage by battery temperature. Power, Thermal & Battery
Jetson: NVIDIA's family of embedded modules combining Arm CPUs, a CUDA GPU with tensor cores and deep-learning accelerators. Edge AI Fundamentals
JIT: Just-in-time compilation of hot bytecode to native code at run time (HotSpot C1/C2; ART JIT). Java Language
Jitter: Randomness added to retry delays so many clients do not retry at the same moment. LLM APIs, Structured Outputs & Tool Calling
Jitter buffer: Receiver buffer that absorbs packet delay variation so voice frames play at a steady cadence. IMS, VoLTE & VoWiFi
JMM: Java Memory Model: the language rules for visibility, atomicity of volatiles, and allowed reorderings. Java Language
JNI: Java Native Interface: the C API that talks to the VM. Java-side details belong on the Java page. C Language
JNI: Java Native Interface: the boundary between ART/Java and C or C++ in the same process. C++ Language
JNI: Java Native Interface: native methods on the Java side and a C API on the other; see C language. Java Language
JNIEnv: Per-thread table of JNI function pointers. Must not be shared across threads. C Language
JobScheduler: Android system service that runs background jobs when constraints are met, batched and Doze-aware. Power, Thermal & Battery
Journaling: Write-ahead logging of filesystem changes so a crash can replay committed metadata (and optionally data) to a consistent state. Operating System Concepts
JSON mode: An API option that guarantees syntactically valid JSON output but not conformance to a particular schema. LLM APIs, Structured Outputs & Tool Calling
JSON Schema: A standard format for describing the structure and types of JSON data, used to define tool parameters and structured outputs. Agentic AI & Multi-Agent Systems
JSON Schema: A standard vocabulary for describing the structure, types and constraints of JSON documents. LLM APIs, Structured Outputs & Tool Calling
Jupyter kernel: The live Python process behind a notebook that keeps state between cell executions. Python & Data Tools for ML
JVM: The virtual machine specified by the Java Virtual Machine Specification; HotSpot is one implementation. Java Language

K

k-means: Clustering that alternates assigning points to the nearest centroid and recomputing centroids. Machine Learning Fundamentals
K-quants: llama.cpp quantization types using super-blocks with quantized sub-block scales, such as Q4_K and Q6_K. Edge AI Fundamentals
KASAN: Kernel Address Sanitizer: detects out-of-bounds and use-after-free accesses. Linux Kernel & BSP
Kernel mode: Privileged CPU mode in which the OS may program devices, change page tables and halt. Entered only through controlled vectors. Operating System Concepts
Kernel trick: Computing dot products in a high-dimensional feature space via a kernel function without explicit mapping. Machine Learning Fundamentals
KeyMint: TEE-backed key management HAL (successor to Keymaster) that binds keys to the verified-boot state. Android Boot Process
Keystone: Qualcomm's name for its program that tracks AOSP upstream releases onto its chipset baselines. Platform Integration & Release
KL divergence: Σp log(p/q): the extra surprise from using q instead of the true p; non-negative and asymmetric. Math & Statistics for ML
KL penalty: Term penalizing divergence of the trained policy from a reference model during preference optimization. Fine-Tuning & Alignment
KL penalty: Term in RLHF that penalises the policy for drifting too far from the reference model. Transformers & Large Language Models
Kleaf: Bazel-based build for the Android kernel / GKI; separate from the halted userspace Bazel migration. Platform Integration & Release
KleidiAI: Arm's library of optimized low-bit matrix-multiply micro-kernels, integrated into XNNPACK and other runtimes. Edge AI Deployment & Projects
KMI: Kernel Module Interface: the stable set of symbols and types GKI vendor modules may use. Linux Kernel & BSP
KMI: Kernel Module Interface; the stable set of kernel symbols vendor modules may use with GKI. Frozen for the life of an ACK branch. Platform Integration & Release
kNN: k-nearest neighbours: predicts from the labels of the k closest training points. Machine Learning Fundamentals
Knowledge conflict: When retrieved context contradicts the model's parametric memory and the model follows its memory. Retrieval-Augmented Generation (RAG)
Knowledge cutoff: The date after which a model has no training data. Retrieval-Augmented Generation (RAG)
Knowledge graph: A network of entities and typed relationships that supports structured queries and explainable reasoning. GenAI System Design & Case Studies
Krippendorff's alpha: Agreement coefficient supporting many raters, missing data and ordinal or interval scales. LLM Evaluation, Safety & Responsible AI
KTO: Preference method learning from unpaired examples labelled desirable or undesirable. Fine-Tuning & Alignment
Kurtosis: A measure of tail heaviness; the normal distribution has kurtosis 3 (excess kurtosis 0). Math & Statistics for ML
KV cache: Stored key and value vectors for all previous tokens in every layer, so attention does not recompute them each step. Edge AI Deployment & Projects
KV cache: Stored keys and values of previous tokens so an LLM does not recompute them at each step. Edge AI Fundamentals
KV cache: Stored attention keys and values for previous tokens, reused at each decode step. It grows with sequence length and batch size. GenAI System Design & Case Studies
KV cache: Stored attention keys and values for already-processed tokens, reused to avoid recomputation; the basis of prompt caching. LLM APIs, Structured Outputs & Tool Calling
KV cache: Stored keys and values of previous tokens, reused at each decoding step to avoid recomputation. Transformers & Large Language Models

L

L1 regularization (Lasso): Penalty on the sum of absolute weights; produces sparse models. Machine Learning Fundamentals
L2 regularization (Ridge): Penalty on the sum of squared weights; shrinks all weights smoothly. Machine Learning Fundamentals
Label smoothing: Training toward softened targets y' = (1 − ε)y + ε/K instead of a hard one-hot, to reduce over-confidence. Deep Learning & Neural Networks
lambda: An anonymous function object generated by the compiler, optionally capturing enclosing variables. C++ Language
LangGraph: A library for building stateful, cyclic agent graphs with typed state, nodes, edges, checkpointing and interrupts. Agentic AI & Multi-Agent Systems
Language model: A model that assigns probabilities to token sequences, usually by predicting the next token. NLP Fundamentals
Late interaction: Scoring that encodes query and document separately at token level and interacts only at scoring time. Retrieval-Augmented Generation (RAG)
Launch mode: Manifest (or Intent-flag) rule for whether ATMS creates a new activity instance and which task it joins. Android Frameworks Internals
launder: std::launder: obtain a pointer the compiler must treat as referring to a new object in reused storage. C++ Language
Law of large numbers: Sample averages converge to the expected value as the sample size grows. Math & Statistics for ML
Layer normalization: Normalizes across the features of each example independently of the batch. Deep Learning & Neural Networks
Layer normalization: Normalising each token's features to zero mean and unit variance, then applying learned scale and shift. Transformers & Large Language Models
Lazy HAL: HAL service started on first lookup and allowed to exit when unused. Binder IPC & AIDL
LBO: Local breakout IMS roaming: visited P-GW and P-CSCF, with IBCF interconnect to the home S-CSCF. Specified, not the usual live model. IMS, VoLTE & VoWiFi
LDA: Latent Dirichlet Allocation: a generative topic model treating documents as mixtures of topics and topics as distributions over words. NLP Fundamentals
Leader-follower replication: Writes go to one leader that streams changes to read-only followers. System Design
Learning rate: Step size multiplying the gradient in each parameter update. Deep Learning & Neural Networks
Learning rate: Step size of each gradient update, or shrinkage of each boosting tree. Machine Learning Fundamentals
Learning rate: The step-size multiplier in gradient descent. Math & Statistics for ML
Least privilege: Giving each user, agent or tool only the minimum permissions its task requires. GenAI System Design & Case Studies
Least-to-most prompting: Decomposing a problem into sub-questions ordered from easiest to hardest and solving them sequentially, reusing earlier answers. Prompt Engineering
Lemmatization: Reducing a word to its dictionary form using vocabulary and part of speech. NLP Fundamentals
Levenshtein distance: Minimum number of single-character insertions, deletions and substitutions to transform one string into another. LLM Evaluation, Safety & Responsible AI
libc++: LLVM C++ standard library; the STL used by the Android NDK. C++ Language
LightGBM: Fast gradient-boosting library using histograms and leaf-wise tree growth. Machine Learning Fundamentals
Likelihood: P(data | parameters) viewed as a function of the parameters. Math & Statistics for ML
LIME: Local explanation method fitting a simple surrogate model around one prediction. Machine Learning Fundamentals
Linearizability: Strongest single-object consistency: operations appear instantaneous and in real-time order. System Design
Linkage: Whether two declarations of the same name denote the same object or function (external, internal, or none). C Language
linkToDeath: Registers for notification when the process hosting a Binder dies. Binder IPC & AIDL
LiteRT: Google's on-device runtime, formerly TensorFlow Lite, executing .tflite models with CPU, GPU and NPU accelerators. Edge AI Deployment & Projects
LiteRT: Google's on-device runtime, formerly TensorFlow Lite, using .tflite models. Edge AI Fundamentals
LiteRT for Microcontrollers: The MCU variant of LiteRT (formerly TFLite Micro), running models from a fixed memory arena without an OS. Edge AI Fundamentals
Little's law: Average concurrency equals arrival rate multiplied by average time in the system. GenAI System Design & Case Studies
Livelock: Processes keep changing state in response to each other but never make useful progress (the polite-doorway problem). Operating System Concepts
LK: Little Kernel. A small embedded OS used as the base of older Qualcomm (aboot) and MediaTek bootloaders. Android Boot Process
Llama Guard-style classifier: An LLM fine-tuned to classify prompts or responses as safe or unsafe against a harm taxonomy. LLM Evaluation, Safety & Responsible AI
llama.cpp: A C/C++ LLM inference engine with optimized CPU kernels and GPU backends, using the GGUF format. Edge AI Deployment & Projects
llama.cpp: An open-source C/C++ engine for running quantized LLMs on CPUs and GPUs of laptops and phones. Edge AI Fundamentals
LLM-as-a-judge: Using a language model to grade outputs against defined criteria. LLM Evaluation, Safety & Responsible AI
LLM-as-judge: Using a strong language model with a rubric to rate or compare outputs. Fine-Tuning & Alignment
LLM-as-judge: Using a strong model with a rubric to grade outputs. It must be calibrated against human labels. GenAI System Design & Case Studies
LLM-as-judge: Using a language model with a rubric to grade or compare outputs; requires calibration and bias controls. Prompt Engineering
LLMLingua: Prompt-compression framework that uses a small model to drop low-information tokens under a budget; LLMLingua-2 uses a learned token classifier. Prompt Engineering
LLMOps: Practices for versioning, evaluating, deploying, monitoring and improving LLM applications. GenAI System Design & Case Studies
LLMOps: Operational practices for deploying, versioning, monitoring and improving LLM applications. LLM Evaluation, Safety & Responsible AI
lmkd: Low Memory Killer Daemon; userspace process that kills apps under memory pressure using PSI signals. Android Frameworks Internals
lmkd: Android's userspace low-memory killer daemon, which kills processes by priority when memory pressure is high. Edge AI Deployment & Projects
LMKD: Low Memory Killer Daemon: Android userspace process killer driven by PSI and oom_score_adj. Linux Kernel & BSP
Load balancer: Component that distributes requests across healthy servers. System Design
Load factor: Number of entries divided by number of buckets; triggers resizing when too high. Data Structures & Algorithms
loc: pandas label-based indexer that also accepts boolean masks; slice ends are inclusive. Python & Data Tools for ML
lockdep: Kernel lock validator that detects lock-order problems and misuse. Linux Kernel & BSP
Log-sum-exp trick: Computing log Σe^x_i as m + log Σe^x_i−m with m = max x to avoid overflow. Math & Statistics for ML
Logical address: The address the program issues (virtual address). The MMU translates it to a physical address or a fault. Operating System Concepts
Logistic regression: Linear classifier that maps a weighted sum through a sigmoid to a probability. Machine Learning Fundamentals
Logit: The raw, unnormalized score a model assigns to each vocabulary token before softmax. LLM APIs, Structured Outputs & Tool Calling
Logit: A raw, unnormalized model score that softmax or sigmoid turns into a probability; also log(p/(1 − p)). Math & Statistics for ML
logit_bias: An API parameter that adds a fixed bias to the logits of specified token IDs to encourage or ban them. LLM APIs, Structured Outputs & Tool Calling
Logits: Raw, unnormalized scores output by a model before sigmoid or softmax. Deep Learning & Neural Networks
Logits: Raw, unnormalised model outputs before softmax or sigmoid. Python & Data Tools for ML
Logits: Raw, unnormalised scores for every vocabulary token before softmax. Transformers & Large Language Models
LogitsProcessor: A Hugging Face Transformers hook that modifies the score tensor at each generation step, used for custom constraints. LLM APIs, Structured Outputs & Tool Calling
logprobs: Log-probabilities of generated tokens (and optionally top alternatives) returned by the API, usable as confidence scores. LLM APIs, Structured Outputs & Tool Calling
Logprobs: Log-probabilities of generated tokens (and optional alternatives) returned by some APIs; usable as a raw confidence signal after calibration. Prompt Engineering
Long-term memory: Information persisted across sessions, typically in a vector or key-value store, and retrieved when relevant. Agentic AI & Multi-Agent Systems
Looper: Per-thread loop that takes Messages from a MessageQueue and dispatches them. Android Frameworks Internals
LoRA: Low-rank adaptation: fine-tuning with small low-rank update matrices while freezing the base model. Edge AI Fundamentals
LoRA: Low-Rank Adaptation: trains a low-rank update BA added to frozen weight matrices. Fine-Tuning & Alignment
LoRA: Low-rank adaptation: fine-tuning small adapter matrices instead of all weights, so many task adapters can share one base model. GenAI System Design & Case Studies
LoRA adapter: A small set of low-rank weight updates that specialise a shared base model for a task and can be swapped at runtime. Edge AI Deployment & Projects
Loss masking: Excluding tokens from the loss, typically by setting their labels to -100. Fine-Tuning & Alignment
Lost in the middle: The tendency of models to use information at the start or end of a long context more reliably than information in the middle. Prompt Engineering
Lost in the middle: The tendency of LLMs to use information at the start and end of a long context better than in the middle. Retrieval-Augmented Generation (RAG)
Lost in the middle: Tendency of models to use information at the start and end of a long context more reliably than information in the middle. Transformers & Large Language Models
Low Power Standby: Android 13+ deeper idle after a long unused period, with tighter restrictions than ordinary deep Doze. Power, Thermal & Battery
LPA: Local Profile Assistant: on-device component that downloads and manages eSIM profiles. Android Telephony, RIL & Modem
LPA: Local Profile Assistant: on-device software that downloads and manages eSIM profiles. Wear OS Platform
LRF: Location Retrieval Function: provides location and PSAP routing for emergency calls. IMS, VoLTE & VoWiFi
LRU: Least recently used page replacement. A good stand-in for OPT; exact LRU on every reference is expensive, so hardware uses a referenced bit and Clock. Operating System Concepts
LSan: LeakSanitizer: reports heap that is not freed at process exit (often bundled with ASan). C Language
LSM tree: Log-structured merge tree: write-optimised storage that flushes sorted files and compacts them in the background. System Design
LSTM: Long short-term memory: an RNN cell with forget, input and output gates and a cell state. Deep Learning & Neural Networks
LSTM: Long short-term memory: a recurrent cell with forget, input and output gates and an additive cell state that preserves long-range information. NLP Fundamentals
lunch: The AOSP command that selects a product, release configuration and build variant before compiling. Platform Integration & Release
lvalue: An expression that designates an object (something that can appear on the left of assignment, roughly). C Language
lvalue: Expression with identity that is not expiring; you can take its address. C++ Language

M

MAC: Multiply-accumulate operation, the basic building block of neural network maths. Edge AI Fundamentals
MADA: Mobile Application Distribution Agreement; the commercial contract under which an OEM may preload GMS. Platform Integration & Release
MAE: Mean absolute error; average absolute difference between prediction and truth. Machine Learning Fundamentals
Maintenance window: Short period during Doze when deferred work is allowed to run. Power, Thermal & Battery
make_shared: Factory that typically allocates the object and the shared_ptr control block together. C++ Language
malloc: Uninitialised heap allocation aligned for any standard type. Pair with free. C Language
Managing up: Working effectively with your manager and leadership: aligning on goals, sharing risks early, agreeing decision rights. Leadership, Delivery & Behavioral
Many-shot jailbreaking: Filling a long context with many fake dialogues in which an assistant complies with harmful requests, to override safety behaviour. Prompt Engineering
MAP estimation: Choosing parameters that maximize likelihood times prior; equivalent to regularized MLE. Math & Statistics for ML
Map-reduce summarisation: Summarising chunks in parallel (map) and then merging the partial summaries (reduce). GenAI System Design & Case Studies
Marginal probability: The probability of one variable obtained by summing (or integrating) a joint distribution over the others. Math & Statistics for ML
Mask ROM: Read-only memory whose content is fixed during chip manufacture; holds the PBL. Android Boot Process
Masked language modelling (MLM): Pretraining objective of predicting randomly masked tokens using context on both sides. Transformers & Large Language Models
Massive MIMO: Antenna arrays with many elements for beamforming and multi-user spatial multiplexing. 5G NR & 5G Core
Matrix factorization: Decomposing a user×item matrix into latent user and item vectors. Machine Learning Fundamentals
Matryoshka embeddings (MRL): Embeddings trained so that their leading dimensions form usable shorter embeddings. Retrieval-Augmented Generation (RAG)
max_tokens: The cap on the number of tokens the model may generate in one response. Some APIs use max_completion_tokens or max_output_tokens instead; check current docs. LLM APIs, Structured Outputs & Tool Calling
Maximum likelihood (MLE): Choosing parameters that make the observed data most probable. Math & Statistics for ML
MaxSim: ColBERT's operator: for each query token take the maximum similarity to any document token, then sum. Retrieval-Augmented Generation (RAG)
MCG / SCG: Master Cell Group and Secondary Cell Group in dual connectivity. 5G NR & 5G Core
McNemar's test: Statistical test for paired binary outcomes, using only items where two systems disagree. LLM Evaluation, Safety & Responsible AI
MCP (Model Context Protocol): An open JSON-RPC-based standard (introduced by Anthropic in 2024, now Linux Foundation) connecting AI applications to external tools, data resources and prompt templates. Agentic AI & Multi-Agent Systems
MCP host, client and server: The host is the AI application; each client inside it holds a session with one server; servers expose tools, resources and prompts. Agentic AI & Multi-Agent Systems
MeasureClient: Health Services API for short, foreground spot measurements. Wear OS Platform
Median: The middle value of sorted data; the 0.5 quantile. Math & Statistics for ML
MediaPipe: Google's framework of ready-made on-device ML pipelines built on LiteRT. Edge AI Fundamentals
melt: pandas operation that reshapes a wide table into a long one. Python & Data Tools for ML
Membership inference: Attack that determines whether a specific record was part of a model's training data. LLM Evaluation, Safety & Responsible AI
memcpy: Copy n bytes between non-overlapping (restrict) buffers. Overlap is UB. C Language
memmove: Copy n bytes; overlap is allowed. C Language
Memoisation: Caching the results of a recursive function so each input is computed once (top-down DP). Data Structures & Algorithms
Memory bandwidth: Bytes per second that can move between DRAM and compute units; the main limit for memory-bound layers. Edge AI Fundamentals
Memory mapping (mmap): Mapping a file into the address space so pages load lazily and can be reclaimed by the kernel, avoiding a full copy into the heap. Edge AI Deployment & Projects
Memory poisoning: An attack or error in which false or malicious content is written into agent memory and trusted later. Agentic AI & Multi-Agent Systems
memory_order: C11 atomic constraint: relaxed, acquire, release, acq_rel, seq_cst — how much reordering is forbidden. C Language
memory_order: Atomic constraint on visibility and ordering: relaxed, acquire, release, acq_rel, seq_cst. C++ Language
Merge: Joining two branches' histories with a merge commit. Platform Integration & Release
merge: pandas SQL-style join of two DataFrames on key columns. Python & Data Tools for ML
Merge and unload: Folding a LoRA update into the base weights and removing the adapter modules. Fine-Tuning & Alignment
MessageClient: Data Layer API for fire-and-forget messages to a connected node. Wear OS Platform
MessageQueue: Time-ordered list of Messages for one Looper, with native blocking via epoll. Android Frameworks Internals
Messenger: Handler-backed Binder wrapper: clients send Message objects; all calls run on one thread. Binder IPC & AIDL
Meta build: A versioned bundle pinning one tested build of every HLOS and non-HLOS component. Platform Integration & Release
Meta prompting: Prompting with an abstract, structure-oriented solution template, or asking a model to write and improve prompts. Prompt Engineering
Meta-planner: A supervisor agent whose actions are delegations to other agents rather than direct tool calls. Agentic AI & Multi-Agent Systems
Metadata filtering: Restricting retrieval to chunks whose attributes (tenant, date, type, permissions) satisfy a predicate. Retrieval-Augmented Generation (RAG)
Metaspace: Native memory where HotSpot stores class metadata after the removal of PermGen in Java 8. Java Language
METEOR: Translation metric using exact, stem and synonym matching with recall weighting and a fragmentation penalty. LLM Evaluation, Safety & Responsible AI
METEOR: A generation metric that aligns words by exact match, stem and synonym, weights recall over precision and penalizes fragmented order. NLP Fundamentals
MGCF: Media Gateway Control Function: converts SIP to ISUP/BICC and controls the IMS-MGW. IMS, VoLTE & VoWiFi
MHI: Modem Host Interface: Qualcomm protocol for talking to a modem over PCIe. Android Telephony, RIL & Modem
Min-p sampling: Truncation that keeps tokens whose probability is at least a fraction of the most likely token's probability. Transformers & Large Language Models
MIPC: MediaTek's structured IPC protocol between the RIL daemon and the modem. Android Telephony, RIL & Modem
Mixed precision: Training with 16-bit arithmetic for speed and memory while keeping sensitive parts in FP32. Deep Learning & Neural Networks
Mixed precision: Using different numeric precisions for different layers, typically keeping sensitive layers at higher precision. Edge AI Deployment & Projects
Mixed precision: Using different numeric formats for different layers, for example INT8 for most and FP16 for sensitive ones. Edge AI Fundamentals
Mixed precision: Computing in 16-bit while keeping an fp32 master copy of weights for the optimizer. Fine-Tuning & Alignment
Mixture of experts (MoE): An architecture that activates a subset of expert sub-networks per token. Memory scales with total parameters and compute with active parameters. GenAI System Design & Case Studies
Mixture of Experts (MoE): Architecture where a router sends each token to a few of many expert FFNs, decoupling total and active parameters. Transformers & Large Language Models
MLA (Multi-head Latent Attention): Attention variant that caches a compressed latent per token from which keys and values are reconstructed. Transformers & Large Language Models
MLC-LLM: A compiler-based LLM deployment stack built on TVM, targeting mobile GPUs and other backends. Edge AI Fundamentals
MLFQ: Multilevel feedback queue: several priority queues; jobs that burn their quantum are demoted so interactive work stays responsive. Operating System Concepts
MLP: Multi-layer perceptron: stacked fully connected layers with non-linear activations. Deep Learning & Neural Networks
mmap: Syscall that maps a file or anonymous pages into the address space. Accesses fault pages in; shared maps are also IPC. Operating System Concepts
MMR (maximal marginal relevance): A selection rule balancing relevance to the query against redundancy with already-selected results. Retrieval-Augmented Generation (RAG)
MMTel: Multimedia Telephony: the IMS voice and video service with its supplementary services. IMS, VoLTE & VoWiFi
MmTelFeature: ImsService feature for multimedia telephony: creates call sessions, reports capabilities, notifies incoming calls. CS & IMS Call Flows
MMU: Memory Management Unit: hardware that translates virtual to physical addresses. Linux Kernel & BSP
MO / MT: Mobile-originated (outgoing) and mobile-terminated (incoming) calls. CS & IMS Call Flows
Mode collapse: GAN failure where the generator produces only a few kinds of outputs. Deep Learning & Neural Networks
Mode collapse: Loss of output diversity where the model keeps producing the same few high-probability responses despite many valid alternatives. Prompt Engineering
Model card: Document describing a model's intended use, data, evaluation results, limitations and ethical considerations. LLM Evaluation, Safety & Responsible AI
Model Context Protocol (MCP): An open protocol for exposing tools, resources and prompts from servers to LLM applications in a standard way. LLM APIs, Structured Outputs & Tool Calling
Model extraction: Attack that replicates a model's functionality by querying it and training a substitute. LLM Evaluation, Safety & Responsible AI
Model gateway: An internal proxy that gives applications one interface to many models, with routing, failover, caching and metering. GenAI System Design & Case Studies
Model merging: Combining weights of several fine-tuned models that share a base, without further training. Fine-Tuning & Alignment
Moderation model: Classifier that scores text for categories of harmful content. LLM Evaluation, Safety & Responsible AI
Momentum: Optimizer technique that accumulates a moving average of gradients to accelerate and smooth updates. Deep Learning & Neural Networks
Momentum: An optimizer technique that accumulates an exponentially weighted sum of past gradients to smooth and accelerate updates. Math & Statistics for ML
Monitor: The intrinsic lock associated with every Java object; used by synchronized, wait and notify. Java Language
Monitor: Language-level construct: encapsulated data plus an implicit mutex and condition variables (Java synchronized is the usual example). Operating System Concepts
Monotonic stack: A stack kept in increasing or decreasing order, used for next-greater or next-smaller queries. Data Structures & Algorithms
MOS: Mean Opinion Score: 1-to-5 listening-quality rating, often predicted from the E-model (ITU-T G.107). IMS, VoLTE & VoWiFi
MoSCoW: Prioritization into Must have, Should have, Could have and Won't have (this time). Leadership, Delivery & Behavioral
MPSS: Modem Processor Subsystem; the modem's firmware and processor. Platform Integration & Release
MQA (Multi-Query Attention): Attention variant in which all query heads share a single key and value head. Transformers & Large Language Models
MRF: Media Resource Function: announcements, tones, conference mixing and transcoding. IMS, VoLTE & VoWiFi
MRO: Method resolution order: the sequence Python searches through base classes to find a method. Python & Data Tools for ML
MRR (mean reciprocal rank): The average over queries of 1 divided by the rank of the first relevant result. Retrieval-Augmented Generation (RAG)
MSE / RMSE: Mean squared error and its square root; penalise large errors heavily. Machine Learning Fundamentals
MSRP: Message Session Relay Protocol: carries RCS chat and file content in sessions set up by SIP. IMS, VoLTE & VoWiFi
MSS: Maximum Segment Size; TCP payload per segment, derived from MTU minus headers. Android Data Call: Control, netd, eBPF & Packets
MTTR: Mean Time To Resolve (or Repair); average time from report to fix. Platform Integration & Release
MTU: Maximum Transmission Unit; largest IP packet the path claims to carry. Android Data Call: Control, netd, eBPF & Packets
MTU: Maximum Transmission Unit: largest IP packet size on a link; provided by the network for cellular. Android Telephony, RIL & Modem
Multi-agent system: An architecture in which several specialized agents collaborate through messages or shared state. Agentic AI & Multi-Agent Systems
Multi-head attention: Several attention operations in parallel with separate projections, concatenated and projected by W_O. Transformers & Large Language Models
Multi-LoRA serving: Serving many LoRA adapters over one shared base model, batching requests for different adapters together. Fine-Tuning & Alignment
Multi-query retrieval: Generating several reformulations of a question, retrieving for each and fusing the results; also called RAG-Fusion. Retrieval-Augmented Generation (RAG)
Multimodal prompting: Writing instructions that steer a model over image, audio or document parts as well as text, including what to look at and how to report it. Prompt Engineering
Multiplier: A leader whose impact is measured by what the team can deliver without them, not by how many tickets they personally close. Leadership, Delivery & Behavioral
Mutable: Able to be changed in place after creation (lists, dicts, sets, arrays). Python & Data Tools for ML
Mutex: Mutual-exclusion lock with ownership. Lock/unlock a critical section. Contrast a semaphore, which has no owner. Operating System Concepts
Mutual exclusion: At most one thread is in the critical section (or holds the exclusive resource) at a time. Also a Coffman condition. Operating System Concepts
Mutual information: How much knowing one variable reduces uncertainty about another; zero only under independence. Math & Statistics for ML

N

n-gram: A sequence of n consecutive tokens or characters. NLP Fundamentals
N16: Interface between V-SMF and H-SMF for home-routed roaming session control. 5G NR & 5G Core
N26: Interface between AMF and MME for seamless 5GS and EPS interworking. 5G NR & 5G Core
N3IWF: Non-3GPP Interworking Function: 5G equivalent of the ePDG. IMS, VoLTE & VoWiFi
N:M sparsity: A structured sparsity pattern with N zeros in every M consecutive weights (for example 2:4) that hardware can accelerate. Edge AI Fundamentals
Naive Bayes: Probabilistic classifier assuming features are independent given the class. Machine Learning Fundamentals
name mangling: Encoding of C++ function types into linker symbol names so overloads can coexist. C++ Language
Named entity recognition (NER): Finding spans that name people, organizations, locations, dates and domain-specific entities, and labelling their types. NLP Fundamentals
Namespace: Linux isolation of a name table (PID, mount, network, …) so a process tree sees its own view. A container building block. Operating System Concepts
NAPI: New API; kernel polling of a nic under load so the CPU is not hardirq-per-packet. Android Data Call: Control, netd, eBPF & Packets
NAS: Non-Access Stratum: signalling between UE and core network, carried transparently by the radio. Android Telephony, RIL & Modem
NAS: Neural architecture search: automated search for architectures, often scored by measured latency on the target device. Edge AI Fundamentals
NAT64 / PLAT: Provider-side translator from IPv6 to IPv4; the network half of 464XLAT. Android Data Call: Control, netd, eBPF & Packets
ndarray: NumPy's n-dimensional, homogeneous, typed array. Python & Data Tools for ML
ndc: Legacy netd command-line/text protocol; remnant beside INetd. Android Data Call: Control, netd, eBPF & Packets
nDCG: Normalised discounted cumulative gain: a ranking metric rewarding highly relevant items near the top, normalised by the ideal ordering. Retrieval-Augmented Generation (RAG)
NDK: Native Development Kit: Clang, bionic sysroot and build support for Android native code. C Language
NDK: Native Development Kit: Clang toolchain and headers for shipping C/C++ in Android apps and some system modules. C++ Language
NEF: Network Exposure Function; exposes network capabilities to external applications. 5G NR & 5G Core
Negative sampling: Training embeddings by distinguishing real context words from a few randomly sampled words instead of computing a full softmax. NLP Fundamentals
Nested cross-validation: Inner CV tunes hyperparameters, outer CV estimates performance of the whole procedure. Machine Learning Fundamentals
netd: Native daemon that programs interfaces, policy routing, firewall/eBPF and related kernel state. Android Data Call: Control, netd, eBPF & Packets
netd: Android's native network daemon. It applies interface, routing, DNS, firewall and eBPF configuration on behalf of ConnectivityService. Trace a Path Through the Android Stack
NetworkAgent: Producer of a Network (telephony, Wi-Fi, VPN, Ethernet) into ConnectivityService. Android Data Call: Control, netd, eBPF & Packets
NetworkRequest: App or system request for a Network matching a capability filter. Android Data Call: Control, netd, eBPF & Packets
NF4: 4-bit NormalFloat: a non-uniform 4-bit format whose levels follow a normal distribution; used by QLoRA. Edge AI Fundamentals
NF4: 4-bit NormalFloat: a 16-level code at normal-distribution quantiles, used for storing QLoRA base weights. Fine-Tuning & Alignment
NGAP: NG Application Protocol used on N2 between gNB and AMF. 5G NR & 5G Core
NIST AI RMF: Voluntary AI risk management framework built on the functions Govern, Map, Measure and Manage. LLM Evaluation, Safety & Responsible AI
NITZ: Network Identity and Time Zone: time, zone and network name sent by the network. Android Telephony, RIL & Modem
NLI scorer: Natural language inference model used to judge whether an output is entailed by, neutral to, or contradicts a reference. LLM Evaluation, Safety & Responsible AI
nlist: The number of clusters in an IVF index. Retrieval-Augmented Generation (RAG)
nn.Module: Base class for PyTorch layers and models, which registers parameters and submodules and defines forward. Python & Data Tools for ML
NNAPI: Android Neural Networks API, the older accelerator abstraction, deprecated from Android 15 in favour of vendor delegates and backends. Edge AI Deployment & Projects
NNAPI: Android Neural Networks API, a vendor-neutral accelerator interface, deprecated from Android 15. Edge AI Fundamentals
no_grad: PyTorch context that disables gradient tracking, used for inference and manual weight updates. Python & Data Tools for ML
Node: A unit of work in a graph that receives state and returns a partial state update. Agentic AI & Multi-Agent Systems
Node: Driver object representing a Binder service in its owning process. Binder IPC & AIDL
Node: A device (phone, watch, or cloud) participating in the Wearable Data Layer network. Wear OS Platform
noexcept: Specifies that a function does not throw; enables optimizations such as moving on vector reallocation. C++ Language
Non-HLOS: Firmware and RTOS images for processors other than the application processor. Platform Integration & Release
Norm: A measure of vector length, e.g. L1 (sum of absolute values) or L2 (Euclidean length). Math & Statistics for ML
Normalisation (L2): Scaling a vector to unit length so dot product equals cosine similarity. Retrieval-Augmented Generation (RAG)
Normalization: Making text consistent: Unicode forms, casing, whitespace, markup removal, spelling variants. NLP Fundamentals
nprobe: The number of IVF clusters searched per query; the IVF recall versus latency dial. Retrieval-Augmented Generation (RAG)
NPU: Neural processing unit: a dedicated accelerator for low-precision tensor maths with high performance per watt. Edge AI Fundamentals
NRF: NF Repository Function; registry and discovery service for network functions. 5G NR & 5G Core
NRVO: Named return value optimization: optionally constructing a named local directly in the caller’s return slot. C++ Language
NSA: Non-Standalone; NR added to an LTE anchor on the EPC. 5G NR & 5G Core
NSSAI: List of S-NSSAIs; configured, requested, allowed or rejected. 5G NR & 5G Core
NSSF: Network Slice Selection Function. 5G NR & 5G Core
Null hypothesis: The default claim of no effect or no difference that a test tries to reject. Math & Statistics for ML
Numerology: The parameter µ that sets subcarrier spacing and slot length. 5G NR & 5G Core
NV / EFS: Modem non-volatile items and embedded file system for calibration, IMEI and configuration. Android Telephony, RIL & Modem

O

oat / odex: ART's compiled native code and metadata produced by dex2oat from dex. Java Language
Object file: Compiler output (.o) containing machine code, data and relocation records, not yet linked. C Language
Observation: The result returned by the environment after an action, appended to the agent's context to ground the next step. Agentic AI & Multi-Agent Systems
OCR: Optical character recognition: extracting text from images of text such as scans. Retrieval-Augmented Generation (RAG)
ODM: Original Design Manufacturer; typically owns the board, RF and factory image, sometimes a thin software overlay. Platform Integration & Release
ODPM: On-Device Power Monitor: hardware energy counters for power rails, readable via Perfetto on supported devices. Edge AI Deployment & Projects
ODPM: On-device power monitor: hardware that measures energy per power rail, exposed through the Power Stats HAL. Power, Thermal & Battery
ODR: One Definition Rule: one definition per entity in the program, except identical inline/template definitions. C++ Language
OEM: Original Equipment Manufacturer; owns the brand, product software, GMS path, carrier SKUs and OTAs. Platform Integration & Release
OKR: Objectives and key results: a goal-setting method pairing a qualitative objective with measurable results. Leadership, Delivery & Behavioral
Ollama: A local model runner that downloads quantized open models and serves them through a REST API. LLM APIs, Structured Outputs & Tool Calling
One-hot encoding: Representing a category as a binary vector with a single 1. Machine Learning Fundamentals
One-hot encoding: Representing a category as a vector with a single 1 in the column for that category. Python & Data Tools for ML
One-hot vector: A vector as long as the vocabulary with a single 1 at the word's index. NLP Fundamentals
oneway: AIDL keyword for asynchronous calls without a reply. Binder IPC & AIDL
Ongoing Activity: API that shows a running task such as a workout on the face and launcher so the user can return to it. Wear OS Platform
Online evaluation: Measuring system quality on live production traffic. LLM Evaluation, Safety & Responsible AI
ONNX: Open Neural Network Exchange: an open model format used to move models between frameworks and runtimes. Edge AI Fundamentals
ONNX Runtime: A cross-platform inference engine for ONNX models with pluggable execution providers. Edge AI Fundamentals
onTransact: Stub method that decodes an incoming transaction and dispatches it to the implementation. Binder IPC & AIDL
oom_score_adj: Per-process value (-1000 to 1000) in /proc/<pid>/ set by AMS; higher means killed sooner. Android Frameworks Internals
Oops / panic: Kernel error that kills the current task / fatal error that halts or reboots the system. Linux Kernel & BSP
Open addressing: Collision strategy that stores all entries in the table itself and probes for another free slot. Data Structures & Algorithms
Open weights: Model parameters released for download and self-hosting, possibly under licence restrictions and without training data. Transformers & Large Language Models
OpenAI-compatible API: An endpoint that accepts the Chat Completions request format, letting the same client code target different providers or local servers. LLM APIs, Structured Outputs & Tool Calling
Operator fusion: Merging several consecutive operations into one kernel to cut memory traffic and launch overhead. Edge AI Fundamentals
OPP: Operating performance point: a legal frequency and voltage pair for a CPU or GPU cluster. Power, Thermal & Battery
Opportunity cost: The value of the best alternative you give up when you choose to do something. Leadership, Delivery & Behavioral
OPRO: Optimization by prompting: an optimizer LLM reads previous prompts with their scores and proposes better ones. Prompt Engineering
Optimal substructure: Property that an optimal solution is composed of optimal solutions to subproblems. Data Structures & Algorithms
Optional: A container for a value that may be absent; intended as a method return type, not a field or parameter. Java Language
Oracle context: An evaluation setting that gives the generator the gold evidence directly, isolating generation quality. Retrieval-Augmented Generation (RAG)
Orchestrator: Application logic that builds prompts, calls retrieval and tools, runs agent loops and enforces budgets. GenAI System Design & Case Studies
Orchestrator-workers: A pattern where a central LLM decides sub-tasks at run time, delegates them to workers and synthesizes results. Agentic AI & Multi-Agent Systems
Orphan: A live process whose parent has exited. The OS reparents it (classically to init) so someone can wait and reap it. Operating System Concepts
ORPO: Odds Ratio Preference Optimization: single-stage SFT plus odds-ratio preference loss, with no reference model. Fine-Tuning & Alignment
Orthogonal matrix: A square matrix with orthonormal columns (Q^TQ = I); preserves lengths and angles. Math & Statistics for ML
Out-of-bag (OOB): Rows not drawn in a tree's bootstrap sample, usable as free validation data. Machine Learning Fundamentals
Out-of-vocabulary (OOV): A word not present in the model's vocabulary. NLP Fundamentals
Outbox pattern: Writing events to a table in the same transaction as business data, then publishing them reliably. System Design
Output indicator: Text at the end of a prompt, such as "Answer:" or "SQL:", that cues where and in what form the answer should start. Prompt Engineering
Over-refusal: Refusing benign requests because they superficially resemble harmful ones. LLM Evaluation, Safety & Responsible AI
Overfitting: Fitting training data (including noise) so closely that performance on new data suffers. Deep Learning & Neural Networks
Overfitting: Learning noise in the training data, leading to poor performance on new data. Machine Learning Fundamentals
Overlapping subproblems: Property that the same subproblems recur many times in a naive recursion. Data Structures & Algorithms
override: Specifier that a virtual function must override a base; mismatch is a compile error. C++ Language
OWASP LLM Top 10: Community list of the most critical security risks for LLM applications. Interviews usually expect the 2025 edition (prompt injection through unbounded consumption). LLM Evaluation, Safety & Responsible AI

P

P-CSCF: Proxy Call Session Control Function: the IMS entry point, learned via PCO or DHCP. Android Telephony, RIL & Modem
P-CSCF: Proxy CSCF: the UE's first and only SIP contact point in IMS. IMS, VoLTE & VoWiFi
P-GW: PDN Gateway; LTE user-plane anchor and often NAT to the Internet. Android Data Call: Control, netd, eBPF & Packets
p-value: The probability, assuming the null hypothesis, of a result at least as extreme as the one observed. Math & Statistics for ML
PACELC: Extension of CAP: under partition choose availability or consistency, else choose latency or consistency. System Design
Packing: Concatenating multiple short examples into one training sequence to reduce padding. Fine-Tuning & Alignment
Padding: Unused bytes inserted so members and the whole struct meet alignment. Contents are not meaningful. C Language
Padding: Adding border values (usually zeros) around an input so convolutions can cover edges and control output size. Deep Learning & Neural Networks
Page fault: Exception raised when a virtual address has no valid translation or wrong permissions. Linux Kernel & BSP
Page fault: The CPU trapped on a translation: not present, permission, or bad address. Legal not-present faults implement demand paging and COW. Operating System Concepts
Page table: Kernel-owned map from virtual page numbers to physical frames and permissions, usually a multi-level radix tree. Operating System Concepts
Paged attention: Storing the KV cache in fixed-size blocks mapped by a block table, so waste is at most one block per sequence and prefixes can be shared. Edge AI Fundamentals
Paged attention: Managing the KV cache in fixed-size blocks, like virtual memory pages, to avoid fragmentation and share prefixes. Waste is at most one block per sequence. GenAI System Design & Case Studies
Paged KV cache: A KV cache stored in fixed-size blocks mapped by a block table, avoiding contiguous reallocations and fragmentation. Edge AI Deployment & Projects
Paged optimizer: Optimizer whose states live in unified memory and page to CPU RAM during GPU memory spikes. Fine-Tuning & Alignment
PagedAttention: vLLM's technique for storing the KV cache in fixed-size pages, reducing memory fragmentation and increasing concurrency. LLM APIs, Structured Outputs & Tool Calling
PagedAttention: Memory manager that stores the KV cache in fixed-size blocks to avoid fragmentation and share prefixes. Transformers & Large Language Models
Paging: Network broadcast asking an idle UE to connect because there is an incoming call or data. CS & IMS Call Flows
PAIR: Prompt Automatic Iterative Refinement: black-box jailbreak where an attacker LLM refines prompts based on judge feedback. LLM Evaluation, Safety & Responsible AI
Pairwise evaluation: Judging which of two outputs for the same input is better. LLM Evaluation, Safety & Responsible AI
Parallel tool calls: Multiple tool calls returned in a single assistant message, which can be executed concurrently. LLM APIs, Structured Outputs & Tool Calling
Parameter sharing: Reusing the same weights at multiple positions or time steps, as in CNNs and RNNs. Deep Learning & Neural Networks
Parametric memory: Knowledge stored in a model's weights, as opposed to retrieved (non-parametric) knowledge. Retrieval-Augmented Generation (RAG)
Parcel: Sequential container holding one transaction's arguments or reply. Binder IPC & AIDL
Parcel: The container used to marshal data for a Binder transaction. Trace a Path Through the Android Stack
Parcelable: Interface for objects that write themselves to and read themselves from a Parcel. Binder IPC & AIDL
Parcelable: Android's explicit flatten protocol for Binder and Intents; not Java serialization and not a disk format. Java Language
ParceledListSlice: Framework helper that sends large lists across several transactions. Binder IPC & AIDL
Parent delegation: The classloader rule: ask the parent loader before defining a class yourself. Java Language
Parent-child retrieval: Indexing small chunks for matching but returning their larger parent sections to the LLM. Retrieval-Augmented Generation (RAG)
Parquet: Compressed, columnar file format that preserves dtypes and allows reading only selected columns. Python & Data Tools for ML
Partial wakelock: Wakelock that keeps the CPU running while allowing the screen to turn off. Power, Thermal & Battery
pass@k: The probability that at least one of k attempts at a task succeeds. Agentic AI & Multi-Agent Systems
pass@k: Probability that at least one of k sampled code solutions passes all unit tests. LLM Evaluation, Safety & Responsible AI
pass^k: The probability that all k attempts at a task succeed; a measure of reliability. Agentic AI & Multi-Agent Systems
PassiveMonitoringClient: Health Services API for all-day background data delivered in batches. Wear OS Platform
Path compression: Union-Find optimisation that points nodes directly at their root during find. Data Structures & Algorithms
PBL: Primary Boot Loader. The first code executed after reset, stored in SoC ROM; loads and verifies XBL. Android Boot Process
PCA: Principal component analysis: linear projection onto orthogonal directions of maximum variance. Machine Learning Fundamentals
PCB: Process control block: the kernel's record of a process (or task) — identity, state, memory, fds, credentials, scheduling data. Operating System Concepts
PCF: Policy Control Function; QoS, charging and UE policies. 5G NR & 5G Core
PCH: Precompiled header: serialized compiler state for a stable include prefix to speed builds. C++ Language
PCO: Protocol Configuration Options; NAS container for DNS, P-CSCF and similar. Android Data Call: Control, netd, eBPF & Packets
PCO: Protocol Configuration Options: extra parameters (DNS, P-CSCF, MTU) exchanged during PDN/PDU setup. Android Telephony, RIL & Modem
PCO: Protocol Configuration Options: NAS container that delivers the P-CSCF address and DNS during PDN setup. IMS, VoLTE & VoWiFi
PCRF / PCF: Policy and Charging Rules Function (LTE) / Policy Control Function (5G): turn session information into QoS rules. IMS, VoLTE & VoWiFi
PDCP: Packet Data Convergence Protocol; ciphering, integrity, ROHC, reordering on the radio user plane. Android Data Call: Control, netd, eBPF & Packets
PDCP: Packet Data Convergence Protocol: ciphering, integrity, header compression, reordering. Android Telephony, RIL & Modem
PDN: Packet Data Network connection (LTE name for the IP session to an APN). Android Data Call: Control, netd, eBPF & Packets
PDN connection / PDU session: A data connection to an APN/DNN in LTE / 5G, with its own IP address and bearers or QoS flows. Android Telephony, RIL & Modem
PDN connection / PDU session: A data connection to a packet network with its own IP address, on LTE and 5G respectively. Trace a Path Through the Android Stack
PDU session: A connection between the UE and a data network, the 5G version of a PDN connection. 5G NR & 5G Core
PDU session: 5G IP (or Ethernet/unstructured) session to a DNN, anchored at a UPF. Android Data Call: Control, netd, eBPF & Packets
PECS: Producer Extends, Consumer Super: the wildcard rule for generic APIs. Java Language
PEFT: Parameter-Efficient Fine-Tuning: methods that train a small fraction of parameters; also the name of the Hugging Face library. Fine-Tuning & Alignment
Per-channel quantization: Using a separate scale for each output channel of a weight tensor for better accuracy. Edge AI Fundamentals
Per-group quantization: Using a separate scale for each small group (for example 32-128) of consecutive weights. Edge AI Fundamentals
Perceptron: A single neuron with a step activation; a linear binary classifier. Deep Learning & Neural Networks
Perfetto: Android's system-wide tracing tool for scheduling, frequencies, thermal, power rails, memory and custom trace slices. Edge AI Deployment & Projects
Perfetto: Android's system-wide tracing tool, including power rails, battery counters and suspend events. Power, Thermal & Battery
PerformanceHintManager: ADPF API that creates a hint session for a set of threads with a target work duration. Power, Thermal & Battery
PermGen: The old HotSpot space for class metadata, removed in Java 8; do not use it as an ART story. Java Language
Permutation importance: Drop in score when a feature's values are shuffled on held-out data. Machine Learning Fundamentals
Perplexity: Exponential of the average per-token cross-entropy; lower means the model finds the text less surprising. Fine-Tuning & Alignment
Perplexity: Exponential of average negative log-likelihood per token; measures how well a model predicts text. LLM Evaluation, Safety & Responsible AI
Perplexity: The exponential of the average per-token cross-entropy; the effective number of choices a language model is unsure between. Math & Statistics for ML
Perplexity: The exponential of the average per-token negative log-likelihood; the effective number of choices a language model is uncertain between. NLP Fundamentals
Perplexity: Exponential of the average per-token cross-entropy; the effective number of choices the model is unsure between. Transformers & Large Language Models
Persona: A role assigned to the model ("You are a senior accountant") that shapes style, depth and viewpoint but not factual knowledge. Prompt Engineering
PFCP: Packet Forwarding Control Protocol on N4 between SMF and UPF. 5G NR & 5G Core
PFCP: Packet Forwarding Control Protocol on N4 (SMF controls UPF). 5G replacement for much of GTP-C on that hop. Android Data Call: Control, netd, eBPF & Packets
Phantom reference: A reference that does not keep the object alive and whose get is always null; used for cleanup after death. Java Language
Phased delivery: Shipping the core of a feature first and the rest in later releases. Leadership, Delivery & Behavioral
PhoneAccount: Telecom record describing a calling account (a SIM or a VoIP app) and the ConnectionService that serves it. CS & IMS Call Flows
Physical address: An address on the memory bus, in a RAM frame (or device memory). Programs do not use these under virtual memory. Operating System Concepts
PIC / PIE: Position-independent code / executable: can run at any load address, used for shared libraries and hardened binaries. C Language
PII: Personally identifiable information, such as names, emails, phone numbers, addresses and account numbers. LLM APIs, Structured Outputs & Tool Calling
PIMPL: Pointer to implementation: a private incomplete type behind a pointer, hiding ABI and reducing rebuilds. C++ Language
Pipe: Unidirectional kernel byte-stream buffer. Anonymous pipes are typically parent-child; a FIFO is a named pipe in the filesystem. Operating System Concepts
Pipeline: Chained preprocessing and model steps fitted together to prevent leakage and skew. Machine Learning Fundamentals
Pipeline: scikit-learn object chaining transformers and a final estimator so they are fitted and applied together. Python & Data Tools for ML
pivot_table: pandas reshaping that aggregates values into a grid of index versus column categories. Python & Data Tools for ML
placement new: Constructing an object in already-allocated storage; destruction is a manual destructor call. C++ Language
Plan-and-execute: An architecture that first produces an explicit plan and then executes its steps, optionally re-planning. Agentic AI & Multi-Agent Systems
Plan-and-solve: Zero-shot prompting that asks the model to devise a plan and then execute it step by step, reducing skipped steps. Prompt Engineering
Planner: The component that decomposes a goal into ordered steps without calling tools itself. Agentic AI & Multi-Agent Systems
PLC: Packet Loss Concealment: the decoder invents a plausible frame when an RTP packet is lost. IMS, VoLTE & VoWiFi
PLMN: Public Land Mobile Network: an operator network identified by MCC + MNC. Android Telephony, RIL & Modem
PMIC: Power Management IC. Sequences voltage rails, releases CPU reset, handles charging and records the power-on reason. Android Boot Process
PMIC: Power management IC: regulators, charger, fuel gauge and power sequencing. Power, Thermal & Battery
PMS (PackageManagerService): Service that installs, parses and tracks packages, components, signatures and UIDs. Android Frameworks Internals
Pointer provenance: The idea that a pointer is not only an address: it is tied to the object it was derived from. Casting through integers can lose that. C Language
Pointwise evaluation: Scoring a single output on its own against a scale or pass/fail criterion. LLM Evaluation, Safety & Responsible AI
Poisoning: Corrupting a model by injecting malicious data or updates into training, fine-tuning or retrieval sources. LLM Evaluation, Safety & Responsible AI
Policy: In RL, the mapping from states to actions or action probabilities. Machine Learning Fundamentals
Polysemy: One word having several related or unrelated meanings, such as "bank". NLP Fundamentals
Pooling: Downsampling by taking the max or average over small windows. Deep Learning & Neural Networks
Pooling: Combining per-token vectors into one sequence vector, for example mean, max or [CLS] pooling. Retrieval-Augmented Generation (RAG)
POS tagging: Assigning a part-of-speech category (noun, verb, adjective, and so on) to each token. NLP Fundamentals
Position bias: A judge's tendency to prefer the first or second option regardless of content. LLM Evaluation, Safety & Responsible AI
Positional encoding: Information added to token representations so attention can use word order. Math & Statistics for ML
Positional encoding: Information about token position added to embeddings so an order-blind attention model can use word order. NLP Fundamentals
Positional encoding: Any method of giving a Transformer information about token order. Transformers & Large Language Models
Post-mortem: A blameless review after an incident that records root cause and corrective actions. Platform Integration & Release
Power (statistical): The probability that a test detects a real effect of a given size; 1 − β. Math & Statistics for ML
Power HAL: Vendor HAL (android.hardware.power) that applies boosts and modes (interaction, launch, low power) by programming cpufreq, uclamp and related knobs. Power, Thermal & Battery
Power Stats HAL: HAL that exposes per-rail energy and per-subsystem residency data. Power, Thermal & Battery
Power/interest grid: A stakeholder map that guides how closely to manage each group. Leadership, Delivery & Behavioral
power_profile.xml: Device overlay of component currents used by batterystats when measured rails are not available. Power, Thermal & Battery
PowerManagerService: Service owning wakelocks, screen state and doze/suspend decisions. Android Frameworks Internals
PowerManagerService: Framework service that manages wakelocks, screen state and requests to suspend. Power, Thermal & Battery
PPG: Photoplethysmography; optical measurement of blood volume changes used for heart rate. Trace a Path Through the Android Stack
PPG: Photoplethysmography: optical measurement of blood-volume changes for heart rate and SpO2. Wear OS Platform
PPO: Proximal Policy Optimization: RL algorithm using a clipped probability-ratio objective and a value model. Fine-Tuning & Alignment
PQ (product quantisation): Lossy compression that splits vectors into sub-vectors and stores each as a codebook index. Retrieval-Augmented Generation (RAG)
PRACK: Provisional Response Acknowledgement: makes a 1xx response such as 183 reliable. IMS, VoLTE & VoWiFi
Pre-LN / Post-LN: Where normalization sits relative to the residual add: inside the branch (Pre-LN, x + F(Norm(x))) or on the residual path (Post-LN, Norm(x + F(x))). Deep Learning & Neural Networks
Pre-LN / Post-LN: Placement of normalization before the sub-layer inside the residual branch (Pre-LN) or after the residual addition (Post-LN). Transformers & Large Language Models
Pre-mortem: Imagining a project has failed and working backwards to identify likely causes. Leadership, Delivery & Behavioral
Precision: TP / (TP + FP): how often a positive prediction is correct. Machine Learning Fundamentals
Precision: The fraction of predicted positives (or extracted items) that are correct. NLP Fundamentals
Precision@k: The fraction of the top k results that are relevant. Retrieval-Augmented Generation (RAG)
Precondition: SDP mechanism that delays alerting until QoS resources are reserved on both sides. IMS, VoLTE & VoWiFi
Preconditions: SIP mechanism (183 with SDP answer / PRACK / UPDATE) that reserves network resources before the callee is alerted. The dedicated voice bearer is usually triggered from the SDP answer, not from PRACK itself. CS & IMS Call Flows
PREF64: RA option that can advertise a NAT64 prefix to the UE. Android Data Call: Control, netd, eBPF & Packets
Prefill: The phase where an LLM processes the whole prompt in parallel; compute-bound; sets time to first token. Edge AI Fundamentals
Prefill: The inference phase that processes all prompt tokens in parallel. It is compute-bound and determines TTFT. GenAI System Design & Case Studies
Prefill: Writing the beginning of the assistant's reply yourself (for example "{") so the model continues in the desired format. Prompt Engineering
Prefill: The parallel forward pass over the prompt that fills the KV cache and produces the first token. Transformers & Large Language Models
Prefill phase: Processing all prompt tokens in parallel to fill the KV cache; compute-bound and the main contributor to TTFT. Edge AI Deployment & Projects
Prefix caching: Reusing a precomputed KV cache for a shared prompt prefix, such as a system prompt, to reduce TTFT. Edge AI Deployment & Projects
Prefix caching: Reusing computed KV for a byte-identical prompt prefix (system prompt, tools, shared document) to cut prefill and TTFT. Edge AI Fundamentals
Prefix caching (prompt caching): Reusing computed KV state for identical prompt prefixes across requests, lowering latency and cost. GenAI System Design & Case Studies
Prefix sum: Running total array where the sum of any range is the difference of two entries. Data Structures & Algorithms
Prefix tuning: PEFT method that learns key/value vectors prepended at every attention layer. Fine-Tuning & Alignment
Presence penalty: A parameter that applies a flat logit penalty to any token that has already appeared, encouraging new topics. LLM APIs, Structured Outputs & Tool Calling
Presence penalty: Decoding control that lowers a token's logit by a fixed amount once it has appeared at all. Transformers & Large Language Models
Presubmit: Checks run on a change before it is merged. Platform Integration & Release
Principal component analysis (PCA): Linear dimensionality reduction that projects data onto the top eigenvectors of its covariance matrix. Math & Statistics for ML
Priority inheritance: A lock holder temporarily runs at the priority of its highest waiter so a medium-priority job cannot invert the high waiter. Operating System Concepts
Priority inversion: High-priority task waits on a lock held by a low-priority task that a medium task keeps preempting. Linux Kernel & BSP
Priority inversion: A high-priority thread waits on a lock held by a low-priority thread that is itself preempted by a medium-priority thread. Operating System Concepts
Private DNS: User setting that forces or prefers DoT in DnsResolver. Android Data Call: Control, netd, eBPF & Packets
Procedural memory: Stored knowledge of how to do things, such as instructions, rules, workflows or reusable skills. Agentic AI & Multi-Agent Systems
Process: A program in execution: address space, credentials, file table, and one or more threads. The usual isolation boundary. Operating System Concepts
Product quantization (PQ): Compressing vectors by splitting them into sub-vectors, each encoded as a centroid index, to shrink index memory. GenAI System Design & Case Studies
PRODUCT_PACKAGES: Make variable listing modules installed on a product image. Built is not the same as packaged. Platform Integration & Release
Progress: Critical-section rule: if the section is free and someone wants in, the choice of who enters cannot be delayed by uninterested threads. Operating System Concepts
Promotion gate: Pass or fail criteria a build must meet to move to the next stage. Platform Integration & Release
Prompt caching: Provider-side reuse of computation for a repeated prompt prefix, reducing input cost and time to first token. LLM APIs, Structured Outputs & Tool Calling
Prompt caching: Provider feature that reuses computation for a repeated prompt prefix, lowering cost and latency. Prompt Engineering
Prompt caching: Reusing the computed KV cache of a repeated prompt prefix across requests. Transformers & Large Language Models
Prompt chaining: A fixed sequence of LLM calls where each consumes the previous output, often with validation gates between steps. Agentic AI & Multi-Agent Systems
Prompt chaining: Splitting a task into sequential LLM calls where each output feeds the next, with optional validation between steps. Prompt Engineering
Prompt compression: Reducing prompt tokens while keeping task-relevant information, via extraction, summarization, token pruning or learned compressors. Prompt Engineering
Prompt injection: Input crafted to override a model's instructions, either directly from the user or indirectly via content. Agentic AI & Multi-Agent Systems
Prompt injection: An attack in which crafted input causes the model to ignore its instructions or take unintended actions. LLM APIs, Structured Outputs & Tool Calling
Prompt injection: Input that overrides or subverts the developer's intended instructions to the model. LLM Evaluation, Safety & Responsible AI
Prompt injection: An attack in which crafted input overrides or subverts the developer's instructions to an LLM. Prompt Engineering
Prompt injection: Malicious instructions in user input or retrieved content that try to override the system's instructions. Retrieval-Augmented Generation (RAG)
Prompt leakage: Attack causing a model to reveal its system prompt or hidden context. LLM Evaluation, Safety & Responsible AI
Prompt leaking: A form of injection that extracts the system prompt or other hidden context. Prompt Engineering
Prompt sensitivity: The tendency of model quality to move under small, semantically irrelevant changes to wording, format, example order or seed. Prompt Engineering
Prompt template: A reusable prompt with placeholders filled at runtime, versioned like code. Prompt Engineering
Prompt tuning: PEFT method that learns a few soft embedding vectors prepended to the input. Fine-Tuning & Alignment
Prompt tuning (soft prompt): Learning a small set of continuous prefix vectors while keeping the model frozen; a PEFT method, not discrete prompt wording. Prompt Engineering
Property service: init's system-wide key/value store (ro.*, persist.*, sys.*) protected by SELinux property contexts. Android Boot Process
ProTeGi: Prompt optimization with textual gradients: an LLM explains a prompt's errors in words, edits the prompt, and beam search keeps the best edits. Prompt Engineering
ProtoLayout: Protocol-buffer based layout description used by Tiles and rendered by the system. Wear OS Platform
Provenance: The traceable link from each claim in an output to the source, tool call or agent that produced it. Agentic AI & Multi-Agent Systems
Proxy: Generated client-side class that marshals calls and sends transactions. Binder IPC & AIDL
Pruning: Removing weights, channels, heads or layers that contribute little to the output. Edge AI Fundamentals
prvalue: Pure rvalue: a temporary or initializer that does not yet have identity in the abstract machine. C++ Language
PSAP: Public Safety Answering Point: the emergency call centre. IMS, VoLTE & VoWiFi
PSCell: Primary cell of the secondary cell group. 5G NR & 5G Core
Pseudo-polynomial: Running time polynomial in a numeric input value (like capacity W) but exponential in its bit length. Data Structures & Algorithms
Pseudonymisation: Replacing identifiers with consistent placeholders, with the mapping stored securely so values can be restored. GenAI System Design & Case Studies
PSI: Pressure Stall Information: kernel metric of time tasks stall on memory, CPU or I/O. Android Frameworks Internals
PSI: Pressure stall information: kernel metrics showing how much time tasks stall waiting for memory, CPU or IO. Edge AI Deployment & Projects
PSI: Pressure Stall Information: time tasks spend stalled on CPU, memory or I/O. Linux Kernel & BSP
PSI: Population Stability Index; measures distribution shift between a reference and live data. Machine Learning Fundamentals
PstnIncomingCallNotifier: Phone-process class that reports new ringing connections to Telecom via addNewIncomingCall(). CS & IMS Call Flows
pstore / ramoops: Reserved RAM that preserves kernel logs across a crash and reboot. Linux Kernel & BSP
Psychological safety: A shared belief that it is safe to take interpersonal risks such as admitting mistakes. Leadership, Delivery & Behavioral
PTCRB: North-American operator forum for cellular device certification. Platform Integration & Release
pthread: POSIX threads API: create, join, mutex, condvar. The everyday threading API on Android userspace. C Language
PTQ: Post-training quantization: quantizing a trained model using calibration data, without retraining. Edge AI Deployment & Projects
PTQ: Post-training quantization: quantizing an already-trained model using calibration data. Edge AI Fundamentals
Pydantic: A Python library that validates data against type-annotated models, coerces safe conversions and generates JSON Schema. LLM APIs, Structured Outputs & Tool Calling

Q

Q-learning: Off-policy RL algorithm that learns action values via temporal-difference updates. Machine Learning Fundamentals
QAIRT: Qualcomm AI Runtime SDK, which includes the QNN libraries, converters, quantizers, HTP backend, profiling and Genie. Edge AI Deployment & Projects
QAT: Quantization-aware training: fine-tuning with simulated quantization so the model learns to tolerate rounding. Edge AI Deployment & Projects
QAT: Quantization-aware training: training with simulated quantization so the model tolerates low precision. Edge AI Fundamentals
QCI / 5QI: QoS class identifiers in LTE / 5G (1 = conversational voice, 5 = IMS signalling). Android Telephony, RIL & Modem
QCI / 5QI: QoS Class Identifier (LTE) / 5G QoS Identifier: a number standing for delay, loss and priority characteristics. IMS, VoLTE & VoWiFi
QCI 1 / 5QI 1: GBR QoS class for conversational voice on LTE / NR; QCI 5 / 5QI 5 is for IMS signalling. CS & IMS Call Flows
QDQ format: An ONNX representation of quantization using explicit QuantizeLinear/DequantizeLinear nodes that backends fuse into integer kernels. Edge AI Deployment & Projects
QFI: QoS Flow Identifier carried in the GTP-U header. 5G NR & 5G Core
QFI: QoS Flow Identifier inside a 5G PDU session / GTP-U header. Android Data Call: Control, netd, eBPF & Packets
QK-norm: Layer- or RMS-normalizing queries and keys before the dot product to stop attention logits from growing with depth. Transformers & Large Language Models
QLoRA: LoRA fine-tuning on a base model stored in 4-bit NF4, with double quantization and paged optimizers. Fine-Tuning & Alignment
QMAP: Qualcomm Multiplexing and Aggregation Protocol example header on the AP–modem link. Android Data Call: Control, netd, eBPF & Packets
QMAP: Qualcomm multiplexing protocol that carries several PDNs over one data link with aggregation. Android Telephony, RIL & Modem
QMAP: Qualcomm Multiplexing and Aggregation Protocol; header used by rmnet to carry several data calls over one link. Trace a Path Through the Android Stack
QMI: Qualcomm MSM Interface: service-based binary protocol between AP clients and modem services. Android Telephony, RIL & Modem
QMI: Qualcomm MSM Interface; the message protocol between AP software and the modem and other subsystems. On modern SoCs it rides QRTR. Trace a Path Through the Android Stack
QMI WDS: Qualcomm Wireless Data Service example: vendor IPC to start/stop packet data. Android Data Call: Control, netd, eBPF & Packets
QNN / QAIRT: Qualcomm AI Engine Direct, packaged as the Qualcomm AI Runtime SDK, for running models on the Hexagon NPU, Adreno GPU and CPU. Edge AI Fundamentals
QRTR: Qualcomm IPC router: kernel socket family (AF_QIPCRTR) that transports QMI messages. Android Telephony, RIL & Modem
QRTR: Qualcomm IPC Router; socket-style transport used for QMI on recent Qualcomm platforms, replacing older shared-memory SMD channels. Trace a Path Through the Android Stack
qtaguid: Legacy xtables module for per-UID traffic tags and stats; replaced in spirit by eBPF. Android Data Call: Control, netd, eBPF & Packets
QTEE: Qualcomm Trusted Execution Environment. The secure OS in TrustZone that hosts trusted apps. Android Boot Process
Quality gate: An objective check that must pass before work moves to the next stage. Leadership, Delivery & Behavioral
Quantile: A cut point below which a given fraction of sorted data falls (percentiles, quartiles, deciles). Math & Statistics for ML
Quantization: Representing weights, activations or KV in lower precision (FP8, INT8, INT4) to cut memory and speed up inference. GenAI System Design & Case Studies
Quantization: Storing model weights at lower numeric precision (8-bit, 4-bit) to save memory and speed up inference. LLM APIs, Structured Outputs & Tool Calling
Quantum: Time slice in round robin (or a level of MLFQ). Too small wastes time on switches; too large behaves like FCFS. Operating System Concepts
Query rewriting: Using an LLM or rules to turn a raw user query into a clearer, more retrievable one. Retrieval-Augmented Generation (RAG)
Query routing: Directing a query to the appropriate knowledge source, index, model or prompt before execution. Retrieval-Augmented Generation (RAG)
Quickselect: Partition-based selection of the k-th smallest element in O(n) average time. Data Structures & Algorithms
Quorum: Minimum number of replicas that must respond to a read or write; R + W > N gives overlapping reads and writes. System Design
QXDM / QCAT: Qualcomm tools to capture and decode modem logs over the DIAG interface. Android Telephony, RIL & Modem

R

R-squared (R²): Coefficient of determination: fraction of target variance explained relative to predicting the mean. Machine Learning Fundamentals
Race condition: Correctness depends on the interleaving of concurrent operations. A lost update on a shared counter is the canonical example. Operating System Concepts
Race to idle: Finishing work quickly so hardware can return to low-power sleep states, often saving energy overall. Edge AI Fundamentals
RACI: Responsible, Accountable, Consulted, Informed: a matrix clarifying roles for tasks. Leadership, Delivery & Behavioral
RadioResponseInfo: Header on every HAL response: type (solicited or solicited-ack), serial and error. Android Telephony, RIL & Modem
Raft: Consensus protocol: a leader replicates a log; an entry is committed when a majority has stored it. System Design
RAG: Retrieval-augmented generation: fetching relevant external content at inference time and conditioning the answer on it. GenAI System Design & Case Studies
RAG status: Red, amber, green indicators showing whether work is on track. Leadership, Delivery & Behavioral
RAGAS: An open-source framework computing LLM-judged RAG metrics such as faithfulness, answer relevance, context precision and context recall. Retrieval-Augmented Generation (RAG)
RAII: Resource Acquisition Is Initialization: acquire in the constructor, release in the destructor. C++ Language
Ramdump: Full memory image captured after a crash for offline analysis. Linux Kernel & BSP
Random forest: Bagged decision trees with random feature subsets at each split. Machine Learning Fundamentals
ranges: C++20 library of lazy views and range-taking algorithms that operate on whole ranges instead of iterator pairs. C++ Language
Rank: The number of linearly independent rows or columns of a matrix. Math & Statistics for ML
Rank (LoRA): Inner dimension r of the LoRA matrices; bounds the rank of the update and sets adapter size. Fine-Tuning & Alignment
RAPID: Recommend, Agree, Perform, Input, Decide: a framework clarifying decision roles. Leadership, Delivery & Behavioral
RAT: Radio Access Technology: GSM, UMTS, LTE, NR and so on. Android Telephony, RIL & Modem
Rate limit: A cap on requests or tokens per unit time; exceeding it returns HTTP 429. LLM APIs, Structured Outputs & Tool Calling
Rate limiting: Restricting how many requests a client may make in a time period. System Design
RCA: Root-Cause Analysis; finding why a problem happened, not only what failed. Platform Integration & Release
RCS: Rich Communication Services: GSMA rich messaging over IMS. IMS, VoLTE & VoWiFi
RCU: Read-Copy-Update: synchronization with lock-free readers and deferred reclamation. Linux Kernel & BSP
ReAct: A prompting and agent pattern that interleaves reasoning thoughts, tool actions and observations in a loop. Agentic AI & Multi-Agent Systems
ReAct: Reason + Act: interleaving reasoning thoughts, tool actions and observations until a final answer is reached. Prompt Engineering
Ready queue: The scheduler's collection of runnable threads waiting for a CPU. Waiting time is time spent here, not time spent blocked on I/O. Operating System Concepts
Real-time factor: Processing time divided by input audio duration; below 1 means faster than real time. Edge AI Fundamentals
realloc: Resize a heap block; may move it. On failure the original pointer remains valid. C Language
Reasoning model: A model trained, typically with reinforcement learning on verifiable tasks, to think at length internally before answering. Prompt Engineering
Reasoning tokens: Hidden intermediate tokens a reasoning model generates before its answer; billed as output tokens. LLM APIs, Structured Outputs & Tool Calling
Rebase: Replaying commits on top of a new base, producing a linear history with new commit IDs. Platform Integration & Release
Recall: TP / (TP + FN): fraction of actual positives that are caught; also sensitivity or TPR. Machine Learning Fundamentals
Recall: The fraction of true positives (or gold items) that the system found. NLP Fundamentals
Recall@k: The fraction of all relevant items that appear in the top k results. Retrieval-Augmented Generation (RAG)
Receptive field: The region of the input that can influence a given unit. Deep Learning & Neural Networks
Reciprocal rank fusion (RRF): Merging ranked lists by summing 1 ÷ (k + rank) scores for each item. GenAI System Design & Case Studies
Record: A transparent, final, shallowly immutable Java class with generated accessors and equality. Java Language
Recursion limit: A hard cap on the number of steps a graph or agent run may take before being stopped. Agentic AI & Multi-Agent Systems
Red teaming: Structured adversarial testing to find failures and vulnerabilities before attackers do. LLM Evaluation, Safety & Responsible AI
Reducer: A function that defines how updates to a state field are merged, for example append, merge or overwrite. Agentic AI & Multi-Agent Systems
ReentrantLock: An explicit lock in java.util.concurrent that the same thread may acquire again; supports fairness and conditions. Java Language
Reference model: Frozen copy of the starting policy used for the KL penalty or DPO log-ratios. Fine-Tuning & Alignment
Reference-free metric: Metric that evaluates output without a gold answer, using the input, context or intrinsic properties. LLM Evaluation, Safety & Responsible AI
Reflexion: A technique in which an agent writes verbal lessons from failed attempts into memory and uses them on retries. Agentic AI & Multi-Agent Systems
Reflexion: An approach where the model writes verbal lessons after failed attempts and uses them as memory in later attempts. Prompt Engineering
Regression set: A fixed collection of test inputs, including past failures, run on every prompt change to catch reintroduced errors. Prompt Engineering
Regression test: Test ensuring a previously fixed failure does not return after changes. LLM Evaluation, Safety & Responsible AI
Reinforcement learning: Learning a policy by trial and error to maximise cumulative reward. Machine Learning Fundamentals
Relocation: A linker (or loader) patch that fills in an address that was unknown at compile time. C Language
ReLU: Rectified linear unit, max(0, x); the default hidden activation for CNNs and MLPs. Deep Learning & Neural Networks
RemoteActivityHelper: Jetpack helper that starts an intent on the paired phone. Wear OS Platform
RemoteCallbackList: Helper that holds client callbacks and removes them automatically when clients die. Binder IPC & AIDL
RenderThread: Per-app thread that turns display lists into GPU commands. Trace a Path Through the Android Stack
Reparameterization trick: Writing a sample as z = μ + σε so gradients can flow through a random sampling step. Deep Learning & Neural Networks
Repetition penalty: Multiplicative decoding control that makes already-seen tokens less likely. Transformers & Large Language Models
Replay: Mixing general or earlier-task data into fine-tuning to reduce forgetting. Fine-Tuning & Alignment
Replication lag: Delay between a write on the leader and its appearance on followers. System Design
repo: Google's tool for managing many Git repositories from a single manifest. Platform Integration & Release
requires_grad: PyTorch tensor flag indicating that operations on it should be recorded for gradient computation. Python & Data Tools for ML
Reranker: A second-stage model that rescores a candidate shortlist more accurately than the first-stage retriever. Retrieval-Augmented Generation (RAG)
rerere: Git's "reuse recorded resolution" feature, which re-applies earlier conflict resolutions. Platform Integration & Release
Rescue Party: Framework mechanism that detects crash loops and escalates from resetting settings to offering a factory reset. Android Boot Process
Residual (in IVF-PQ): The difference between a vector and its cluster centroid; PQ-encoding residuals reduces quantisation error. Retrieval-Augmented Generation (RAG)
Residual connection: A shortcut that adds a block's input to its output (y = F(x) + x). Deep Learning & Neural Networks
Residual connection: Adding a sub-layer's input to its output (x + f(x)), giving gradients an identity path. Transformers & Large Language Models
Residual stream: The per-example (or per-token) vector that every residual block reads from and writes an additive update into. Deep Learning & Neural Networks
Residual stream: The per-token vector flowing through the network that every sub-layer reads from and adds to. Transformers & Large Language Models
Responses API: A newer provider endpoint family (names vary) alongside Chat Completions, with different field names for the same ideas: messages, tools, usage, streaming. Check current docs before coding against it. LLM APIs, Structured Outputs & Tool Calling
restrict: Promise that a pointer is the only way the function will access that object, enabling non-aliasing optimisations. C Language
Retrieval gateway: A central layer between routing and knowledge sources enforcing authentication, authorisation, quotas, caching and logging. Retrieval-Augmented Generation (RAG)
Retry-After: An HTTP response header telling the client how long to wait before retrying. LLM APIs, Structured Outputs & Tool Calling
Reward hacking: A policy exploiting flaws in a reward signal to score highly without truly improving. Fine-Tuning & Alignment
Reward hacking: A trained policy exploiting flaws in the reward signal to score highly without truly improving. LLM Evaluation, Safety & Responsible AI
Reward hacking: A policy exploiting flaws in the reward model to get high scores without genuinely better outputs. Transformers & Large Language Models
Reward model: Model trained on human (or AI) comparisons to output a scalar score for a prompt–response pair. Fine-Tuning & Alignment
Reward model: Model trained on human comparisons to score responses, used as the objective in RLHF. Transformers & Large Language Models
ReWOO: Reasoning without observation: plan all tool calls up front with placeholders, execute them, then solve, reducing LLM calls. Agentic AI & Multi-Agent Systems
Ridge point: Peak compute divided by memory bandwidth; the arithmetic intensity where a workload becomes compute-bound. Edge AI Fundamentals
RIL: Radio Interface Layer; the path from Telephony through the Radio HAL to the vendor modem software. Trace a Path Through the Android Stack
RIL / RILJ: Radio Interface Layer; RILJ is the Java side (RIL.java) in the framework. Android Telephony, RIL & Modem
RIL / RILJ: Radio Interface Layer; RIL.java (log tag RILJ) is the framework client of the radio HAL. CS & IMS Call Flows
rild: The vendor RIL daemon implementing the Radio HAL (for example qcrild). Android Telephony, RIL & Modem
rild: Vendor radio daemon implementing the radio HAL and talking to the modem (MTK rild, Qualcomm qcrild). CS & IMS Call Flows
Risk register: A maintained list of risks with likelihood, impact, owner, mitigation and triggers. Leadership, Delivery & Behavioral
RLAIF: Reinforcement Learning from AI Feedback: preference labels come from an AI judge instead of humans. Fine-Tuning & Alignment
RLC: Radio Link Control: segmentation, reassembly and ARQ in TM, UM or AM mode. Android Telephony, RIL & Modem
RLF: Radio Link Failure: loss of the radio connection, followed by re-establishment or idle. Android Telephony, RIL & Modem
RLHF: Reinforcement Learning from Human Feedback: SFT, reward model from human preferences, then RL against that reward. Fine-Tuning & Alignment
RLHF: Reinforcement Learning from Human Feedback: reward model trained on human preferences, then policy optimisation against it. LLM Evaluation, Safety & Responsible AI
RLHF: Reinforcement learning from human feedback: optimising a model against a reward model trained on human preferences. Machine Learning Fundamentals
RLHF: Reinforcement Learning from Human Feedback: reward model from human preferences plus RL (typically PPO) to optimise the LLM. Transformers & Large Language Models
RLVR: RL with verifiable rewards: rewards from automatic checks such as correct final answers or passing tests. Fine-Tuning & Alignment
rmnet: Qualcomm kernel driver family exposing modem data calls as rmnet_dataN interfaces. Android Data Call: Control, netd, eBPF & Packets
rmnet: Qualcomm cellular data network interfaces (rmnet_data0..N), one per PDN. Android Telephony, RIL & Modem
rmnet: Qualcomm network driver exposing modem data calls as rmnet_data interfaces. Trace a Path Through the Android Stack
RMSNorm: Normalization dividing by the root-mean-square of features without subtracting the mean. Deep Learning & Neural Networks
RMSNorm: Simplified normalization that rescales by the root-mean-square of features without subtracting the mean. Transformers & Large Language Models
RNA: RAN Notification Area; area in which an RRC_INACTIVE UE moves without notifying the network. 5G NR & 5G Core
RNN: Recurrent neural network: processes sequences step by step with a hidden state and shared weights. Deep Learning & Neural Networks
RNN: Recurrent neural network: processes a sequence one step at a time, updating a hidden state with shared weights. NLP Fundamentals
ROC curve: Plot of true positive rate against false positive rate across thresholds. Machine Learning Fundamentals
ROHC: Robust Header Compression: shrinks IP/UDP/RTP headers over the radio for voice efficiency. IMS, VoLTE & VoWiFi
Rollback index: Version number in vbmeta compared with a value in tamper-evident storage to block downgrades. Android Boot Process
Roofline model: A chart relating attainable performance to arithmetic intensity, bounded by memory bandwidth and peak compute. Edge AI Fundamentals
RoPE: Rotary position embedding: rotating query and key vector pairs by position-dependent angles so attention depends on relative position. Math & Statistics for ML
RoPE: Rotary Position Embedding: rotates query and key dimension pairs by position-dependent angles so scores depend on relative distance. Transformers & Large Language Models
Rotation methods: Quantization techniques (QuaRot, SpinQuant) that apply orthogonal transforms to spread outliers across channels. Edge AI Fundamentals
ROUGE: Recall-oriented n-gram or longest-common-subsequence overlap metric for summarisation. LLM Evaluation, Safety & Responsible AI
ROUGE: A family of summarization metrics measuring n-gram (ROUGE-N) or longest-common-subsequence (ROUGE-L) overlap, emphasizing recall. NLP Fundamentals
Round robin: Preemptive scheduling: each ready job runs for a quantum, then is placed at the tail of the ready queue. Operating System Concepts
Router: A component that classifies input and sends it to the appropriate handler, model, source or agent. Agentic AI & Multi-Agent Systems
Routing: Classifying a request and sending it to the most suitable prompt, model, tool pipeline or human. Prompt Engineering
RPMB: Replay Protected Memory Block. Authenticated storage area in UFS/eMMC used by the TEE for rollback counters and secrets. Android Boot Process
RRC: Radio Resource Control; idle/inactive/connected and bearer setup on the air. Android Data Call: Control, netd, eBPF & Packets
RRC: Radio Resource Control: sets up, reconfigures and releases the radio connection. Android Telephony, RIL & Modem
RRC_INACTIVE: NR RRC state with stored context allowing fast resume. 5G NR & 5G Core
RRF (reciprocal rank fusion): A fusion method scoring each document by the sum of 1/(k + rank) across result lists. Retrieval-Augmented Generation (RAG)
rsLoRA: Rank-stabilized LoRA using scale α/√r. Fine-Tuning & Alignment
RSP: GSMA Remote SIM Provisioning: the standard for downloading eSIM profiles. Wear OS Platform
RSRP / RSRQ / SINR: Reference signal received power, quality, and signal-to-interference-plus-noise ratio. Android Telephony, RIL & Modem
RSS and PSS: Resident set size (all resident pages of a process) and proportional set size (shared pages divided among sharers). Edge AI Deployment & Projects
RTP: Real-time Transport Protocol; carries voice and video media packets. Trace a Path Through the Android Stack
RTP / RTCP: Real-time Transport Protocol carries media; its control protocol reports loss, jitter and delay. IMS, VoLTE & VoWiFi
RTTI: Run-time type information: typeid and dynamic_cast, often disabled with -fno-rtti on Android. C++ Language
Rule of Five: If you define one of destructor, copy/move ctor, copy/move assign, define or delete all five. C++ Language
Rule of Zero: Prefer types whose members already manage resources so you write no special members. C++ Language
rvalue: xvalue or prvalue; can bind to T&&. C++ Language

S

S-CSCF: Serving CSCF: registrar and session controller that runs iFC. IMS, VoLTE & VoWiFi
S-NSSAI: Single slice identifier made of SST and optional SD. 5G NR & 5G Core
S8HR: S8 Home Routed: the common IMS roaming model; P-GW and P-CSCF stay in the home network and the IMS APN is hauled over S8. IMS, VoLTE & VoWiFi
SA: Standalone; NR connected directly to the 5GC. 5G NR & 5G Core
Saddle point: A point with zero gradient that is a minimum in some directions and a maximum in others. Deep Learning & Neural Networks
Saddle point: A point with zero gradient that is a minimum in some directions and a maximum in others. Math & Statistics for ML
Safe state: A resource-allocation state for which there exists an order of processes that can all finish with the remaining resources (Banker's). Operating System Concepts
Safepoint: A point where the VM can stop a thread for GC or other VM operations. Java Language
Saga: A long-running transaction split into local steps with compensating actions on failure. System Design
Sandbox: An isolated execution environment with restricted resources, network and secrets for running untrusted code or browsing. Agentic AI & Multi-Agent Systems
SBC: Session Border Controller: edge product providing security, NAT traversal and topology hiding, often hosting the P-CSCF. IMS, VoLTE & VoWiFi
SBI: Situation, Behaviour, Impact: a structure for specific, non-judgemental feedback. Leadership, Delivery & Behavioral
Scale and zero-point: The two parameters that map real values to integers in quantization. Edge AI Fundamentals
Scaled dot-product attention: softmax(QK^T/√d_k)V: weighting value vectors by normalized query-key similarity. Math & Statistics for ML
Scaling laws: Empirical power-law relationships between loss and model size, data and compute. Transformers & Large Language Models
SCC-AS: Service Centralization and Continuity Application Server: anchors sessions for access transfer and SRVCC. IMS, VoLTE & VoWiFi
schedutil: cpufreq governor that sets frequency from scheduler utilization; the modern Android default. Power, Thermal & Battery
Scope creep: Uncontrolled growth of requirements after a plan is agreed. Leadership, Delivery & Behavioral
SCS: Subcarrier spacing, 15 × 2^µ kHz. 5G NR & 5G Core
SDAP: Service Data Adaptation Protocol; maps QoS flows to DRBs. 5G NR & 5G Core
SDP: Session Description Protocol: describes media addresses, ports, codecs and direction. IMS, VoLTE & VoWiFi
Sealed type: A class or interface that permits only a listed set of subtypes (newer Java). Java Language
Secure aggregation: A cryptographic protocol that lets a server see only the sum of many device updates, never an individual one. Edge AI Fundamentals
Segment tree: Binary tree over array ranges that answers range queries and applies point or range updates in O(log n). Data Structures & Algorithms
Segmentation: Variable-size logical regions (code, stack, heap). Matches program structure; reintroduces external fragmentation if used as the allocator. Operating System Concepts
Self-attention: Attention where queries, keys and values all come from the same sequence, so every token can use every other token as context. NLP Fundamentals
Self-attention: Attention in which queries, keys and values all come from the same sequence. Transformers & Large Language Models
Self-consistency: Sampling several reasoning paths from one model and selecting the most common final answer. Agentic AI & Multi-Agent Systems
Self-consistency: Sampling multiple reasoning paths and selecting the most frequent final answer. Prompt Engineering
Self-consistency: Sampling several reasoning paths and choosing the most common final answer. Transformers & Large Language Models
Self-RAG: A method where a model emits reflection tokens to decide when to retrieve and to critique relevance and support. Agentic AI & Multi-Agent Systems
Self-RAG: A method where the model decides when to retrieve and critiques relevance and support with reflection tokens. Retrieval-Augmented Generation (RAG)
Self-refine: Iterative loop of generate, critique and revise using the model's own feedback against criteria. Prompt Engineering
SELinux: Mandatory access control in the kernel; Android runs all domains in enforcing mode, and denials appear as avc: denied. Android Boot Process
SELinux: Mandatory access control in the kernel; every process runs in a domain with explicit allow rules. Android Frameworks Internals
Semantic cache: A cache that returns a stored answer when a new query's embedding is close enough to a previous one. GenAI System Design & Case Studies
Semantic cache: A response cache keyed by embedding similarity rather than exact text match. LLM APIs, Structured Outputs & Tool Calling
Semantic cache: A cache that reuses answers for new queries whose embeddings are sufficiently similar to cached ones. Retrieval-Augmented Generation (RAG)
Semantic chunking: Splitting text where consecutive-sentence embedding similarity drops, indicating a topic change. Retrieval-Augmented Generation (RAG)
Semantic memory: Stored general facts and knowledge, such as user preferences or system facts, independent of when they were learned. Agentic AI & Multi-Agent Systems
Semaphore: A counter of permits used to bound concurrent access to a resource. Java Language
Semaphore: Integer plus a wait queue: P/wait decrements and may sleep; V/signal increments and may wake. Binary or counting; no owner. Operating System Concepts
Sensor hub: Always-on low-power processor that samples, fuses and batches sensor data. Power, Thermal & Battery
Sensor hub: A low-power processor that samples and batches sensors while the main CPU sleeps. Trace a Path Through the Android Stack
Sensor hub: The sensor-processing role of the co-processor: sampling, fusion, algorithms and batching. Wear OS Platform
Sentence-BERT (SBERT): A BERT model fine-tuned in a siamese setup so that pooled sentence vectors are comparable with cosine similarity. NLP Fundamentals
SentencePiece: A tokenizer library that learns BPE or Unigram vocabularies directly from raw text, treating whitespace as an ordinary symbol. NLP Fundamentals
Sentiment analysis: Classifying the opinion or emotional polarity expressed in text. NLP Fundamentals
Seq2seq: Encoder-decoder model mapping an input sequence to an output sequence of possibly different length. Deep Learning & Neural Networks
Seq2seq: An encoder–decoder architecture that maps an input sequence to an output sequence of possibly different length. NLP Fundamentals
Sequence point: Older term for a place where previous side effects are complete. C11+ uses sequenced-before. C Language
Sequenced-before: C11/C17 partial order on evaluations. Unsequenced conflicting accesses to a scalar are UB. C Language
Serial: Request ID in the Radio HAL used to match async responses to requests. Binder IPC & AIDL
Series: pandas one-dimensional labelled array. Python & Data Tools for ML
Server-sent events (SSE): A one-way HTTP streaming format where the server pushes "data:" lines; used for token streaming. LLM APIs, Structured Outputs & Tool Calling
Service Request: NAS procedure that takes an idle UE to connected so the core can restore the user plane after paging or for MO data. Android Telephony, RIL & Modem
servicemanager: Binder context manager (handle 0) where services register by name and clients look them up. Android Boot Process
servicemanager: Binder context manager that maps service names to Binder handles. Android Frameworks Internals
servicemanager: Name registry for Binder services on /dev/binder. Binder IPC & AIDL
ServiceStateTracker: Framework class that tracks registration, operator, RAT, roaming and signal. Android Telephony, RIL & Modem
SETUP: CC message that starts a CS call; carries the called number and bearer capability. CS & IMS Call Flows
SetupDataCallResult: HAL structure returned after setup: cause, cid, ifname, addresses, DNS, routes, MTU, 5G extras. Android Data Call: Control, netd, eBPF & Packets
SFINAE: Substitution Failure Is Not An Error: a failed substitution removes a template candidate instead of failing the program. C++ Language
SFT: Supervised Fine-Tuning: training on input–target demonstrations with next-token cross-entropy. Fine-Tuning & Alignment
SFTTrainer: TRL's trainer for supervised fine-tuning, with chat formatting, packing and PEFT integration. Fine-Tuning & Alignment
Shadow AI: Employees using unapproved AI tools outside corporate oversight. LLM Evaluation, Safety & Responsible AI
Shadow and reverse-shadow: A mentoring ramp in which the learner first observes, then leads while the mentor observes. Leadership, Delivery & Behavioral
SHAP: Shapley-value explanations assigning each feature an additive contribution to a prediction. Machine Learning Fundamentals
Sharding: Partitioning data across nodes by a key so each node holds a subset. System Design
Shared library: Dynamically loaded image (.so) with its own text/data, resolved by the dynamic linker. C Language
shared_ptr: Shared-ownership smart pointer with an atomic strong count and a separate weak count in a control block. C++ Language
Short-term memory: The working context of the current task or thread: messages, tool results and structured state. Agentic AI & Multi-Agent Systems
SIDF: Subscription Identifier De-concealing Function inside the UDM. 5G NR & 5G Core
Sigmoid: Activation 1/(1 + e^−x) mapping to (0, 1); used for binary outputs and gates. Deep Learning & Neural Networks
Signal: Asynchronous notification delivered to a process or thread. Tiny payload; not a data plane. Handlers may call only async-signal-safe functions. Operating System Concepts
Silent redial: Automatic redial on the other domain (IMS to CS or CS to IMS) without the user seeing a failed call. CS & IMS Call Flows
Silhouette score: Cluster quality measure from −1 to 1 comparing own-cluster and nearest-other-cluster distances. Machine Learning Fundamentals
simpleperf: Android's sampling CPU profiler for native code, with call graphs and hardware counters. Edge AI Deployment & Projects
SimPO: Reference-free preference method using length-normalized log-probability as the implicit reward plus a margin. Fine-Tuning & Alignment
Singular value decomposition (SVD): Factorizing any matrix as UΣV^T with orthogonal U, V and non-negative singular values. Math & Statistics for ML
SIP: Session Initiation Protocol: text-based signaling that creates, modifies and ends sessions. IMS, VoLTE & VoWiFi
SIP: Session Initiation Protocol; the signalling protocol that sets up and tears down IMS calls. Trace a Path Through the Android Stack
SIP INVITE: SIP request that starts a session; carries the SDP offer for media. CS & IMS Call Flows
Situational leadership: Adapting leadership style (direct, coach, support, delegate) to a person's competence and commitment. Leadership, Delivery & Behavioral
size_t: Unsigned type of object sizes; result of sizeof and the usual malloc/strlen type. C Language
sk_buff: Linux socket buffer; the packet object in the kernel stack. Android Data Call: Control, netd, eBPF & Packets
Skewness: A measure of asymmetry of a distribution; positive means a longer right tail. Math & Statistics for ML
Skin temperature: Estimated temperature of the device surface the user touches, often a virtual sensor. Power, Thermal & Battery
Skip-gram: Word2vec variant that predicts context words from a centre word. Deep Learning & Neural Networks
Skip-gram: The word2vec variant that predicts surrounding context words from the center word. NLP Fundamentals
SLA, SLO, SLI: Contractual promise, internal target, and measured indicator of service quality. System Design
slicing: Copying a derived object into a base value, losing the derived part and virtual behavior. C++ Language
Sliding window: Technique that maintains a contiguous range with two indices that only move forward. Data Structures & Algorithms
Sliding-window attention: Attention restricted to the most recent W tokens, bounding KV-cache memory. Edge AI Deployment & Projects
Sliding-window attention: Local attention in which each token attends only to the previous w tokens. Transformers & Large Language Models
SM-DP+: Subscription Manager Data Preparation: server that prepares and delivers eSIM profiles. Android Telephony, RIL & Modem
SM-DP+: Carrier-side server that prepares and delivers eSIM profiles. Wear OS Platform
SMF: Session Management Function; manages PDU sessions and controls UPFs. 5G NR & 5G Core
SMF: Session Management Function; 5G owner of PDU sessions. Android Data Call: Control, netd, eBPF & Packets
Smoothing: Techniques that reserve probability mass for unseen n-grams in count-based language models. NLP Fundamentals
SmoothQuant: A technique that divides activation channels and multiplies weight rows by the same factor to move outliers into weights, enabling W8A8. Edge AI Fundamentals
SMOTE: Synthetic Minority Over-sampling Technique; creates minority points by interpolating between neighbours. Machine Learning Fundamentals
SMR: Security Maintenance Release; an OEM or vendor update that delivers security bulletin patches. Cadence is a product choice; the Android security bulletin itself is monthly. Platform Integration & Release
Snowflake ID: 64-bit roughly time-ordered unique ID built from a timestamp, machine ID and sequence number. System Design
snprintf: Bounded formatted write that NUL-terminates when the size is not zero; return is the untruncated length. C Language
Socket: Bidirectional endpoint. Internet sockets span hosts; UNIX-domain sockets span processes on one host with a filesystem or abstract name. Operating System Concepts
Soft reboot: Restart of the framework (system_server and Zygote) without restarting the kernel. Android Frameworks Internals
Soft reference: A reference cleared under memory pressure, used for caches that should yield to the collector. Java Language
softirq: Deferred kernel interrupt processing; NAPI poll and much of TCP input run here. Android Data Call: Control, netd, eBPF & Packets
Softirq: Statically defined bottom-half mechanism for high-rate kernel work; runs in atomic context. Linux Kernel & BSP
Softmax: Function that turns a vector of logits into a probability distribution summing to 1. Deep Learning & Neural Networks
Softmax: A function that turns a vector of logits into positive probabilities summing to 1: e^z_i/Σe^z_j. Math & Statistics for ML
Solicited response: HAL reply to a specific framework request, correlated by serial. Binder IPC & AIDL
Soong: Primary AOSP userspace build system; modules are declared in Android.bp. Platform Integration & Release
Span: One timed operation within a trace, such as an LLM call, tool call or retrieval, with inputs, outputs and metadata. Agentic AI & Multi-Agent Systems
Span corruption: T5's objective of replacing spans with sentinel tokens and generating the missing spans. Transformers & Large Language Models
Sparse retrieval: Retrieval using high-dimensional, mostly-zero term vectors such as TF-IDF or BM25. Retrieval-Augmented Generation (RAG)
Specificity: TN / (TN + FP): fraction of actual negatives correctly identified. Machine Learning Fundamentals
Speculative decoding: A draft model (or extra heads / n-grams) proposes tokens that the target verifies in one pass. Expected tokens per pass = (1 − α^k+1) / (1 − α). Output distribution is unchanged. Edge AI Deployment & Projects
Speculative decoding: A draft model proposes tokens that the main model verifies in parallel, speeding decode without changing outputs. Edge AI Fundamentals
Speculative decoding: A draft model proposes several tokens, and the target model verifies them in one pass, speeding up decoding without changing the output distribution. GenAI System Design & Case Studies
Speculative decoding: A draft model proposes several tokens that the large model verifies in parallel, speeding generation without changing outputs. Transformers & Large Language Models
Spinlock: Busy-waiting lock for short critical sections; holder must not sleep. Linux Kernel & BSP
SpinQuant: A quantization method that applies learned rotations to weights and activations to spread outliers before low-bit quantization. Edge AI Deployment & Projects
SPLADE: A learned sparse retriever that produces weighted, expanded vocabulary vectors usable with inverted indexes. Retrieval-Augmented Generation (RAG)
Split brain: Failure where two nodes both believe they are the leader and accept conflicting writes. System Design
Spotlighting: Making untrusted input distinguishable from instructions through delimiting, datamarking or encoding, to reduce injection. Prompt Engineering
SPS: Semi-Persistent Scheduling: a periodic radio grant (usually every 20 ms) used for VoLTE instead of a fresh DCI every TTI. IMS, VoLTE & VoWiFi
SQNR: Signal-to-quantization-noise ratio in decibels, comparing reference tensor energy with quantization error energy. Edge AI Deployment & Projects
SQNR: Signal-to-quantization-noise ratio in decibels; a standard per-tensor measure of quantization damage. Edge AI Fundamentals
Squad: A small cross-functional team owning end-to-end outcomes from a shared backlog. Leadership, Delivery & Behavioral
SRVCC: Single Radio Voice Call Continuity: hands an active VoLTE call over to CS. Android Telephony, RIL & Modem
SRVCC: Single Radio Voice Call Continuity: hands an active IMS call to CS when leaving VoLTE coverage. CS & IMS Call Flows
SRVCC: Single Radio Voice Call Continuity: hands an active IMS call to the 2G/3G CS domain. IMS, VoLTE & VoWiFi
SSB: Synchronization Signal / PBCH block used for cell search and beam selection. 5G NR & 5G Core
SSC mode: Session and Service Continuity mode (1, 2, 3) controlling anchor UPF changes. 5G NR & 5G Core
SSO: Small string optimization: short strings stored inside the std::string object instead of on the heap. C++ Language
SSR: Subsystem Restart: Qualcomm mechanism to crash-dump and restart the modem without rebooting the phone. Android Telephony, RIL & Modem
Stable AIDL: AIDL interfaces with frozen versions for boundaries that update independently, such as HALs. Binder IPC & AIDL
Stable sort: A sort that preserves the relative order of elements with equal keys. Data Structures & Algorithms
Stacking: Ensemble in which a meta-model learns to combine base models' out-of-fold predictions. Machine Learning Fundamentals
Stampede: Many requests missing the cache at once and overloading the backing store (thundering herd). System Design
Standalone watch app: A watch app that declares it can run without the phone (com.google.android.wearable.standalone true). Wear OS Platform
Standard deviation: The square root of variance, expressed in the data's units. Math & Statistics for ML
Standard error: The standard deviation of an estimator across repeated samples, e.g. σ/√n for the mean. Math & Statistics for ML
STAR: Situation, Task, Action, Result: a structure for behavioral interview answers, often plus Learning. Leadership, Delivery & Behavioral
Starvation: A thread waits unbounded while others proceed. Priority without aging and some readers-writers policies are typical causes. Operating System Concepts
State: The shared data structure passed between steps or agents in a run, such as messages, plan and findings. Agentic AI & Multi-Agent Systems
State bloat: Uncontrolled growth of shared history that saturates the context window and raises cost and latency. Agentic AI & Multi-Agent Systems
State machine: A model of computation with a finite set of states and explicit transition rules, used to constrain agent control flow. Agentic AI & Multi-Agent Systems
State of charge (SOC): Remaining battery charge as a percentage of current full capacity. Power, Thermal & Battery
State of health (SOH): Current full capacity relative to the original design capacity. Power, Thermal & Battery
state_dict: Dictionary mapping a PyTorch model's or optimizer's parameter names to tensors; the recommended save format. Python & Data Tools for ML
static: Keyword meaning internal linkage (file scope) or static storage duration (block scope), depending on where it appears. C Language
Static library: Archive (.a) of object files. The linker copies only the members it needs. C Language
Static quantization: Quantization with activation scales fixed ahead of time from calibration; required by most NPUs. Edge AI Deployment & Projects
Static quantization: Quantization where activation scales are fixed ahead of time from calibration data. Edge AI Fundamentals
Static shapes: Tensor dimensions fixed at export/compile time, allowing NPU compilers to plan memory and tiling. Edge AI Deployment & Projects
Status of record: The single authoritative source of program status that everyone trusts. Leadership, Delivery & Behavioral
Stemming: Stripping affixes with heuristic rules to reach a crude root form that may not be a real word. NLP Fundamentals
Step-back prompting: Asking a broader question first to retrieve general principles before answering a specific one. Retrieval-Augmented Generation (RAG)
STL: Standard Template Library: containers, iterators, algorithms (and, loosely, the rest of the C++ standard library). C++ Language
STN-SR: Session Transfer Number for SRVCC: routes the MSC server's transfer INVITE to the SCC-AS or ATCF. IMS, VoLTE & VoWiFi
Stop sequence: A string that ends generation as soon as the model produces it. LLM APIs, Structured Outputs & Tool Calling
Stop sequence: A string that makes the server end generation when it is produced, such as "Observation:" or a turn marker. Prompt Engineering
Stop words: Very frequent function words often removed in classical pipelines. NLP Fundamentals
Storage duration: How long an object lives: automatic (stack), static (process), or allocated (heap until free). C Language
Straight-through estimator: A QAT trick that treats rounding as the identity in the backward pass so gradients can flow. Edge AI Fundamentals
Stratification: Splitting data so each part keeps the same class proportions as the whole. Python & Data Tools for ML
Strict aliasing: Informal name for effective-type rules: accessing an object as the wrong type is UB (with exceptions such as char *). C Language
strict aliasing: Rule that an object may be accessed only through a compatible type (plus char/byte exceptions). C++ Language
Strict mode: A structured-output setting that enforces exact conformance to a supplied JSON Schema via constrained decoding. LLM APIs, Structured Outputs & Tool Calling
Stride: Number of positions a convolution or pooling window moves at each step. Deep Learning & Neural Networks
Structured output: Constraining model output to a schema so it can be parsed and validated reliably. Agentic AI & Multi-Agent Systems
Structured outputs: Techniques and API features that make model output machine-readable and schema-conformant. LLM APIs, Structured Outputs & Tool Calling
Structured outputs: API feature that constrains the model to produce JSON matching a supplied schema. Prompt Engineering
STS: Security Test Suite; checks that security bulletin patches are present. Platform Integration & Release
Stub: Generated server-side base class that receives transactions. Binder IPC & AIDL
STW: Stop-the-world: mutator threads paused at safepoints for a GC phase. Java Language
Subword tokenization: Splitting text into units between characters and words so frequent words stay whole and rare words decompose into known pieces. NLP Fundamentals
SUCI: Subscription Concealed Identifier; encrypted form of the SUPI. 5G NR & 5G Core
super: Physical partition that contains resizable logical partitions such as system, vendor and product. Android Boot Process
Supervised fine-tuning (SFT): Training on curated input-output demonstrations with the standard next-token loss. Transformers & Large Language Models
Supervisor: A central agent that routes work to specialists, collects their results and decides the next step or final answer. Agentic AI & Multi-Agent Systems
SUPI: Subscription Permanent Identifier, usually the IMSI. 5G NR & 5G Core
Support vectors: Training points on or inside the SVM margin that define the boundary. Machine Learning Fundamentals
SurfaceFlinger: Native compositor process that combines window buffers and sends them to the display via HWC. Android Frameworks Internals
SurfaceFlinger: Android's system compositor, which combines layers and sends frames to the display. Trace a Path Through the Android Stack
Suspend blocker: Android's original kernel mechanism for preventing opportunistic suspend; replaced by wakeup sources. Power, Thermal & Battery
Suspend residency: Share of time the system spends suspended; the key standby power metric. Power, Thermal & Battery
Suspend-to-RAM: System sleep state with DDR in self-refresh and most of the SoC powered down. Power, Thermal & Battery
Sustained-to-peak ratio: Throughput after a long run divided by initial throughput; captures the effect of thermal throttling. Edge AI Deployment & Projects
SVM: Support vector machine: maximum-margin classifier, extendable with kernels. Machine Learning Fundamentals
Swarm: A decentralized multi-agent topology where agents hand control directly to one another without a central supervisor. Agentic AI & Multi-Agent Systems
SWE-bench: A benchmark where agents must resolve real repository issues by producing patches that pass hidden tests. Agentic AI & Multi-Agent Systems
SwiGLU: Gated feed-forward activation W₂(SiLU(W₁x) ⊙ W₃x); hidden width is set near 8d/3 to keep the parameter count equal to a 4d MLP. Deep Learning & Neural Networks
SwiGLU: Gated FFN variant: W₂(SiLU(W₁x) ⊙ W₃x), used in most modern LLMs. Transformers & Large Language Models
Sycophancy: Tendency of a model to agree with or flatter the user rather than be accurate. Fine-Tuning & Alignment
Sycophancy: A model's tendency to agree with the user's views or false premises instead of being accurate. LLM Evaluation, Safety & Responsible AI
Symbolic link: A small file storing a path. It may dangle, may cross filesystems, and is resolved at use time. Operating System Concepts
Sync barrier: Special message that blocks synchronous messages so asynchronous ones (frame work) run first. Android Frameworks Internals
Synthetic data: Training examples generated or rewritten by a model rather than written by people. Fine-Tuning & Alignment
System call: The stable, numbered kernel API. Userspace traps; the kernel validates arguments and performs the privileged work. Operating System Concepts
System message: The highest-priority instruction message setting persona, rules and format. LLM APIs, Structured Outputs & Tool Calling
System prompt: The highest-priority instructions in a conversation, setting identity, behaviour, format and safety rules. Prompt Engineering
system_server: The process, forked from Zygote, that hosts most Android framework services. Android Boot Process
system_server: The privileged Java process hosting most Android system services. Android Frameworks Internals
SystemSuspend: Android userspace service (suspend HAL) that tracks native wakelocks and triggers kernel suspend. Power, Thermal & Battery

T

T-shaped engineer: Someone with deep expertise in one area and broad working knowledge of neighbouring areas. Leadership, Delivery & Behavioral
t-SNE: Non-linear visualization method preserving local neighbourhoods in 2D or 3D. Machine Learning Fundamentals
T3346 / T3396: 3GPP back-off timers (mobility congestion / per-APN session management). Framework must honour them. Android Data Call: Control, netd, eBPF & Packets
Tabulation: Bottom-up DP that fills a table iteratively in dependency order. Data Structures & Algorithms
TAI list: List of tracking areas forming a UE's registration area. 5G NR & 5G Core
Tail latency: The slowest requests, measured by high percentiles such as p99. System Design
Target modules: The layers (for example q_proj, v_proj, gate_proj) that receive LoRA adapters. Fine-Tuning & Alignment
TAS: Telephony Application Server: runs MMTel supplementary services. IMS, VoLTE & VoWiFi
Task affinity: String naming the task an activity prefers to live in; default is the package name. Android Frameworks Internals
Task vector: Difference between fine-tuned and base weights, used for task arithmetic. Fine-Tuning & Alignment
Tasklet: Simple deferred-work mechanism built on softirqs; cannot sleep. Linux Kernel & BSP
TAU: Tracking Area Update: NAS procedure when the UE enters a new TA or when periodic timer T3412 expires. Android Telephony, RIL & Modem
tau-bench: A benchmark of tool-using agents interacting with simulated users under domain policies, scored by final database state. Agentic AI & Multi-Agent Systems
TCI state: Transmission Configuration Indicator; tells the UE which reference beam to assume. 5G NR & 5G Core
TDD: Time Division Duplex; uplink and downlink share a frequency at different times. 5G NR & 5G Core
Teacher forcing: Feeding the true previous token to a decoder during training. Deep Learning & Neural Networks
Teacher forcing: Training by feeding the true previous tokens rather than the model's own predictions. Fine-Tuning & Alignment
Teacher forcing: Feeding the true previous output token to a decoder during training rather than its own prediction. NLP Fundamentals
Teacher forcing: Training a sequence model by always feeding the true previous tokens rather than its own predictions. Transformers & Large Language Models
TelecomServiceImpl: system_server implementation of ITelecomService, behind TelecomManager. CS & IMS Call Flows
TelephonyConnection: Telecom Connection subclass wrapping an internal telephony connection and mapping its state. CS & IMS Call Flows
TelephonyConnectionService: Telephony's ConnectionService in com.android.phone; creates cellular connections and calls Phone.dial(). CS & IMS Call Flows
TelephonyNetworkFactory: Offers cellular Networks to ConnectivityService; live on the preferred data subscription. Android Data Call: Control, netd, eBPF & Packets
TelephonyRegistry: System service that publishes telephony state to registered TelephonyCallbacks. Android Telephony, RIL & Modem
Temperature: A value that divides logits before softmax, controlling randomness in sampling. LLM APIs, Structured Outputs & Tool Calling
Temperature: A divisor applied to logits before softmax that controls how sharp or flat the output distribution is. Math & Statistics for ML
Temperature: Decoding parameter that divides logits before softmax; low values make output more deterministic, high values more varied. Prompt Engineering
Temperature: Divisor applied to logits before softmax that controls how peaked or flat the sampling distribution is. Transformers & Large Language Models
Tenant isolation: Guaranteeing that one customer's data, context and cache cannot reach another customer. GenAI System Design & Case Studies
Tensor: A multi-dimensional array, such as a (batch, tokens, features) activation. Math & Statistics for ML
Tensor: PyTorch's n-dimensional array, which can live on CPU or GPU and can track gradients. Python & Data Tools for ML
Tensor arena: The fixed, pre-allocated SRAM buffer holding all activations in LiteRT for Microcontrollers. Edge AI Fundamentals
Tensor parallelism: Splitting each layer's matrix operations across GPUs to fit large models and reduce per-token latency. GenAI System Design & Case Studies
TensorRT: NVIDIA's inference optimizer and runtime that builds device-specific engines with fusion and low precision. Edge AI Fundamentals
Tentative definition: File-scope declaration that may become a zeroed definition if no real definition appears in the unit. C Language
Test-time compute: Extra computation spent at inference (longer reasoning, sampling, search) to improve answers. Transformers & Large Language Models
Text segment: The executable code portion of the image, usually mapped read-only and shareable. C Language
Text-to-SQL: Having an LLM generate SQL from a natural-language question, typically with retrieved schema context. Retrieval-Augmented Generation (RAG)
TF-IDF: Term frequency multiplied by inverse document frequency; weights words that are frequent in a document but rare in the corpus. NLP Fundamentals
TF-IDF: Term frequency times inverse document frequency: a term weight that favours words frequent in a document but rare in the corpus. Retrieval-Augmented Generation (RAG)
TFT: Traffic Flow Template: packet filters mapping IP flows onto a bearer. IMS, VoLTE & VoWiFi
Thermal engine: Vendor thermal policy daemon or component implementing multi-sensor mitigation rules. Power, Thermal & Battery
Thermal HAL: HAL that reports temperatures, thresholds and throttling severity to the framework. Power, Thermal & Battery
Thermal headroom: Android's forecast of how close the device is to severe throttling, from PowerManager.getThermalHeadroom(). Edge AI Deployment & Projects
Thermal headroom: An OS forecast of how close the device is to thermal throttling, used to degrade workloads gracefully. Edge AI Fundamentals
Thermal soak: A long continuous workload (10-30 minutes) used to measure throttling and sustained performance. Edge AI Deployment & Projects
Thermal throttling: The OS lowering clock speeds to limit heat, reducing sustained performance. Edge AI Fundamentals
Thermal zone: Kernel object for a temperature sensor with trip points and bound cooling devices. Power, Thermal & Battery
this-adjustment: Pointer offset applied when converting to a non-primary base or when dispatching a virtual call through that base. C++ Language
Thought: In ReAct, the model's intermediate reasoning text that decides what to do next; it changes only the context. Agentic AI & Multi-Agent Systems
Thrashing: The system spends its time paging rather than running. Working sets do not fit in RAM; CPU utilisation falls while the disk is busy. Operating System Concepts
Thread: A schedulable execution context: registers, stack, TLS, inside a process's address space. Operating System Concepts
ThreadLocal: A per-thread variable; must be removed on pooled threads or it leaks across tasks. Java Language
TIES merging: Merging method that trims small deltas, elects a sign per parameter and averages agreeing deltas. Fine-Tuning & Alignment
Tile: Swipeable, glanceable card next to the watch face, rendered by the system from an app-provided layout. Wear OS Platform
Time per output token (TPOT): The average time between generated tokens during streaming. It is the inverse of tokens per second. GenAI System Design & Case Studies
Time to first token (TTFT): The time from sending a request to receiving the first generated token, covering queueing and prefill. GenAI System Design & Case Studies
Time to first token (TTFT): The delay between sending a request and receiving the first generated token. LLM APIs, Structured Outputs & Tool Calling
TimSort: Hybrid stable sort combining merge sort and insertion sort on natural runs; used by Python and Java for objects. Data Structures & Algorithms
TinyML: Machine learning on microcontrollers with kilobytes of memory and milliwatt power budgets. Edge AI Fundamentals
TLB: Translation Lookaside Buffer: cache of recent virtual-to-physical translations. Linux Kernel & BSP
TLB: Translation lookaside buffer: a small cache of virtual-to-physical translations. Hit rate dominates effective memory access time. Operating System Concepts
TOCTOU: Time-of-check to time-of-use: a race between validating a path (or other name) and operating on it. Bind check and use to one kernel object (an fd). Operating System Concepts
Toil: Repetitive, manual, automatable work that does not add lasting value. Leadership, Delivery & Behavioral
Token: The sub-word unit models read and write; the unit of billing, rate limits and context length. LLM APIs, Structured Outputs & Tool Calling
Token: The basic unit a model processes: a word, subword, character or byte. NLP Fundamentals
Token: The unit of text a model reads and writes, typically a subword piece mapped to an integer ID. Transformers & Large Language Models
Token bucket: A rate-limiting algorithm in which requests consume tokens that refill at a fixed rate. LLM APIs, Structured Outputs & Tool Calling
Token bucket: Rate-limiting algorithm where tokens refill at a steady rate and each request consumes one, allowing bursts. System Design
Token-based rate limiting: Limiting usage by tokens per minute rather than requests, reflecting the real cost and load. GenAI System Design & Case Studies
Tokenizer: The component that converts text to token IDs and back; each model family has its own. LLM APIs, Structured Outputs & Tool Calling
Tokenizer: Component that converts text into integer token IDs (and back) for a specific language model. Python & Data Tools for ML
Tokenizer fertility: The average number of tokens a tokenizer produces per word; higher fertility means higher cost and shorter effective context. NLP Fundamentals
Tool: A function or API the agent can request, described by a name, description and parameter schema. Agentic AI & Multi-Agent Systems
Tool hallucination: Calling non-existent tools, mixing up schemas or inventing arguments, common when an agent has too many tools. Agentic AI & Multi-Agent Systems
Tool message: A message carrying the result of an executed tool, linked to the originating call by its ID. LLM APIs, Structured Outputs & Tool Calling
Tool poisoning: Hiding malicious instructions in a tool's description or metadata so the model follows them. Agentic AI & Multi-Agent Systems
tool_choice: A parameter controlling whether the model may, must, or must not call tools, or must call a specific one. LLM APIs, Structured Outputs & Tool Calling
Top-k sampling: Sampling only from the k most probable next tokens. LLM APIs, Structured Outputs & Tool Calling
Top-k sampling: Sampling only from the k most probable next tokens after renormalising. Transformers & Large Language Models
Top-p (nucleus sampling): Sampling from the smallest set of tokens whose cumulative probability reaches p. Prompt Engineering
Top-p (nucleus) sampling: Sampling only from the smallest set of tokens whose cumulative probability reaches p. LLM APIs, Structured Outputs & Tool Calling
Top-p (nucleus) sampling: Sampling from the smallest set of tokens whose cumulative probability reaches p. Transformers & Large Language Models
Topic coherence: A score of how semantically related the top words of a topic are, used to compare topic models. NLP Fundamentals
Topological sort: Linear ordering of a DAG's vertices so every edge points forward. Data Structures & Algorithms
TOPS: Trillions of operations per second; a peak compute figure, usually for INT8. Edge AI Fundamentals
torch.export: PyTorch's ahead-of-time graph capture producing an ExportedProgram with no Python control flow, used by ExecuTorch and ai-edge-torch. Edge AI Deployment & Projects
Trace: The full recorded tree of spans for one agent run, used for debugging, evaluation and audit. Agentic AI & Multi-Agent Systems
Trace: End-to-end record of one request as a tree of spans covering prompts, retrieval, model and tool calls. LLM Evaluation, Safety & Responsible AI
Tradefed: Trade Federation; the Android test harness used to run xTS and device tests. Platform Integration & Release
TrafficDescriptor: URSP match key (application id, DNN, IP descriptors, connection capabilities) carried into setup and the HAL result. Android Data Call: Control, netd, eBPF & Packets
TrafficStats: SDK API for per-UID bytes/packets; backend moved from xt_qtaguid to eBPF maps. Android Data Call: Control, netd, eBPF & Packets
Training–serving skew: Mismatch between features computed in training and in production. Machine Learning Fundamentals
Trajectory: The sequence of thoughts, actions and observations an agent took during a run. Agentic AI & Multi-Agent Systems
Transaction: One SIP request and all its responses, matched by the Via branch and CSeq. IMS, VoLTE & VoWiFi
TransactionTooLargeException: Error when a transaction cannot fit in the receiver's Binder buffer. Binder IPC & AIDL
Transfer learning: Reusing a model trained on one task as the starting point for another. Deep Learning & Neural Networks
transform (groupby): pandas group operation that returns a result aligned to the original rows, such as each row's share of its group total. Python & Data Tools for ML
Transformer (scikit-learn): An estimator with a transform method, such as a scaler, encoder or imputer. Python & Data Tools for ML
Translation unit: A source file after preprocessing: what the compiler actually compiles. C Language
translation unit: The text the compiler sees: one source file after preprocessing includes and macros. C++ Language
Transliteration: Writing a language in another script, such as Hindi in Latin letters. NLP Fundamentals
Trap: A deliberate synchronous transfer to the kernel (syscall, breakpoint), as opposed to an unexpected fault or an asynchronous IRQ. Operating System Concepts
Trap representation: A bit pattern that is not a valid value of the type. Reading it can be UB (more relevant historically for some integers). C Language
Treble: Android 8.0 architecture that separates the framework from vendor code with stable HAL interfaces. Android Frameworks Internals
Treble: Android architecture separating the framework (system) from vendor implementation. Linux Kernel & BSP
Treble: Android architecture that separates framework and vendor code behind stable interfaces. Platform Integration & Release
Tree of Thoughts: A reasoning method that explores multiple candidate steps as a search tree with evaluation and backtracking. Agentic AI & Multi-Agent Systems
Tree of thoughts: Reasoning as search: propose several partial thoughts, evaluate them, expand promising ones and backtrack from dead ends. Prompt Engineering
Treeify: Java 8+ HashMap conversion of a long collision chain into a red-black tree, only when the bin has 8+ entries and the table capacity is at least 64. Data Structures & Algorithms
Trie: Prefix tree storing strings character by character along root-to-node paths. Data Structures & Algorithms
Trip point: Temperature threshold in a thermal zone that triggers cooling or shutdown. Power, Thermal & Battery
TRL: Hugging Face library of trainers for SFT, reward modelling, DPO, PPO, GRPO and related methods. Fine-Tuning & Alignment
TrustZone: Arm hardware security extension that isolates a secure world from the normal world. Android Boot Process
TrustZone: Arm's secure-world technology; runs the trusted execution environment as non-HLOS firmware. Platform Integration & Release
TSan: ThreadSanitizer: detects data races in instrumented builds. C Language
TTFT: Time to first token: from prompt submission to the first generated token appearing. Edge AI Deployment & Projects
TTFT: Time to first token: delay from submitting a prompt to receiving the first generated token. Edge AI Fundamentals
TTID / TTFD: Time to initial display (first frame) and time to full display (reportFullyDrawn()). Android Frameworks Internals
TTID / TTFD: Time to initial display and time to full display; standard app start-up metrics. Trace a Path Through the Android Stack
TUN: Virtual iface used by VpnService; typically the default Network while the tunnel egresses on Wi-Fi or cellular. Android Data Call: Control, netd, eBPF & Packets
Two pointers: Technique using two indices that move through data, often from both ends, to avoid nested loops. Data Structures & Algorithms
Type 1 / Type 2 decision: Hard-to-reverse (one-way door) versus easily reversible (two-way door) decisions. Leadership, Delivery & Behavioral
type erasure: Hiding a concrete callable or type behind a uniform interface (std::function, any) at the cost of indirection. C++ Language
Type I / Type II error: Rejecting a true null (false positive) / failing to reject a false null (false negative). Math & Statistics for ML

U

UAC: Unified Access Control (5G): barring of access attempts by category and identity; LTE used AC barring / SSAC. Android Telephony, RIL & Modem
UB: Undefined behavior: the standard imposes no requirements; compilers may assume it never happens. C++ Language
UBSan: UndefinedBehaviorSanitizer: runtime checks for many kinds of language UB. C Language
uclamp: Utilization clamp: per-task or per-cgroup min and max utilization that steers EAS and schedutil. Power, Thermal & Battery
UDM / UDR: Unified Data Management and its repository; the 5G equivalent of the HSS. 5G NR & 5G Core
ueventd: Daemon that creates /dev nodes from kernel uevents, applies permissions and serves firmware requests. Android Boot Process
ueventd: Android daemon that creates /dev nodes and loads firmware in response to kernel uevents. Linux Kernel & BSP
UFS: Universal Flash Storage. Serial, full-duplex storage with a SCSI command queue, much faster than eMMC. Android Boot Process
ufunc: NumPy universal function that operates element-wise on arrays in compiled code. Python & Data Tools for ML
UICC / USIM / ISIM: The smart card and its 3GPP and IMS applications. Android Telephony, RIL & Modem
UID: User identifier on a UNIX-style process. Compared with object ownership and mode bits (or ACLs) on each privileged operation. Operating System Concepts
UMAP: Fast non-linear dimensionality reduction preserving local and some global structure. Machine Learning Fundamentals
Undefined behaviour: The standard imposes no requirements. Compilers may assume it never happens and optimise accordingly. C Language
Underfitting: A model too simple or undertrained to capture the patterns, with high training and validation error. Deep Learning & Neural Networks
Underfitting: Model too simple to capture the pattern; high error on training and validation data. Machine Learning Fundamentals
Unigram tokenization: A subword method that starts with a large vocabulary and prunes tokens whose removal least reduces corpus likelihood. NLP Fundamentals
Union-Find: Disjoint set union structure supporting near-constant-time find and union of groups. Data Structures & Algorithms
unique_ptr: Move-only smart pointer with exclusive ownership and a possibly empty deleter (EBO). C++ Language
Universal approximation theorem: Result that a sufficiently wide one-hidden-layer network can approximate any continuous function on a bounded domain. Deep Learning & Neural Networks
UNKNOWN_TRANSACTION: Status returned when a transaction code is not implemented by the server. Binder IPC & AIDL
Unspecified behaviour: The standard gives a set of allowed outcomes and does not require the choice to be documented. C Language
update_engine: On-device daemon that downloads, verifies and applies OTA payloads to the inactive slot. Platform Integration & Release
update_engine: The daemon that downloads, verifies and applies A/B OTA payloads. Trace a Path Through the Android Stack
UPF: User Plane Function; forwards user packets and enforces QoS. 5G NR & 5G Core
UPF: User Plane Function; 5G gateway that terminates N3 GTP-U and forwards on N6. Android Data Call: Control, netd, eBPF & Packets
Upstream-first: Policy of contributing changes to AOSP or Linux before, or instead of, carrying them privately. Platform Integration & Release
URLLC: Ultra-Reliable Low-Latency Communication. 5G NR & 5G Core
URSP: UE Route Selection Policy; rules mapping app traffic to slices, DNNs and sessions. 5G NR & 5G Core
URSP: UE Route Selection Policy; rules from the PCF that map traffic to a DNN, slice and session. Android Data Call: Control, netd, eBPF & Packets
Usage: The response block reporting input, cached, output and reasoning token counts for billing and monitoring. LLM APIs, Structured Outputs & Tool Calling
Usage setting: UE policy, voice-centric or data-centric, that decides whether the UE may stay on 5GS without IMS voice. Not the network IMS VoPS indication. 5G NR & 5G Core
Usage setting: UE policy, voice-centric or data-centric, that decides whether the UE may stay on a RAT that cannot provide voice. Not the same as the network IMS VoPS indication. IMS, VoLTE & VoWiFi
USAP: Unspecialized App Process: a pre-forked Zygote child waiting to become an app. Android Frameworks Internals
useImsForCall(): GsmCdmaPhone check deciding whether to attempt the call over IMS. CS & IMS Call Flows
User mode: Unprivileged CPU mode in which applications run. Privileged instructions and direct device access are forbidden. Operating System Concepts
Userspace reboot: Android 11+ restart of init and all userspace without bringing down the kernel (faster than a cold reboot). Android Boot Process
Usual arithmetic conversions: Rules that convert both operands of a binary operator to a common type after promotions. C Language
Ut: Interface between the UE and the TAS/XCAP server for supplementary service settings. IMS, VoLTE & VoWiFi

V

VAE: Variational autoencoder: an autoencoder with a probabilistic latent space regularized toward a standard normal. Deep Learning & Neural Networks
Valgrind: Dynamic analysis suite; memcheck interprets the binary and finds many memory errors without a special compile. C Language
VALIDATED: NetworkCapabilities flag set after a successful connectivity probe (and related checks). Android Data Call: Control, netd, eBPF & Packets
Vanishing gradient: Gradients shrinking exponentially toward early layers or time steps, stalling their learning. Deep Learning & Neural Networks
Vanishing gradient: Gradients shrinking exponentially as they propagate back through many steps or layers, preventing early inputs from being learned. NLP Fundamentals
Variance: The expected squared deviation from the mean. Math & Statistics for ML
Variance (model): Sensitivity of the learned model to the particular training sample. Machine Learning Fundamentals
vbmeta: Signed AVB metadata partition with descriptors for every verified partition. Android Boot Process
vdex: Verified dex: ART's cache of verification results so boot and load do not re-verify every time. Java Language
Vector database: A system that stores vectors with text and metadata and serves filtered nearest-neighbour queries with persistence and operations. Retrieval-Augmented Generation (RAG)
Vectorization: Expressing computation as whole-array operations instead of explicit Python loops. Python & Data Tools for ML
Vendor API level: The API level the vendor partition was built against (ro.vendor.api_level); may lag the system API inside a freeze window. Platform Integration & Release
vendor_boot: Partition with the vendor ramdisk, DTB, early kernel modules and vendor bootconfig (Android 11+). Android Boot Process
Verbalized sampling: Asking a model for several candidate responses with stated probabilities and sampling from them, to counter mode collapse. Prompt Engineering
Verbosity bias: A judge's tendency to prefer longer answers regardless of quality. LLM Evaluation, Safety & Responsible AI
Version vector: Per-replica counters used to tell whether two updates happen-before each other or conflict. System Design
VFS: Virtual filesystem: the kernel's uniform layer so open/read work the same for disk filesystems, pipes, sockets and pseudo-filesystems. Operating System Concepts
View: An array object that shares memory with another array, created for example by basic slicing. Python & Data Tools for ML
ViLTE: Video over LTE: IMS video calling with a dedicated video bearer. IMS, VoLTE & VoWiFi
VINTF: Vendor Interface object: manifests and compatibility matrices that declare and check HAL versions. Android Frameworks Internals
VINTF: Vendor Interface object: manifests and compatibility matrices that declare which HALs a device provides. Android Telephony, RIL & Modem
VINTF: Vendor interface manifests and compatibility matrices declaring HAL names and versions. Binder IPC & AIDL
VINTF: Vendor Interface objects: manifests and compatibility matrices checked between system and vendor. Linux Kernel & BSP
VINTF: Vendor Interface object; manifests and compatibility matrices that declare and check HAL versions. Platform Integration & Release
VINTF: Vendor Interface object; manifests and compatibility matrices that check framework and vendor HAL versions match. Trace a Path Through the Android Stack
Virtual A/B: A/B updates using copy-on-write snapshots of a single copy of dynamic partitions, merged after success. Android Boot Process
Virtual A/B: A/B updates that snapshot dynamic partitions with copy-on-write instead of storing a full second copy of super. Platform Integration & Release
Virtual A/B: A/B scheme where dynamic partitions use copy-on-write snapshots instead of full second copies. Trace a Path Through the Android Stack
Virtual A/B: A/B updates implemented with snapshots instead of full duplicate partitions, saving flash. Wear OS Platform
Virtual environment: An isolated folder with its own Python interpreter and packages for one project. Python & Data Tools for ML
Virtual memory: Demand-paged, isolated address spaces larger than RAM, backed by frames plus a backing store, translated by the MMU. Operating System Concepts
Vision Transformer (ViT): Transformer encoder applied to sequences of image patches. Transformers & Large Language Models
vLLM: An open-source LLM serving engine built on paged attention and continuous batching, with an OpenAI-compatible API. GenAI System Design & Case Studies
vLLM: An open-source high-throughput inference server for LLMs with an OpenAI-compatible API. LLM APIs, Structured Outputs & Tool Calling
vndbinder: Binder domain (/dev/vndbinder) for vendor-to-vendor IPC, managed by vndservicemanager. Binder IPC & AIDL
VNDK: Vendor Native Development Kit: system libraries vendor code may use with a stable ABI. Android Frameworks Internals
void*: Generic object pointer. Convertible to other object pointers in C; not dereferenceable; not a portable function-pointer box. C Language
volatile: Qualifier requiring that accesses to that lvalue are not elided. Not a concurrency tool. C Language
Volatile: A field modifier that inserts happens-before between a write and a later read of that field, and forbids certain reorderings. Java Language
VoLTE: Voice over LTE, carried over IMS. Wear OS Platform
VoLTE / VoNR / VoWiFi: IMS voice over LTE, over 5G NR, and over Wi-Fi. IMS, VoLTE & VoWiFi
VoNR: Voice over NR; IMS voice carried natively on 5G SA. 5G NR & 5G Core
VPN protect: fwmark/socket option that exempts the VPN's own tunnel sockets from the VPN routing table. Android Data Call: Control, netd, eBPF & Packets
Vsync: The display's refresh signal, used to pace rendering and composition. Trace a Path Through the Android Stack
vtable: Per-class table of virtual function pointers (plus RTTI / offset-to-top) used for dynamic dispatch. C++ Language
VTCM: Vector tightly coupled memory: fast on-chip memory in the Hexagon NPU; working sets that exceed it spill to DRAM. Edge AI Deployment & Projects
VTS: Vendor Test Suite; tests HALs, kernel and vendor interfaces. Platform Integration & Release

W

W4A16: A scheme with 4-bit weights and 16-bit activations, common for LLMs on NPUs. Edge AI Deployment & Projects
W4A16: Notation for 4-bit weights with 16-bit activations; similar forms describe other weight/activation precisions. Edge AI Fundamentals
Wait-for graph: Graph of processes waiting on processes. A cycle implies deadlock when each contended resource has a single instance. Operating System Concepts
Wakelock: Request to keep the CPU (and optionally the screen) from sleeping. Power, Thermal & Battery
Wakeup source: Kernel object (wakelock) that prevents system suspend while active. Linux Kernel & BSP
Wakeup source: Kernel object that blocks system suspend while active; the mainline form of a wakelock. Power, Thermal & Battery
Warmup: Gradually increasing the learning rate at the start of training for stability. Deep Learning & Neural Networks
Warmup: Gradually increasing the learning rate from near zero over the first steps of training. Fine-Tuning & Alignment
Watch Face Format (WFF): Declarative XML format for watch faces that the system renders without running app code. Wear OS Platform
Watch Face Push: Wear OS 5 API to install a WFF package on the watch without shipping a watch-side face APK. Wear OS Platform
Watchdog: system_server thread that kills system_server if critical threads or locks are stuck for 60 s. Android Frameworks Internals
Watermelon status: A report that looks green on the outside but hides red problems inside. Leadership, Delivery & Behavioral
WDS: Wireless Data Service; Qualcomm QMI example for PDN/PDU start and stop. Android Data Call: Control, netd, eBPF & Packets
Weak reference: A reference that does not prevent collection; cleared when the object is no longer strongly reachable. Java Language
Weak symbol: A symbol the linker may override with a strong definition, used for interposable defaults. C Language
weak_ptr: Non-owning observer of a shared_ptr control block used to break cycles and test liveness. C++ Language
WearableListenerService: Service that receives Data Layer events even when the app is not running. Wear OS Platform
Weight decay: Shrinking weights toward zero each step; equivalent to L2 regularization for plain SGD. Deep Learning & Neural Networks
Weight tying: Sharing the token-embedding matrix with the output LM head (W_out = E), saving |V|·d parameters. Transformers & Large Language Models
Window token: An IBinder WMS already knows (usually the activity token) that authorizes adding windows. Android Frameworks Internals
WIP limit: A cap on how much work is in progress at once, to reduce context switching and speed completion. Leadership, Delivery & Behavioral
WMS (WindowManagerService): Service managing windows, focus, z-order, rotation and transitions. Android Frameworks Internals
Word2vec: Self-supervised method that learns word embeddings by predicting words from context or context from words. Deep Learning & Neural Networks
word2vec: A family of shallow neural methods (CBOW and skip-gram) that learn static word embeddings from local context windows. NLP Fundamentals
WordPiece: BERT's subword tokenizer, which merges pairs that most increase training likelihood and marks continuations with ##. NLP Fundamentals
WordPiece: BERT's subword tokenizer, which chooses merges by likelihood gain and marks continuations with ##. Transformers & Large Language Models
Work stealing: Idle ForkJoin workers take tasks from other workers' deques; the scheduling model of ForkJoinPool. Java Language
Workflow: A system where code defines a fixed sequence or graph of LLM calls and tools; the model does not choose the path. Agentic AI & Multi-Agent Systems
Working set: The pages a process referenced in the recent window Δ. If working sets do not fit, the system thrashes. Operating System Concepts
WorkManager: Jetpack library for deferrable, guaranteed background work with constraints. Power, Thermal & Battery
Workqueue: Deferred work executed by kernel worker threads in process context; can sleep. Linux Kernel & BSP
Write-ahead log: Append-only durable log of changes written before in-memory state is treated as committed; replayed after a crash. System Design
wwan: Generic kernel subsystem / iface name some SoCs use instead of rmnet or ccmni. Android Data Call: Control, netd, eBPF & Packets

X

X2 / Xn: Direct interface between neighbour base stations used for intra-RAT handover (X2 on LTE, Xn on NR). Android Telephony, RIL & Modem
Xavier initialization: Random weights with variance 2/(fan_in + fan_out), designed for tanh and sigmoid networks. Deep Learning & Neural Networks
XBL / SBL: eXtensible (formerly Secondary) Boot Loader. Trains DDR, loads the secure world and ABL. Android Boot Process
XCAP: XML Configuration Access Protocol: HTTP-based reading and writing of XML settings documents. IMS, VoLTE & VoWiFi
XGBoost: Regularized gradient-boosting library using second-order gradients and sparsity-aware splits. Machine Learning Fundamentals
Xn: Interface between gNBs for handover and dual connectivity. 5G NR & 5G Core
XNNPACK: A highly optimized CPU inference library for Arm and x86 used as the CPU backend by LiteRT, ExecuTorch and ONNX Runtime. Edge AI Deployment & Projects
XNNPACK: A highly optimized CPU inference library used as the default CPU backend by LiteRT, ExecuTorch and ONNX Runtime. Edge AI Fundamentals
xt_bpf: iptables match that runs an eBPF program; leftover on devices still using xtables. Android Data Call: Control, netd, eBPF & Packets
xt_qtaguid: Legacy per-UID tagging and stats module; historical TrafficStats backend. Android Data Call: Control, netd, eBPF & Packets
xTS: Collective name for CTS, VTS, GTS, STS and related suites. Platform Integration & Release
xvalue: eXpiring value: has identity, but resources may be reused (the result of std::move on an object). C++ Language

Z

z-score: The number of standard deviations a value lies from the mean. Math & Statistics for ML
Zero-shot chain-of-thought: Eliciting reasoning with a trigger phrase such as "Let's think step by step" and no examples. Prompt Engineering
Zero-shot cross-lingual transfer: Fine-tuning a multilingual model on one language and applying it to others without target-language labels. NLP Fundamentals
Zero-shot prompting: Asking the model to perform a task from instructions alone, without demonstrations. Prompt Engineering
Zipf's law: In natural language, the r-th most frequent word occurs about 1/r as often as the most frequent word, so most of the vocabulary is rare. NLP Fundamentals
Zombie: A process that has exited but whose parent has not yet waited. The address space is gone; the PID and exit status remain until reap. Operating System Concepts
zRAM: Compressed swap device in RAM that delays memory pressure. Android Frameworks Internals
ZRAM: Compressed RAM block device used as swap on Android. Linux Kernel & BSP
Zygote: Pre-initialized ART process that preloads framework code and forks system_server and every app. The init service is named zygote; a 32-bit helper is zygote_secondary. Android Boot Process
Zygote: Preloaded process that forks system_server and every app process. The init service is named zygote; a 32-bit helper is zygote_secondary. Android Frameworks Internals
Zygote: The warm ART process that preloads classes and forks app processes so they share memory copy-on-write. Java Language
Zygote: A pre-initialised process that forks to create every app process quickly. Trace a Path Through the Android Stack

#

3GPP AAA server: Authenticates and authorises non-3GPP (Wi-Fi) access using EAP-AKA against the HSS. IMS, VoLTE & VoWiFi
464XLAT: CLAT on the customer side plus PLAT (NAT64) in the network so IPv4 sockets work on IPv6-only access. Android Data Call: Control, netd, eBPF & Packets
5G-AKA: 5G Authentication and Key Agreement; challenge-response authentication where the home AUSF verifies the UE's RES*. 5G NR & 5G Core
5G-GUTI: Temporary UE identity assigned by the AMF, used instead of the permanent identity after registration. 5G NR & 5G Core
5GC: 5G Core network, the service-based core used by SA. 5G NR & 5G Core
5GMM / 5GSM: 5G NAS mobility management and session management protocols. 5G NR & 5G Core
5GMM / 5GSM: 5G NAS mobility management (AMF) and session management (SMF). Registration is 5GMM; PDU sessions are 5GSM. Android Data Call: Control, netd, eBPF & Packets
5GMM / 5GSM: 5G mobility management and session management; the NAS protocols for registration and PDU sessions. Android Telephony, RIL & Modem
5QI: 5G QoS Identifier; an index to standard QoS characteristics such as delay budget and error rate. 5G NR & 5G Core
@VintfStability: AIDL annotation marking an interface as a stable system/vendor contract. Binder IPC & AIDL
[CLS] token: A special token prepended by BERT-style encoders whose final vector summarises the sequence; used for pooling and for cross-encoder scores. Retrieval-Augmented Generation (RAG)