Self-Balancing Tree
A binary search tree that automatically keeps its height logarithmic through rotations, guaranteeing fast operations regardless of insertion order.
Concepts
Plain-language explanations of the ideas behind software - compilers, garbage collection, objects, types.
628 entries, all primary-sourced
Semantic Versioning (SemVer)
A version-numbering scheme that encodes compatibility into MAJOR.MINOR.PATCH numbers, specified by Tom Preston-Werner.
Separation of Concerns
Structuring a system so each part addresses a distinct concern with minimal overlap, allowing the parts to be understood and changed independently; the term was coined by Edsger Dijkstra in 1974.
Server-Side Rendering
Rendering a page's HTML on the server per request and sending it to the browser ready to display, in contrast to client-side rendering where the browser builds the page from JavaScript.
Serverless Computing
A cloud model where the provider fully manages and scales the servers, so developers deploy code and pay only for actual execution; 'serverless' means no servers to manage, not no servers at all.
Service Mesh
A dedicated infrastructure layer, typically built from sidecar proxies, that handles service-to-service traffic management, security, and observability without changing application code.
Service-Oriented Architecture
An architectural paradigm that structures software as network-accessible services with prescribed interfaces and contracts, the 2000s enterprise predecessor of microservices.
Sharding (Partitioning)
Splitting a dataset across multiple machines so the system can scale beyond one machine's capacity.
Shell Completion
The shell feature that completes commands, paths, and arguments when you press Tab, including programmable completion that knows each command's own options.
Shortest Path Problem
The problem of finding a lowest-cost route between nodes in a weighted graph, solved by Dijkstra's algorithm, Bellman-Ford, and A* depending on the conditions.
Side Effect
Any observable effect of a procedure beyond returning a value - mutating state, performing input or output, or signalling an error - which functional programming seeks to minimize and isolate.
Side-Channel Attack
An attack that extracts secrets not by breaking the underlying math but by measuring physical or behavioral leakage such as timing, power consumption, electromagnetic emissions, cache state, or sound.
Sidecar Pattern
A deployment pattern in which a helper container or process runs alongside a main service to add capabilities such as proxying or logging, without changing the service itself.
SIMD
Single Instruction, Multiple Data: one instruction operating in lockstep on a whole vector of data elements, a category that traces back to Flynn's 1972 taxonomy of computer organizations.
Single Sign-On (SSO)
An authentication arrangement in which one login at a trusted identity provider grants a user access to many independent systems without re-entering credentials.
Single-Page Application
A web app that loads one HTML document and then updates the page dynamically with JavaScript, instead of fetching a fresh page from the server for every interaction.
Singleton Pattern
A creational design pattern that ensures a class has only one instance and provides a global point of access to it.
Software Development Life Cycle (SDLC)
The stages a software project moves through, from requirements through design, implementation, testing, deployment, and maintenance.
Software in Safety-Critical Systems
Software whose failure can cause death, injury, or catastrophe - in avionics, medical devices, nuclear plants, and vehicles - and the standards, formal methods, and certification processes built to make such software trustworthy.
Software Quality
How well software meets its requirements and serves its users, spanning external qualities like correctness and reliability and internal ones like maintainability.
Software Supply Chain
The software supply chain is all the code, dependencies, build tools, and people that go into producing software; supply-chain security defends every link against tampering.
Software Testing
The practice of evaluating software by exercising it to find defects and check that it meets its requirements, organized into levels such as unit, integration, system, and acceptance testing.
SOLID Principles
Five object-oriented design principles popularized by Robert C. Martin - Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion - aimed at making code easier to maintain and extend.
Sorting Algorithm
A method for arranging items into a defined order, one of the oldest and most-studied problems in computing.
Space-Time Tradeoff
The common engineering choice between using more memory to run faster or less memory at the cost of more computation.
Speculative Execution
Executing instructions before the processor knows for certain that they are needed, typically past a predicted branch, and discarding the results if the guess was wrong; the architectural root of the Spectre and Meltdown vulnerabilities.
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.
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.