Glossary

You will find a myriad of jargon, acronyms and product or tool names used both in technical documentation and social media discussion of the Boost C++Libraries and C++ development in general. This section contains descriptions of the most common.

You will find well known acronyms such as DLL, URL and UUID in this list, because they also refer to Boost libraries of the same name.

Where terms apply specifically to one technology, such as Quantum Computing or Safe C++, many of the specific terms are only listed under the entry for that technology.

Contents

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U

V

W

X

Y

Z

A

ABI : Application Binary Interface

ADL : Argument-Dependent Lookup

AFAICT : As Far As I Can Tell

AFAIK : As Far As I Know

ASIO : Asynchronous Input/Output - refer to Boost.Asio

AST : Abstract Syntax Tree - a data structure used in compilers to represent the structure of code in a hierarchical, tree-like form. It’s a crucial intermediate step in parsing code for tasks like analysis, compilation, and optimizations.

ATM : At The Moment

B

BBK : Badly Broken Keyboard - describing terrible code or debugging issues

BFS : Breadth-First Search

Bikeshedding or BS : Focusing on trivial issues

BOFH : B’d Operator From Hell - referring to a grumpy system admin

BOGOSITY : A measure of how bogus something is - typically bogus code or bogus logic

BTW : By The Way

C

CICD (CI/CD) : Continuous Integration and Continuous Deployment (or Delivery). CI refers to the practice of automatically integrating code changes into a shared repository, where each change is verified by automated builds and tests. CD extends this process to automatically deploy or deliver new code to production environments. Refer to Contributor Guide: Continuous Integration.

CML : Can mean CMake Language, Conversion Markup Language, Configuration Menu Language, Concurrent ML (a high-level language for concurrent programming) - depending on context.

CppFront : a project created by Herb Sutter, which is a syntax experiment for C++. It’s designed as a front-end tool to make C++ more modern and easier to use by offering a simpler syntax that translates into standard C++ code. Essentially, it’s a transpiler for a modernized dialect of C++.

CRC : Cyclic Redundancy Code - refer to Boost.Crc

CRTP : Curiously Recurring Template Pattern

CSS : Cascading Style Sheet - defines the styles used in HTML web pages.

CUDA : CUDA originally stood for Compute Unified Device Architecture though is now generally used as a name for a parallel computing platform, language and API. For more information, refer to CUDA Toolkit.

D

DDS : Data Distribution Service

DFL : Do not Fix Later - used sarcastically pointing out procrastination on fixing bugs

DFS : Depth-First Search

DLL : Dynamic Link Library - also refer to Boost.Dll

DOCCA : A set of XSLT transformations that convert Doxygen XML extracted from Javadoc comments in C++ source code, into Boost.Quickbook output.

Drone : A continuous integration (CI) and delivery platform that automates the build, test, and deploy stages of a software pipeline. It is container-based and integrates with various version control systems, supporting multiple languages and environments - refer to Contributor Guide: Continuous Integration.

DRY : Don’t Repeat Yourself

E

ELF binary : refers to a file that follows the Executable and Linkable Format (ELF), which is a common standard file format for executables, object code, shared libraries, and core dumps on Unix-like operating systems such as Linux. ELF supports advanced features like dynamic linking, which is useful for shared libraries. Tools like gdb (the GNU Debugger) can use the debug symbols and information stored in ELF binaries to provide insights during debugging sessions.

EVP :

  • Used in cryptography, particularly in OpenSSL, where EVP stands for Envelope. It is used to refer to high-level cryptographic functions in the OpenSSL library, such as encryption, hashing, and signing. C++ programs using OpenSSL for cryptographic operations might use the EVP APIs.

  • Enhanced Vector Processing : in high-performance computing contexts, EVP might refer to techniques that leverage vectorization or SIMD (Single Instruction, Multiple Data) for improving computational performance. It relates to libraries or frameworks that optimize algorithms using vectorized processing.

EVP_MD_CTX : Envelope Message Digest Context - part of OpenSSL’s high-level cryptographic library and is used to manage the context for performing message digest (hashing) operations. The EVP API provides a high-level and flexible interface, allowing developers to use a consistent set of functions for various cryptographic algorithms without being tied to a specific implementation.

F

FIFO : First In, First Out

FOMO : Fear Of Missing Out

FOOBAR or FUBAR : Fed Up Beyond All Recognition

FPU : Floating Point Unit

FSM : Finite State Machine

FUD : Fear, Uncertainty, and Doubt

FWIW : For What It’s Worth

G

GCC : GNU Compiler Collection - a popular open-source compiler that supports C++, and it is frequently mentioned in discussions about toolchains, performance optimizations, and cross-platform development.

GDB : Often used as short for GNU Debugger, though can mean Graph Database.

GIL : Generic Image Library - Boost.Gil is a library designed for image processing, offering a flexible way to manipulate and process images.

H

HCF : Halt and Catch Fire - a bug that crashes everything, usually exaggerated

HOF : High-Order Functions - refer to Boost.Hof

HRT : High-Resolution Timer - a high-resolution timing mechanisms used in C++ for precise measurements of time, especially in performance profiling and real-time systems.

HSM : Hierarchical State Machine - used in designing state machines in software development, often in real-time systems or simulations.

I

ICL : Interval Container Library - refer to Boost.Icl

ID10T : Idiot - pronounced "ID-ten-T" (user errors)

IDEs : Integrated Development Environments

IIUC : If I understand correctly

IIRC : If I remember correctly

IMO or IMHO : In My (Honest or Humble) Opinion

INCITS : The InterNational Committee for Information Technology Standards is the central U.S. forum dedicated to creating technology standards for the next generation of innovation.

IO : Input/Output - refer to Boost.Io

IOW : In Other Words

IR : Intermediate Representation - an internal representation of code or data.

IWBNI : It Would Be Nice If - a feature request is a dream

IWYU : include-what-you-use - a tool for use with clang to analyze #includes in C and C++ source files.

J

Jinja or Jinga2 : Jinga is a popular Python text template engine. Jinga2C++ is a modern C++ implementation of Jinga.

JNI : Java Native Interface - a framework that allows C++ code to interact with Java code. JNI is relevant when integrating C++ components into Java applications, especially in cross-language development.

JIT : Just-In-Time (Compilation) - while JIT compilation is more commonly associated with languages like JavaScript or Java, it is occasionally discussed in the context of C++ when talking about optimization techniques, runtime compilation, or performance-critical applications. Some C++ libraries (e.g., LLVM) support JIT compilation features.

K

K8s : The Kubernetes container orchestration system

KDE : The K Desktop Environment (a Linux graphical environment)

KISS : Keep It Simple, Stupid

KPI : Key Performance Indicator

KVM : Kernel-based Virtual Machine

L

LEAF : Lightweight Error Augmentation Framework - refer to Boost.Leaf

LGTM : Looks Good To Me - often used in code reviews to signal approval

LIFO : Last In, First Out

LLVM : Initially this stood for Low Level Virtual Machine but is now no longer considered an acronym. LLVM is now the name for a set of compiler and toolchain technologies that support the development of a frontend for any programming language and a backend for any processor architecture. It is written in C++.

LOL : Laughing Out Loud

LOPS Lack Of Programmer Skill - used humorously when a problem is tricky to debug

LSP :

  • Liskov Substitution Principle - states that objects of a derived class should be able to replace objects of the base class without affecting the correctness of the program, ensuring that a subclass can stand in for its superclass without altering expected behavior.

  • Language Server Protocol - a standard protocol used for communication between code editors/IDEs (like VS Code) and programming language tools (like compilers or linters). It’s designed to enable features like autocomplete, go-to-definition, and refactoring.

M

MDS :

  • Meltdown Data Sampling : in the context of system security and CPU vulnerabilities, MDS refers to a family of side-channel attacks that target weaknesses in modern CPU architectures. These attacks can potentially leak sensitive data through speculative execution flaws, similar to vulnerabilities like Meltdown and Spectre.

  • Modular Design Structure : sometimes used to describe a software design methodology in which systems are broken down into modules, allowing for separation of concerns and better maintainability.

  • Multiple Data Streams : a more abstract term, refers to scenarios where an application handles multiple data streams simultaneously, possibly in a parallel or distributed environment.

MFW : My Face When - used humorously or sarcastically depending heavily on the accompanying context or image.

MIR, MLIR : Mid-level Intermediate Representation - an intermediate form of code that is generated by the compiler during the compilation process, designed to be easier for the compiler to analyze and optimize. In particular, this mid-level code aids with borrow checking, incremental compilation and ensuring safety (type, memory, etc.) issue.

MOC : In the context of Qt and C++, this refers to the Meta-Object Compiler - a tool that processes Qt’s extensions to C++, such as signals and slots (a mechanism for event-driven programming) and other meta-object features (like introspection and dynamic properties). The MOC generates additional C++ code that enables these features to work seamlessly.

MPI : Message Parsing Interface - refer to Boost.Mpi

MPL or MP11 : Metaprogramming Libraries - refer to Boost.Mpl and the later Boost.Mp11

MVP : Model-View-Presenter

N

NDA : Non-Disclosure Agreement

NIMBY : Not In My Back Yard - when a programmer doesn’t want to deal with a particular issue

NLL : Non-Lexical Lifetimes - an NLL borrow checker in the Rust language that uses a more precise, dataflow-based analysis to determine when a borrow starts and ends, based on the actual usage of the variables. This allows for more flexible and intuitive borrowing rules.

NTTP : Non-Type Template Parameter

O

Odeint : Ordinary Differential Equations (Initial) - a library for solving initial value problems of ordinary differential equations, refer to Boost.Numeric/odeint

OOB : Out of Bounds or Out of Band - meaning irrelevant

OOP : Object-Oriented Programming

P

PEBKAC : Problem Exists Between Keyboard And Chair - user error

PFR : A library to perform basic reflection - refer to Boost.Pfr

Phi function : a construct used in Static Single Assignment (see SSA) form to resolve multiple possible values for a variable when control flow converges in a program. It selects a value based on the control flow path taken to reach the convergence point. Phi functions are not visible to developers — they exist in the intermediate representation (IR) of compilers working with low-level code optimizations.

PICNIC : Problem In Chair, Not In Computer

PIMPL :

  • Pointer to IMPLementation

  • Perception Is My Lasting Principle - the "Cheshire Cat" idiom where someone’s perception of reality is subjective

PITA : Pain In The Application - difficult or frustrating code issue

POD : Plain Old Data

POSIX : Portable Operating System Interface

PPA : Personal Package Archive - a repository on Launchpad (a platform for Ubuntu software collaboration) that allows developers and maintainers to distribute software or updates that are not yet included in the official Ubuntu repositories.

PR : Pull Request - a request to include specified content into a GitHub repository. An administrator can accept or reject the PR.

Q

QBK : Quickbook - a Boost tool for automated documentation, not to be confused with Intuit Quickbooks accounting software.

QED : "Quod erat demonstrandum" in Latin, which translates to "that which was to be demonstrated".

QML : Qt Meta Language - a declarative language used in conjunction with Qt for designing user interfaces. QML is commonly referenced in C++ discussions related to UI development in Qt.

QOI : Quite OK Image format - a relatively new image file format that aims to provide lossless image compression with a focus on simplicity and speed, sometimes used in performance-critical applications dealing with image processing.

QoS : Quality of Service - a concept that often appears in networking discussions, especially when C++ programs deal with real-time communications, distributed systems, or systems requiring specific performance guarantees.

Qt : This is a widely-used C++ framework for cross-platform GUI applications. While not an acronym, it’s often capitalized as Qt in discussions. Qt is known for its rich set of libraries and tools to develop not only graphical applications but also applications that require network handling, file I/O, and more.

Quantum Computing : Unlike classical computing based on bits which must have a value of 0 or 1, quantum computing is based on qubits (see definition below) that can exist in multiple states at the same time. Still in the research phase, this technology can dramatically improve the performance of certain algorithms - especially those we currently call "brute-force" computing - in fields such as cryptography, chemistry simulation, graph traversing, and no doubt many others as new algorithms are discovered. We can currently simulate quantum algorithms in C++ - refer to Quantum Computing. There is a mass of new terminology to grasp - many of which have completely different meanings outside of quantum computing - including:

  • Bloch Sphere : a geometric representation of a single qubit’s state as a point on the surface of a unit sphere, useful for visualizing superposition and phase.

    Bloch Sphere

    The Bloch sphere is a 3D representation of a single qubit’s state. Any point on the sphere’s surface corresponds to a valid qubit state, with poles representing |0⟩ and |1⟩, and equatorial points representing equal superpositions. This tool helps visualize qubit transformations, such as rotations from quantum gates or decoherence effects over time.

  • Clifford+T Gate Set : a universal set of quantum gates that includes Clifford gates and the T gate, used to construct fault-tolerant quantum circuits. The Clifford gate is a type of quantum gate that forms a foundational set of operations used in quantum error correction and stabilizer circuits. The T gate is a single-qubit quantum gate that applies a π/4 phase shift to the |1⟩ state, making it essential for achieving universal quantum computation when combined with Clifford gates.

  • Decoherence : the process by which a quantum system loses its quantum properties (like superposition or entanglement) due to environmental interaction.

  • Entanglement : a quantum phenomenon where two or more qubits become linked, such that measuring one affects the state of the others, regardless of distance.

    Entanglement

    This shows a classic quantum circuit diagram demonstrating how to create an entangled pair of qubits (often called a Bell State). Qubit 0 (q₀) — starts in state |0⟩. Qubit 1 (q₁) — also starts in state |0⟩. A Hadamard Gate (H) is applied to q₀, which puts q₀ into a superposition: (|0⟩ + |1⟩) / √2. A CNOT gate is applied with q₀ as the control qubit, and q₁ as the target qubit. This entangles the qubits — their states become correlated. This means measuring q₀ as 0 forces q₁ to be 0, and measuring q₀ as 1 forces q₁ to be 1. Even if far apart, their outcomes are perfectly correlated — the hallmark of entanglement.

  • Hamiltonian : an operator representing the total energy of a quantum system, governing how its state evolves over time via Schrödinger’s equation.

  • Interference : arises from the wave-like nature of quantum states, allowing quantum algorithms to amplify correct answers while canceling out incorrect ones, enhancing computational efficiency.

  • Measurement : the act of observing a qubit’s state, which causes its wavefunction to collapse into a definite classical outcome (0 or 1).

  • Noisy Intermediate-Scale Quantum (NISQ) : A classification of current quantum devices with dozens to hundreds of qubits that are not yet error-corrected or scalable but still useful for experimentation.

  • QASM (Quantum Assembly Language) : a low-level language for describing quantum circuits and operations, often used to interface with quantum simulators and hardware.

  • Qubit : the basic unit of quantum information, capable of existing in a superposition of 0 and 1, unlike a classical bit which is strictly one or the other.

  • Qubit Connectivity (Topology) : the layout that defines which qubits in a quantum computer can directly interact, affecting how efficiently quantum circuits can be executed.

  • Qubit Decoherence Time (T1, T2) : T1 refers to how long a qubit holds its energy state (relaxation), and T2 refers to how long it maintains its phase (coherence) — both affect quantum stability.

  • Quantum Annealing : an optimization technique that finds the lowest-energy configuration of a system by slowly evolving its quantum state.

  • Quantum Circuit : a structured sequence of quantum gates applied to qubits to implement a quantum algorithm.

    Quantum Circuit

    This diagram shows a basic quantum circuit composed of qubit wires (horizontal lines) and quantum gates. The gates — such as Hadamard (H), CNOT, and Measurement (M) — manipulate the quantum state of the qubits. The circuit structure visually represents the flow of operations over time from left to right, forming the basis of all quantum algorithms.

  • Quantum Error Correction (QEC) : techniques used to detect and correct quantum errors by encoding logical qubits across multiple physical qubits.

  • Quantum Fourier Transform (QFT) : a quantum algorithm for transforming a quantum state into its frequency domain - used in Shor’s algorithm and other applications.

  • Quantum Gate : a basic operation applied to qubits that changes their state, analogous to logic gates in classical circuits but with quantum behavior.

  • Quantum Phase Estimation (QPE) : an algorithm used to estimate the eigenvalue (phase) associated with an eigenvector of a unitary operator—central to many quantum applications.

  • Quantum Teleportation : a process where the state of a qubit is transferred from one location to another, without moving the physical particle itself, by using entanglement and classical communication. It doesn’t transmit matter or energy like in science fiction — instead, it “teleports” quantum information perfectly, but always requires destroying the original state.

    Quantum Teleportation

    This diagram shows the basic process of quantum teleportation, where the unknown state of qubit |ψ⟩ (held by Alice) is transferred to Bob using entanglement and classical communication. The circuit begins with an entangled pair of qubits shared between Alice (qubit A) and Bob (qubit B). Alice performs a set of quantum operations — a CNOT gate followed by a Hadamard gate — on her qubits, then measures them. She sends the two classical measurement results (bits) to Bob over a classical channel. Bob then applies specific quantum gates (Pauli X and/or Z) depending on Alice’s results, reconstructing the original state |ψ⟩ on his qubit — effectively completing the teleportation without physically moving the qubit itself.

  • Quantum Volume : a benchmark that evaluates a quantum computer’s ability to run complex circuits by factoring in gate fidelity, connectivity, and qubit count.

  • Superposition : a principle in quantum mechanics where a qubit can exist in multiple states simultaneously, enabling parallelism in computation.

  • Trotterization : a technique for approximating quantum evolution by breaking time-dependent Hamiltonians into discrete, manageable steps.

QVM : Quaternions Vectors and Matrices - refer to Boost.Qvm

R

RAII : Resource Acquisition Is Initialization

RPC : Remote Procedure Call

RTFM : Read The Fine (or Friendly) Manual

RTTI : Run-Time Type Information

RUST : Rust is a relatively new programming language incorporating memory-safety, thread-safety and type-safety constructs. This language provides many of the concepts proposed for Safe C++.

Rustaceans : Aficionados of the Rust programming language

S

Safe C++ : There are memory-safe discussions and initiatives going on in the wider C++ development world, though it seems like it’s a tough nut to crack. The Safe C++ proposal is currently in a state of indefinite hiatus. Key concepts of memory-safety, and it’s partners type-safety and thread-safety, include:

  • Borrowing : this refers to a feature of an ownership system that allows a variable to grant temporary access to its data without giving up ownership. Immutable borrowing allows others to read but not modify data. Multiple immutable borrows are allowed at the same time. With mutable borrowing others can modify the data, but only one mutable borrow is allowed at any one time (to prevent data races), and the owner cannot modify the value until the borrow ends. Borrowing enforces lifetimes - so borrowed references do not outlive the original data.

  • Borrow checking : a kind of compile-time analysis that prevents using a reference after an object has gone out of scope.

  • Choice types : a choice type is similar to an enum, but contains a type-safe selection of alternative types.

  • Explicit mutation : all mutations are explicit, so there are no uncertain side-effects.

  • Interior mutability : types with interior mutability implement deconfliction strategies to support shared mutation, without the risk of data races or violating exclusivity.

  • Pattern matching : the only way to access alternatives of Choice types to ensure type-safety.

  • Relocation object model : a memory model that supports relocation/destruction of local objects, in order to satisfy type-safety.

  • Send and sync : these are type traits that ensure memory-safety between threads. The send is enabled for a variable if it is safe to transfer ownership of its value to another thread. A sync trait is enabled if it is safe to share a reference to a value with other threads.

  • The safe context : operations in the safe context are guaranteed not to cause undefined behavior.

SHA : Secure Hash Algorithm, a function that will reliably give different hash values for different inputs.

SFINAE or SFINAED : Substitution Failure Is Not An Error

SIGILS : refers to symbols or characters that precede a variable, literal, or keyword to indicate its type or purpose. For example, in "%hash" the "%" is a sigil. It is occasionally used with a tongue-in-cheek tone because of its mystical connotations, referring to how these symbols can seem "magical" in making the code work!

SMOP : Small Matter of Programming - sarcastically downplaying complex problems

SOLID : Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion (Design principles)

SSA : Static Single Assignment - a property of intermediate representations (IRs) used in compilers. SSA is a popular technique in modern compilers to make optimizations and analysis simpler and more efficient. Each variable is assigned exactly once and is immutable after assignment. If a variable is updated, a new variable is created instead. Refer also to Phi functions.

STL : Standard Template Library

Swifties : In the programming context, aficionados of the Swift language.

T

TCO : Tail Call Optimization

TCP : Transmission Control Protocol

TDD : Test-Driven Development

Test Matrix : A test matrix is a table used to define and track test cases, inputs, and environments, such as various operating systems, compilers, and hardware platforms. Each row represents a test scenario or feature, while the columns represent variations like software versions or hardware setups - refer to Contributor Guide: Test Matrix.

TLS : Thread-Local Storage

TL;DR : Too Long; Didn’t Read

TL;DW : Too Long; Didn’t Watch - used when someone posts an overly long video or demo

TTI : Type Traits Introspection - refer to Boost.Tti

TTOU : Time To Opt Out - used humorously to express wanting to quit a project that is heading south

TTW : Time To Whine - used sarcastically used when someone starts complaining about their code or environment

U

UB : Undefined Behavior

UBlas : Basic Linear Algebra - refer to Boost.Numeric/ublas

URL : Universal Resource Locator - refer to Boost.URL

UDP : User Datagram Protocol

UTC : Coordinated Universal Time

UUID : Universal Unique Identifier - refer to Boost.Uuid

V

VALA : Vector Arithmetic Logic Array - a specialized hardware design or computation technique, but in some performance-critical C++ applications, vector arithmetic and optimization may be discussed in a similar context.

VCPKG : Microsoft’s open source package manager for acquiring and managing libraries

VFS : Virtual File System - abstract file system operations across multiple platforms might implement or make use of a VFS layer. This allows consistent file I/O behavior regardless of the underlying file system.

VLA : Variable Length Array - although C++ does not officially support VLAs in the standard, some compilers provide support as an extension. VLAs allow the length of an array to be determined at runtime.

VMD : Variadic Macro Data - refer to Boost.Vmd

VoIP : Voice over Internet Protocol - in networking libraries or real-time communication systems, VoIP is often discussed when implementing features for voice transmission over IP networks.

VR : Virtual Reality - in game programming, simulations, or graphics-intensive applications, VR is often mentioned in discussions. C++ is commonly used for developing VR engines and related tools.

VTable : Virtual Table - a mechanism used in C++ to support dynamic (runtime) polymorphism through virtual functions. Discussions involving inheritance and object-oriented programming often reference vtables.

W

WAD : Works As Designed - usually sarcastic

WG21 : Working Group 2021 - a C++ Standards working group

WIP : Work In Progress

WITIWF : Well I Thought It Was Funny

WowBagger : The name of the web server where boost.org and lists.boost.org are running. It’s a Redhat Linux machine and soon to be replaced.

WRT : With Respect To

WTB : Where’s The Bug? - used sarcastically when trying to find a difficult-to-locate issue

X

XFS : Extended File System - a high-performance file system in Linux

XSS : Cross-Site Scripting - a security vulnerability where malicious scripts are injected into websites

XUL : XML User Interface Language - used to define user interfaces in Mozilla applications

Y

YAGNI : You Aren’t Gonna Need It

YAP : An expression template library - refer to Boost.Yap

YOLO : You Only Live Once - used when someone takes a risky or questionable coding decision

Z

ZALGO : refers to a form of distorted or "corrupted" text, and while this is more of a meme in the programming community, it comes up when discussing character encoding or text rendering in C++.

ZF : Zero-Fill - zero-filling memory, often done for security reasons or to initialize data in C++ programs.

ZFP : Compressed Floating-Point Arrays - ZFP is a C++ library for compressed floating-point arrays, often used in scientific computing or simulations requiring efficient memory usage.

Zlib : Zlib Compression Library - a widely-used compression library in C++ for data compression and decompression.

ZMQ : ZeroMQ - a high-performance asynchronous messaging library that can be used in C++ for concurrent programming and networking applications.

Z-order or Z-ordering : Refers to the drawing order of objects in 2D or 3D space. This is relevant in C++ game development or graphical applications when managing layers of objects.

See Also

Edit this Page