Kerning
Adjusting the space between specific pairs of letters so that text appears evenly spaced -- distinct from tracking, which adjusts spacing uniformly -- encoded in fonts through kern tables and OpenType's GPOS positioning data.
Concepts
Plain-language explanations of the ideas behind software - compilers, garbage collection, objects, types.
673 entries, all primary-sourced
Key Exchange
The problem and protocols for two parties to establish a shared secret key securely, the classic obstacle for symmetric encryption that Diffie-Hellman solved.
Key-Value Store
The simplest NoSQL model: a distributed hash map of unique keys to opaque values, optimized for fast, scalable lookups.
Kludge
Hacker term, also spelled kluge, for an inelegant solution that nonetheless works: a clumsy patch or clever programming trick that handles a nasty case efficiently if not cleanly, central to the engineering folklore collected in the Jargon File.
Lambda (Anonymous Function)
An anonymous function written inline without a name, such as x => x + 1; named after the lambda calculus and now found in nearly every modern language.
Lambda Calculus
Church's formal system of function definition and application that is a universal model of computation and the theoretical basis of functional programming.
Lazy Evaluation
Delaying the evaluation of an expression until its value is actually needed, which enables infinite data structures and can avoid unnecessary work.
Leader Election
The process by which distributed nodes choose a single node to coordinate, and choose a new one when it fails.
Leader-Follower Replication
The most common replication scheme: one leader accepts writes and streams them to followers that serve reads.
Leap-Second Bug
To keep clocks aligned with the Earth's uneven rotation, an extra second (shown as 23:59:60) is occasionally inserted into UTC. Software that assumes every minute has exactly 60 seconds can break when it sees the 61st, and the disruption pushed metrology bodies to vote in 2022 to phase the leap second out by 2035.
Linear Search
The simplest search: check each element in turn until the target is found or the data is exhausted, running in O(n) time.
Linearizability
The strongest single-object consistency condition: every operation appears to take effect instantaneously at one moment between its call and its return, so the system behaves like a single up-to-date copy.
Linked List
A sequence of nodes each pointing to the next, giving cheap insertion and deletion at a known position but slow access by index.
Linux Namespaces
A Linux kernel feature that gives a process group its own isolated view of system resources such as process IDs, network stacks, mount points, and user IDs.
Locality of Reference
The empirical tendency of programs to reuse data they accessed recently (temporal locality) and to access data near what they just touched (spatial locality) - the regularity that makes caches and the whole memory hierarchy work, formalized by Peter Denning's 1968 working-set model.
Lockfile
A generated file that pins the exact resolved versions of every dependency so installs are reproducible across machines and over time.
Logical Clock
A counter-based mechanism introduced by Leslie Lamport in 1978 for ordering events across a distributed system without relying on synchronized physical clocks.
Machine Code
The binary instructions a CPU fetches and executes directly, encoded as opcodes and operands; the layer beneath assembly language that every higher-level program is ultimately turned into.
Macros and Metaprogramming
The practice of writing programs that generate or transform other programs, exemplified by Lisp-family macros that operate on code as data to extend the language itself.
Managed Code
Code whose execution is overseen by a runtime such as the CLR or the JVM, which handles memory, type safety, and security - in contrast to native or unmanaged code compiled directly to machine instructions.
Map, Filter, Reduce
Three higher-order functions over collections: map transforms each element, filter keeps elements passing a test, and reduce combines elements into a single result.
Memoization
An optimization that caches the result of a function call so that later calls with the same arguments return the stored answer instead of recomputing it.
Memory Hierarchy
The layered arrangement of storage in a computer - registers, cache, main memory, disk - trading speed and cost against capacity, so that fast memory holds the data in active use and slow memory holds the rest.
Memory Safety
A property of programs that prevents bugs like use-after-free, buffer overflows, and data races, achieved through approaches such as garbage collection or compile-time ownership checks.
Merge Sort
A stable, divide-and-conquer sorting algorithm that splits a list, sorts the halves, and merges them, with a guaranteed O(n log n) running time.
Message Queue
Middleware that lets systems communicate asynchronously by placing messages on a queue for other systems to consume, decoupling senders from receivers.
Message-Passing Concurrency
Coordinating concurrent processes by sending each other messages instead of sharing memory, eliminating locks and data races by design.
Microcode
An internal layer of micro-instructions inside a CPU that implements its complex machine instructions in terms of simple hardware steps; proposed by Maurice Wilkes in 1951 and now used to patch processor errata in the field.
Minimum Spanning Tree
The cheapest cycle-free set of edges that connects every node of a weighted graph, found by greedy algorithms from Kruskal (1956) and Prim (1957).
MLOps
The practice of applying DevOps discipline to machine learning - versioning data and models, building CI/CD pipelines for ML, and monitoring deployed models for drift.
Mock Object
A stand-in for a real dependency in a test, programmed with expectations about how it should be called, so a unit can be tested in isolation from slow or unpredictable collaborators like databases and networks.
Model Serving
The practice of deploying a trained machine learning model behind an API for inference, spanning batch and online serving and confronting the training-serving skew problem.
Monad
A functional design pattern, borrowed from category theory, for sequencing computations that carry a context such as state, failure, or input/output while keeping functions pure.
Monorepo
Keeping many projects or services in a single version-control repository, as Google and others do, trading tooling complexity for unified change and dependency management.
Moore's Law
Gordon Moore's 1965 observation that the number of components on an integrated circuit doubles at a steady, predictable rate, which became the planning roadmap of the semiconductor industry.
Multi-Factor Authentication (MFA)
Requiring two or more independent proofs of identity from different categories - something you know, have, or are - so that a stolen password alone is not enough to log in.
Multi-Tenancy
A single running software instance or pool of infrastructure serving many customers ('tenants') at once, with each tenant's data isolated from the others - the economic engine that makes cloud and SaaS cheap.
MVCC (Multi-Version Concurrency Control)
Keeping multiple versions of rows so readers see a consistent snapshot without blocking writers, and writers do not block readers - how PostgreSQL and Oracle achieve high concurrency.
node_modules
The per-project folder where npm installs a package's full dependency tree, famously huge, and the reason flat installs, hoisting, and pnpm's linking exist.
Normalization
Organizing tables so each fact is stored once, by decomposing them according to their functional dependencies into successive normal forms.
Not Invented Here
The tendency of a team or organization to reject external solutions and rebuild them in-house, out of pride, distrust, or insularity.
NP-Completeness
The class of the hardest problems in NP, such that a fast algorithm for any one of them would yield a fast algorithm for every problem in NP.
Obfuscated Code
Code that is deliberately made hard to read, whether as an art form and competitive sport, as a way to protect intellectual property and hide malware, or as a side effect of compressing source down to nothing.
Object Orientation
A way of organizing programs around objects that bundle data together with the behavior that acts on it, with roots in Simula and Smalltalk.
Object-Relational Mapping (ORM)
A layer that maps database tables to objects in code so developers work with objects instead of writing SQL by hand.
Observer Pattern
A behavioral design pattern in which a subject keeps a list of dependent observers and notifies them automatically when its state changes.
OLAP vs OLTP
The split between transaction processing (many small reads and writes) and analytical processing (large aggregate queries over history), two workloads so different they use different database designs.
One-Time Pad
Encryption with a truly random key as long as the message and used only once; the only cipher proven to offer perfect secrecy, but impractical because of the key-distribution burden.