Spiral Model
Barry Boehm's risk-driven, iterative software process that repeatedly cycles through setting objectives, analyzing risks, developing and verifying, and planning the next round.
Concepts
Plain-language explanations of the ideas behind software - compilers, garbage collection, objects, types.
673 entries, all primary-sourced
Split-Brain
A failure where a network partition causes two nodes to each believe they are the leader and accept conflicting writes.
SQL Injection
Injecting malicious SQL into an application's database query by abusing unsanitized input, letting attackers read, change, or destroy data; prevented by parameterized queries.
SQL Join
Combining rows from two or more tables based on related columns, the operation that reassembles normalized data into useful results.
Stack
A last-in-first-out collection with push and pop, underlying function calls, expression evaluation, undo, and depth-first traversal.
State Machine Replication
Making a service fault-tolerant by running identical replicas that process the same commands in the same order so they stay in sync.
Static Analysis
Analyzing source code without running it to find bugs, security flaws, and style violations, in contrast to testing a running program.
Static Site Generator
A tool that transforms templates and content (often Markdown) into a complete set of static HTML files at build time, which can then be served directly without an application server or database.
Stored Procedure
Code stored and executed inside the database server, used to encapsulate logic close to the data.
Stored-Program Computer
A computer design in which instructions live in the same read-write memory as the data, so programs can be loaded and changed without rewiring the machine.
String Matching
The problem of finding all occurrences of a pattern string within a larger text, solved efficiently by algorithms that precompute information about the pattern.
Strong Consistency
A family of guarantees, such as linearizability and external consistency, in which reads always reflect the latest committed writes, so clients never see stale or out-of-order data.
Structured Programming
The discipline of building programs from clear, nested control structures rather than unrestricted jumps, so that a program's behavior can be reasoned about.
Superscalar Execution
Issuing more than one instruction per clock cycle by replicating execution units, so a processor can complete several instructions in parallel rather than the single-instruction-per-cycle limit of a basic pipeline.
Symmetric Encryption
Encryption in which the same secret key is used to both encrypt and decrypt, making it fast but requiring the key to be shared securely in advance.
Tabs vs Spaces
The long-running holy war over whether source code should be indented with tab characters or spaces, and how language style guides settled it differently.
Tail-Call Optimization
Reusing the current stack frame when a function's final action is a call, so deep recursion runs in constant stack space instead of overflowing.
Task Runner
A tool that defines and runs named project tasks, like build, test, or deploy, so a whole workflow becomes a single short command.
Technical Debt
Ward Cunningham's metaphor that shipping not-quite-right code is like taking on debt: fast now, but it accrues interest until you repay it by refactoring.
Test Coverage
A measure of how much of a program's code is exercised by its tests, such as line, branch, or path coverage, useful for finding untested code but not a guarantee of correctness.
Test-Driven Development
A development technique in which you write a failing test before the code that makes it pass, then refactor, following a short red-green-refactor cycle.
The 10x Developer
The claim that the best programmers are an order of magnitude more productive than average, traced to a 1968 study and debated ever since.
The API Economy
The economic model in which businesses expose their capabilities as programmable, often paid, web APIs so that others can build on them, turning interfaces into products.
The Arithmetic Logic Unit
The combinational circuit at the heart of a processor that performs arithmetic and logical operations on binary operands, the working core of the CPU datapath.
The ASIC
An application-specific integrated circuit: a chip custom-built for a single task, trading the flexibility of a general processor for maximum speed and energy efficiency at that one job.
The Bit
The bit, short for binary digit, is the basic unit of information: a single yes or no, 0 or 1 choice, named in Shannon's 1948 paper and credited to John Tukey.
The Bootloader
The first code that runs when a device powers on, responsible for initializing essential hardware and loading the main program or operating system, often in multiple stages from a tiny ROM loader up to a full bootloader like U-Boot.
The Bus Factor
The number of people who would have to be lost before a project stalls, a blunt measure of how concentrated its critical knowledge is.
The Calling Convention
The agreed low-level rules for how functions pass arguments, return values, and preserve registers across calls; part of a platform's ABI, with the System V AMD64 convention governing most Unix-like x86-64 systems.
The Chaos Communication Congress
Europe's long-running hacker conference, held between Christmas and New Year since 1984 and organized by the Chaos Computer Club, blending technical hacking with politics, privacy, and digital rights.
The Church-Turing Thesis
The thesis that anything effectively computable can be computed by a Turing machine, equivalently by the lambda calculus - the claim that the Turing machine captures the intuitive notion of an algorithm.
The Clock Signal
The steady oscillating signal that synchronizes a synchronous digital system, marking the moments when state may change and setting the pace of computation.
The Code Comment
Human-readable annotations in source code that the compiler ignores; their purpose is to explain why code does what it does, the danger is comment rot, and good style favors self-documenting code.
The Computational Graph
Representing a computation as a dataflow graph of operations and the tensors that flow between them - the structure that makes automatic differentiation, optimization, and portability possible; built ahead of time (static) or as the code runs (dynamic).
The CPU Register
The small, fastest storage cells located inside the processor itself, holding the operands and results of computation; registers come in general-purpose, special-purpose, and flag varieties, organized into a register file.
The DataFrame
The labeled, columnar, tabular data structure, originating in the S and R languages and popularized in Python by pandas, that became the common language of data analysis.
The Digital Signal Processor
A processor architected for the math of signal processing, with hardware multiply-accumulate and a memory layout that feeds it, exemplified by Texas Instruments' TMS320 line.
The Embedded Toolchain
The chain of tools that turns embedded source code into a flashable binary: a cross-compiler, a linker driven by a linker script that places code and data at hardware addresses, and conversion to ELF or HEX images, exemplified by the GNU Arm Embedded toolchain.
The End of Moore's Law
The slowdown of transistor scaling and the breakdown of Dennard scaling, which ended the era of automatic single-core speedups and pushed the industry toward multicore and specialized hardware like GPUs and TPUs.
The Esoteric Programming Language
A programming language designed to experiment with weird ideas, to be hard to program in, or as a joke, rather than for practical use, a tradition stretching from INTERCAL in 1972 through Brainfuck and Malbolge.
The Fallacies of Distributed Computing
A list of eight false assumptions programmers new to distributed systems tend to make, which lead to designs that fail in production.
The Flip-Flop
The basic one-bit memory element, built from cross-coupled gates or valves, whose two stable states let a digital circuit remember and form sequential logic.
The FPGA
A field-programmable gate array: an integrated circuit whose logic and interconnect can be reconfigured by the user after manufacturing, sitting between software flexibility and fixed silicon.
The Hacker Ethic
The set of shared principles Steven Levy articulated in his 1984 book Hackers, drawn from the MIT AI Lab: access to computers should be unlimited, information should be free, authority should be mistrusted, and people should be judged by their skill.
The Halting Problem
The proof that no general algorithm can decide, for every program and input, whether it will eventually halt or run forever - the classic example of an undecidable problem.
The Instruction Cycle
The fetch-decode-execute loop a processor repeats endlessly: read the next instruction from memory, interpret it, carry it out, and advance to the next.
The Interrupt
A signal that diverts the CPU from its current work to run a handler, used by hardware to report events and by software to request services; interrupts replace wasteful polling and are dispatched through an interrupt vector table.
The JAR File
The JAR (Java ARchive) is a ZIP-format bundle of compiled Java classes, resources, and a manifest that serves as the unit of distribution for Java libraries and applications.