Byzantine Fault Tolerance
The ability of a distributed system to keep agreeing correctly even when some components fail arbitrarily or maliciously, lying and sending conflicting messages rather than simply crashing.
Concepts
Plain-language explanations of the ideas behind software - compilers, garbage collection, objects, types.
628 entries, all primary-sourced
Cache Coherence
The problem of keeping multiple processors' private caches consistent when they share memory, and the protocols - such as the snooping MESI scheme introduced by Papamarcos and Patel in 1984 - that solve it.
CAP Theorem
A distributed data store can provide at most two of consistency, availability, and partition tolerance at once, so under a network partition designers must choose between consistency and availability.
Cargo Cult Programming
Copying code, structure, or rituals into a program without understanding why they work, imitating the form of a solution while missing its substance.
Causal Consistency
A consistency model that preserves the order of causally related operations on every replica, while allowing concurrent operations to be observed in different orders.
Causality
In distributed systems, the cause-and-effect relationships between events; tracking causality with logical and vector clocks lets systems order events correctly without synchronized physical clocks.
Centralized Version Control
A model of version control in which a single central server holds the canonical repository that clients check out from and commit to.
Certificate Authority
A trusted organization that issues and signs digital certificates vouching that a public key belongs to a named entity such as a website.
cgroups (Linux Control Groups)
A Linux kernel feature that organizes processes into hierarchical groups whose use of CPU, memory, and I/O can be limited, accounted, and monitored.
Changelog
A curated, human-readable record of notable changes between software versions, a practice running from the GNU ChangeLog tradition to the modern Keep a Changelog convention.
Chomsky Hierarchy
Chomsky's 1956 ranking of formal grammars into four nested types, from regular up to recursively enumerable, each matched to a class of abstract machine and to a level of parsing power compilers rely on.
chroot
The Unix system call that changes a process's apparent root directory, the earliest ancestor of container filesystem isolation and a notoriously weak security boundary.
Cipher
An algorithm that transforms plaintext into ciphertext and back under a key, ranging from classical substitution and transposition to modern block and stream ciphers.
CISC (Complex Instruction Set Computer)
The processor design tradition of rich, variable-length, often microcoded instructions, exemplified by the VAX and x86, that the RISC movement reacted against.
Clean Code
Code written to be easily read and changed by humans - clear names, small functions, no duplication, and good tests - reflecting the idea that readability is a primary virtue of software.
Client-Server Model
The architecture in which client programs request services from server programs over a network, exchanging requests and responses -- the basic shape of the web.
Clock Synchronization
The problem of keeping the physical clocks of networked computers close to each other and to true time, made hard by variable network delays and clock drift.
Closure
A function bundled together with the variables from its surrounding scope, so it remembers that environment even after the outer function has returned.
Cloud Computing
Delivering computing resources such as servers, storage, databases, and software on demand over the internet, paid by use instead of owned.
Code Golf
The sport of solving a programming problem in the fewest characters or bytes of source code possible, complete with its own community, scoring rules, and a family of languages designed to make the shortest answers even shorter.
Code Injection
The general class of attacks in which untrusted input is interpreted as code or commands by an application; the root cause is mixing data and code without proper validation or escaping.
Code of Conduct
A document that sets explicit standards for behavior in an open-source project, conference, or other community, together with a process for reporting and enforcing violations; on platforms like GitHub a code of conduct is one of the standard community-health files a project can add.
Code Review
The practice of having other developers examine proposed changes before they merge, to catch bugs and share knowledge.
Code Smell
A surface symptom in code, such as a long method or duplicated code, that usually points to a deeper design problem worth investigating.
Cohesion and Coupling
Two complementary measures of design quality: cohesion, how focused a module is on a single purpose, and coupling, how dependent modules are on one another - the goal being high cohesion and low coupling.
Cold Start
The latency penalty when a serverless function must build a fresh execution environment - downloading code and running initialization - because no warm environment is available; a central trade-off of Function-as-a-Service.
Columnar Storage
Storing a table's data column by column instead of row by row, so analytical queries read only the columns they need and compress well.
Command-Line Interface
The way of operating a computer by typing commands at a prompt: a shell reads a command name plus options and operands, runs it, and reports a numeric exit status. The POSIX Utility Conventions codify how those commands, their option flags, and their arguments are spelled.
Commit
Recording a set of changes as a single, identified snapshot in a project's version-control history, usually accompanied by a message that explains what the change does and why.
Common Language Runtime (CLR)
.NET's virtual machine, which just-in-time compiles Intermediate Language to native code and manages memory, type safety, and security - the .NET counterpart to the Java Virtual Machine.
Compiler
A program that translates source code written in a high-level language into the machine instructions a computer can run directly.
Complexity Class
A set of problems that can all be solved within the same resource bounds - typically time or memory - on a given model of computation, such as P, NP, PSPACE, or EXPTIME.
Component-Based UI Architecture
Building user interfaces from composable, reusable, encapsulated components that take inputs (props) and manage their own state, the shared model behind React, Vue, Angular, and Web Components.
Computability
The study of which problems can in principle be solved by an algorithm or machine, and which cannot.
Computational Complexity
The study of how much resource - chiefly time and memory - an algorithm needs as its input grows, and of grouping problems by how hard they are to solve.
Computational Model
An abstract definition of how computation proceeds, such as Turing machines, lambda calculus, or finite automata, used to reason about what is computable and how costly it is.
Computer Worm
Self-replicating malware that spreads across networks on its own, without needing a host program or user action - the Morris Worm, Code Red, SQL Slammer, Conficker, and Stuxnet are examples.
Concurrency
Structuring a program as independently executing parts that can make progress separately, a notion distinct from running them in parallel.
Configuration Management
The practice of defining the desired state of servers and software and enforcing it automatically and repeatably, so systems converge to a known configuration and drift is corrected rather than accumulating.
Conflict-free Replicated Data Type (CRDT)
A data structure designed so that replicas can be updated independently and merged automatically without conflicts, always converging to the same state.
Consistency Models
The spectrum of guarantees about when and how reads reflect writes in a distributed system, ranging from strong consistency through causal to eventual consistency.
Consistent Hashing
A hashing scheme that maps keys and nodes onto a ring so adding or removing a node only remaps a small fraction of keys, letting distributed datastores spread data and rebalance smoothly.
Container Registry
A server that stores and distributes container images by name and tag, acting as the container world's equivalent of a software package registry.
Containerization
Packaging an application with its dependencies into an isolated, portable unit that shares the host OS kernel, built on Linux namespaces and cgroups.
Context-Free Grammar
A formal grammar whose rules each rewrite a single nonterminal regardless of surrounding context, expressive enough to describe most programming-language syntax.
Continuation
A representation of the rest of a computation as a function; continuation-passing style makes control flow explicit, and Scheme's call/cc exposes continuations as first-class values.
Copyleft
A licensing technique that uses copyright to keep a program free, requiring all modified and extended versions to carry the same freedoms; embodied in the GNU GPL.
Cosmic Rays and Soft Errors
Random, transient bit flips in memory and logic caused by ionizing radiation such as cosmic-ray particles and alpha particles; the phenomenon that motivated error-correcting memory, characterized in IBM's foundational soft-error research led by James Ziegler.