A glossary of fundamental software development terms.
Glossary
Agile Software Development
Agile Manifesto: A 2001 statement of values and principles guiding agile software development by developers.
Backlog: A prioritized list of work items, features, or user stories for the team to complete.
Burndown Chart: A graph tracking remaining work over time to monitor progress in an iteration or sprint.
Continuous Integration (CI): The practice of integrating code changes often, usually several times daily, with automated testing to identify issues early.
Daily Standup: A brief daily meeting where team members share their progress, plans, and blockers.
Increment: Working software produced in an iteration or sprint that adds to previous increments.
Iteration: A time-boxed period, usually one to four weeks, where a team plans, builds, tests, and delivers working software.
Kanban: An agile framework visualizing work flow to identify bottlenecks and boost throughput, with less structure than Scrum.
Product Owner: In Scrum, the role responsible for defining and prioritizing work, representing stakeholders, and ensuring the team builds the right things.
Retrospective: A meeting at each iteration's end where teams review successes, failures, and areas for improvement.
Scrum: The most widely used agile framework with roles, events, and artifacts for organizing work.
Scrum Master: In Scrum, the role responsible for facilitating the process, removing blockers, and coaching the team.
Sprint: In Scrum, a time-boxed iteration, usually two weeks, during which the team completes work.
Sprint Planning: A meeting at the start of a sprint where the team selects work from the backlog and plans how to complete it.
Sprint Review: A meeting at the end of a sprint where the team demonstrates working software to stakeholders and gathers feedback.
Story Points: A unit of measure for estimating work complexity, used to plan iterations and track velocity.
Test-Driven Development (TDD): A practice where developers write tests before writing code, ensuring code is testable and tests drive design.
User Story: A brief description of a feature from the user's perspective, typically written in the format: As a [type of user], I want [goal] so that [benefit].
Velocity: A measure of team work per iteration for planning future work.
Working Software: Software that's tested, functional, and usable by end users, not just code that compiles.
Algorithms
Algorithm: A finite sequence of well-defined steps that solves a class of problems or performs a computation.
Amortized analysis: A technique that averages the cost of operations over a sequence, showing that occasional expensive operations are offset by many cheap ones.
Big O notation: A mathematical notation describing an algorithm's worst-case growth rate as input size increases, ignoring constant factors.
Breadth-first search: A graph traversal that visits all neighbors at the current depth before moving deeper. Finds shortest paths in unweighted graphs.
Depth-first search: A graph traversal that explores as far as possible along each branch before backtracking. Used for connectivity, cycle detection, and topological sorting.
Divide and conquer: An algorithm strategy that splits a problem into independent subproblems, solves each recursively, and combines results.
Dynamic programming: An optimization technique that solves overlapping subproblems once, stores the results, and reuses them to avoid redundant computation.
Greedy algorithm: An algorithm that makes the locally optimal choice at each step. Efficient when the greedy-choice property holds.
Recursion: A technique where a function calls itself with a smaller input until reaching a base case. The foundation for divide-and-conquer and tree algorithms.
Space complexity: The amount of memory an algorithm uses as a function of input size, including auxiliary storage beyond the input itself.
Time complexity: The number of elementary operations an algorithm performs as a function of input size, expressed in Big O notation.
API Design and Contracts
Application Programming Interface (API): A defined way for software systems to communicate.
Backward compatibility: A change that keeps existing clients working without modification.
Contract testing: Tests that verify API behavior matches the published contract.
Hypertext Transfer Protocol (HTTP): The protocol used for most web APIs.
OpenAPI Specification (OAS): A standard format for describing HTTP APIs.
Backend Engineering
API gateway: A single entry point that routes requests to backend services, handling cross-cutting concerns like authentication and rate limiting.
Authentication: Verifying the identity of a user or service, typically through credentials, tokens, or certificates.
Authorization: Determining what actions an authenticated user or service is permitted to perform.
Caching: Storing frequently accessed data in fast storage to reduce load on slower backend systems and improve response times.
Load balancing: Distributing incoming requests across multiple server instances to prevent any single instance from becoming a bottleneck.
Middleware: Software that sits between the request and the handler, performing cross-cutting tasks like logging, authentication, or error handling.
Rate limiting: Restricting how many requests a client can make in a time window to protect services from overload or abuse.
REST: Representational State Transfer, an architectural style for APIs using HTTP methods and stateless interactions with resources identified by URLs.
Stateless service: A service that stores no client state between requests. Each request contains all the information needed to process it, simplifying horizontal scaling.
Capacity Planning
Capacity: The maximum amount of work a system can handle under given conditions.
Capacity planning: The process of determining what resources are needed to meet future demand while balancing performance, cost, and risk.
Bottleneck: The resource that limits system capacity. The slowest component determines overall capacity.
Headroom: Unused capacity reserved for growth, traffic spikes, and unexpected demand.
Utilization: The percentage of capacity currently in use.
Peak demand: The maximum load a system experiences.
Average demand: The typical load over time.
Vertical scaling (scale up): Adding more resources to existing systems (bigger servers, more CPU, more memory).
Horizontal scaling (scale out): Adding more systems (more servers, more instances, more nodes).
Elasticity: A system's ability to automatically add or remove resources based on demand.
Right-sizing: Adjusting resource provisioning to match actual needs, avoiding over- or under-provisioning.
Load testing: Measuring system capacity by simulating expected load.
Stress testing: Pushing systems beyond normal capacity to find breaking points.
Capacity modeling: Using mathematical models to predict capacity needs based on workload characteristics.
Centralized Software Systems
Centralized System: A software system where control, data storage, or processing occurs in a single location or via one coordinating component.
Monolithic Application: A single deployable unit with all functionality in one process.
Single Point of Control: One component that makes decisions or coordinates activities in a system.
Unified Data Storage: Data storage where all data is centralized or appears so from the application's view.
Coordinated Processing: Processing occurs in one location or is managed by a central component.
Client-Server Architecture: An architecture that centralizes processing on servers while clients handle presentation.
Hub-and-Spoke Integration: An integration pattern centralizing logic in a hub connecting multiple systems.
Vertical Scaling: Increasing a machine's capacity with bigger CPU, more memory, and storage.
Horizontal Scaling: Adding more machines to handle increased load.
Single Point of Failure: A component whose failure causes total system failure.
Ci Cd and Release Engineering
Artifact: A compiled, packaged output of a build process (e.g., a JAR file, Docker image, or binary).
Blue-green deployment: A deployment strategy using two identical production environments, deploying to the idle one and switching traffic.
Build: The process of compiling source code into runnable artifacts.
Canary deployment: A deployment strategy that releases code to a small percentage of users first, then gradually expands.
Continuous Deployment: Automating code deployment to production after passing tests.
Continuous Delivery: Automating code deployment with manual gates.
Continuous Integration: The practice of automatically building and testing code whenever it changes.
Deployment pipeline: The automated process that moves code from version control to production.
Feature flag: A switch that controls feature activation, allowing gradual rollouts and quick rollbacks.
Integration hell: Problems from infrequent code integration causing merge conflicts and failures.
Release engineering: The discipline of building systems that reliably package, test, and deploy software.
Rolling deployment: A deployment strategy that updates instances gradually, one at a time.
Staging environment: A production-like environment used for testing before production deployment.
Color and Contrast
Color contrast: The difference in brightness between text and its background, measured as a ratio.
Contrast ratio: A numerical value comparing the relative luminance of lighter and darker colors, ranging from 1:1 to 21:1.
Color blindness: A condition affecting color vision, where users have difficulty distinguishing certain colors.
Luminance: A measure of how bright a color appears to the human eye, accounting for how different colors affect perception.
WCAG: Web Content Accessibility Guidelines, international standards for web accessibility that include contrast requirements.
APCA: Advanced Perceptual Contrast Algorithm, a newer contrast model proposed for future versions of WCAG. APCA aims to better match human perception of contrast by considering factors like text size, weight, and background color.
Hue: The color itself, like red, blue, or green, independent of lightness or saturation.
Saturation: The intensity or purity of a color, ranging from vivid to muted.
Lightness: How light or dark a color appears, affecting contrast more than hue or saturation.
Computer Processing
ASIC: Application-Specific Integrated Circuit. A chip designed for a single task, offering maximum performance and efficiency for that workload.
Branch prediction: A CPU technique that guesses the outcome of conditional branches to keep the instruction pipeline full, avoiding stalls.
Cache hierarchy: Layers of progressively larger, slower memory (L1, L2, L3) between the CPU and main memory that reduce average access latency.
CPU: Central Processing Unit. The general-purpose processor that executes sequential instructions and coordinates system operations.
Data parallelism: Distributing the same operation across many data elements simultaneously, the core paradigm of GPU computing.
FPGA: Field-Programmable Gate Array. A chip whose logic can be reconfigured after manufacture, offering flexibility between general-purpose CPUs and fixed ASICs.
GPU: Graphics Processing Unit. A massively parallel processor with thousands of cores optimized for data-parallel workloads like rendering and machine learning.
Instruction pipeline: A CPU design that overlaps the stages of instruction execution (fetch, decode, execute) so multiple instructions are in flight simultaneously.
TPU: Tensor Processing Unit. A Google-designed accelerator optimized for matrix operations in machine learning, using a systolic array architecture.
Data Analysis
Anomaly detection: Identifying data points that deviate significantly from expected patterns, often indicating errors, fraud, or unusual events.
Causation: A relationship where one variable directly influences another. Requires controlled experiments or rigorous methods to establish, unlike correlation.
Confidence interval: A range of values that is likely to contain the true population parameter, with a specified probability (e.g., 95%).
Correlation: A statistical measure of how two variables move together. Ranges from −1 to +1 but does not imply causation.
Data quality: The degree to which data is complete, consistent, accurate, relevant, and timely enough for its intended analysis.
Descriptive analysis: Summarizing data to describe what happened, using measures like mean, median, counts, and distributions.
Exploratory data analysis: An open-ended investigation of data using visualization and summary statistics to discover patterns, outliers, and relationships before formal modeling.
Overfitting: Building a model that captures noise in the training data rather than the underlying pattern, resulting in poor performance on new data.
Predictive analysis: Using statistical models or machine learning to forecast future outcomes based on historical data patterns.
Sampling bias: A systematic error where the sample does not represent the population, leading to skewed or invalid conclusions.
Statistical significance: The probability that an observed result is not due to chance, typically assessed using a p-value threshold (e.g., p < 0.05).
Data Structures
Amortized analysis: Averaging the cost of operations over a sequence to show that occasional expensive operations (like resizing) are offset by many cheap ones.
Big O notation: A mathematical notation describing how an operation's cost grows with input size, ignoring constant factors and lower-order terms.
Cache efficiency: How well a data structure's memory layout exploits CPU cache lines. Contiguous structures like arrays are cache-friendly; pointer-heavy structures are not.
Data structure: A way of organizing data in memory that determines how efficiently it can be accessed, searched, inserted into, and deleted from.
Eviction policy: The rule a cache or bounded collection uses to decide which item to remove when full, such as least recently used (LRU) or least frequently used (LFU).
Hash collision: When two keys map to the same slot in a hash table, requiring resolution by chaining or probing.
Load factor: The ratio of stored entries to total slots in a hash table. High load factors increase collisions; most implementations resize when the factor exceeds a threshold.
Unbounded growth: A data structure that grows without limit because entries are added but never removed. A common source of memory leaks in long-running systems.
Databases
ACID properties: Atomicity, Consistency, Isolation, Durability. The guarantees a relational transaction provides to ensure data integrity.
Connection pooling: Reusing a set of pre-established database connections instead of opening a new one per request, reducing overhead.
Database index: A data structure that speeds up row retrieval by maintaining a sorted reference to column values, at the cost of additional storage and write overhead.
Foreign key: A column that references the primary key of another table, enforcing referential integrity between related records.
Normalization: Organizing database tables to reduce redundancy and dependency, typically through first, second, and third normal forms.
NoSQL: A category of databases that relax relational constraints for flexibility or scale, including document, key-value, column-family, and graph stores.
Primary key: A column or set of columns that uniquely identifies each row in a table. Must be unique and non-null.
Query optimization: The process by which a database engine chooses the most efficient execution plan for a query, using indexes, statistics, and cost estimates.
Sharding: Partitioning data across multiple database instances so each shard holds a subset, enabling horizontal scaling of writes and storage.
SQL: Structured Query Language. The standard language for querying and manipulating relational databases.
Transaction: A sequence of database operations treated as a single unit: all succeed (commit) or all are rolled back on failure.
Distributed Systems
CAP theorem: States that a distributed system can provide at most two of three guarantees simultaneously: Consistency, Availability, and Partition tolerance.
Consensus algorithm: A protocol that allows distributed nodes to agree on a value despite failures. Examples include Raft and Paxos.
Consistent hashing: A hashing scheme that minimizes key redistribution when nodes are added or removed, used in distributed caches and databases.
Distributed tracing: Following a single request through multiple services by propagating trace IDs, enabling diagnosis of latency and failures across service boundaries.
Eventual consistency: A consistency model where replicas may temporarily diverge but will converge to the same state given enough time without new writes.
Fault tolerance: A system's ability to continue operating correctly when some components fail, typically achieved through redundancy and replication.
Leader election: A consensus process where distributed nodes select one node to coordinate work, ensuring exactly one leader exists at a time.
Network partition: A failure where some nodes in a distributed system cannot communicate with others, forcing trade-offs between consistency and availability.
Partition tolerance: The ability of a distributed system to continue functioning when network partitions prevent some nodes from communicating.
Service discovery: The mechanism by which services locate each other's network addresses dynamically, rather than relying on hard-coded endpoints.
Fundamental Algorithmic Patterns
Backtracking: A recursive search strategy that builds candidates incrementally, abandoning (backtracking) a path as soon as it violates constraints. Used for N-Queens, sudoku, and subset generation.
Binary search: A search technique that halves the search space each step by comparing a target against the midpoint of a sorted range. Runs in O(log n) time.
Bit manipulation: Using bitwise operators (AND, OR, XOR, shift) to solve problems at the binary level. Common tricks include XOR for uniqueness, bitmasks for subsets, and n & (n − 1) for power-of-two checks.
Cyclic sort: An in-place sorting pattern for arrays whose values map directly to indices (e.g., 1 to n). Each element is swapped to its correct position in O(n) time and O(1) space.
Divide and conquer: A strategy that splits a problem into independent subproblems, solves each recursively, and combines results. Merge sort and quicksort are classic examples.
Dynamic programming: A technique for problems with overlapping subproblems and optimal substructure. Stores previously computed results (memoization or tabulation) to avoid redundant work.
Fast and slow pointers: A two-pointer technique where one pointer advances twice as fast as the other. Detects cycles (Floyd's algorithm) and finds midpoints in linked lists in O(n) time and O(1) space.
Frequency counting: Using a hashmap to tally occurrences of each element. Enables O(n) solutions for problems like finding duplicates, grouping anagrams, and identifying unique elements.
Greedy algorithm: An approach that makes the locally optimal choice at each step, without reconsidering. Correct only when the greedy-choice property holds; otherwise dynamic programming is needed.
Merge intervals: A pattern for combining overlapping ranges by sorting intervals by start time and merging consecutive pairs whose ranges overlap.
Minimum spanning tree: A subset of edges in a weighted graph that connects all vertices with minimum total weight and no cycles. Found with Kruskal's or Prim's algorithm.
Monotonic stack: A stack that maintains elements in increasing or decreasing order. Solves next-greater-element, histogram, and span problems in O(n) time.
Prefix sum: A precomputed array where each entry stores the cumulative sum from the start. Enables O(1) range-sum queries after O(n) preprocessing.
QuickSelect: A selection algorithm based on quicksort partitioning that finds the kth smallest element in average O(n) time without fully sorting the array.
Shortest path: The minimum-cost route between nodes in a graph. Algorithm choice depends on constraints: BFS for unweighted, Dijkstra for non-negative weights, Bellman-Ford for negative weights.
Sliding window: A technique that maintains a contiguous subarray or substring bounded by two indices, expanding and shrinking to satisfy constraints. Solves many subarray problems in O(n) time.
Sweep line: An event-based approach for interval problems. Converts intervals into start and end events, sorts them, and scans to count overlaps or detect conflicts.
Topological sort: A linear ordering of a directed acyclic graph's vertices such that every edge points forward. Used for dependency resolution, build order, and scheduling.
Trie: A tree structure where each node represents a character and paths from root to nodes spell prefixes. Supports O(L) insert and prefix lookup, where L is word length.
Two heaps: A pattern using a max-heap for the smaller half and a min-heap for the larger half of a dataset. Provides O(1) median access and O(log n) insertion for streaming data.
Two pointers: A technique using two indices that move through a sorted sequence to find pairs, remove duplicates, or validate conditions in O(n) time and O(1) space.
Union-Find: A data structure (also called disjoint set) that tracks connected components with near-constant-time union and find operations via path compression and union by rank.
Fundamental Data Structures
Array: A contiguous, indexed sequence of elements. Provides O(1) access by position but O(n) insertion or deletion in the middle.
Binary search tree: A tree where each node's left children are smaller and right children are larger. Supports O(log n) search, insert, and delete when balanced.
Deque: A double-ended queue that supports insertion and removal at both ends in O(1) time.
FIFO: First In, First Out. The access pattern of a queue: the earliest added element is removed first.
Graph: A structure of nodes (vertices) connected by edges. Models relationships like networks, dependencies, and routes.
Hash collision: When two distinct keys map to the same hash table slot. Resolved by chaining (linked lists) or open addressing (probing).
Hash map: A key-value store using a hash function for O(1) average lookup, insert, and delete. Also called dictionary, map, or associative array.
Hash set: An unordered collection of unique elements using hashing for O(1) average membership testing.
Heap: A tree-based structure that maintains the min or max element at the root. Used to implement priority queues with O(log n) insert and extract.
LIFO: Last In, First Out. The access pattern of a stack: the most recently added element is removed first.
Linked list: A sequence of nodes where each node points to the next. Supports O(1) insertion and deletion at known positions but O(n) access by index.
Queue: A FIFO structure supporting enqueue at the back and dequeue from the front, both in O(1) time.
Stack: A LIFO structure supporting push and pop at one end in O(1) time. Used for recursion, undo, and expression evaluation.
Tree traversal: Visiting every node in a tree in a defined order: preorder, inorder, postorder (depth-first), or level-order (breadth-first).
Fundamental Software Concepts
Assertion: A statement that checks whether a condition is true at a specific point in code. Fails fast to catch bugs close to their source.
Asynchronous programming: A concurrency model where operations yield control while waiting for I/O, allowing other work to proceed without threads blocking.
Circuit breaker: A resilience pattern that stops calling a failing dependency after a threshold, returning a fallback instead of waiting for timeouts.
Deadlock: A state where two or more threads each hold a resource the other needs, so none can proceed.
Defensive programming: Writing code that anticipates and handles unexpected inputs and states rather than assuming correct usage.
Exponential backoff: Increasing the wait time between retries (e.g., 1s, 2s, 4s) to reduce load on a failing system.
Garbage collection: Automatic memory management that reclaims objects no longer referenced by the program.
Immutable state: Data that cannot be changed after creation. Eliminates a class of concurrency bugs because shared data is read-only.
Memory leak: A condition where allocated memory is never freed because references to it are retained unintentionally, causing steady memory growth.
Race condition: A bug where program behavior depends on the unpredictable timing of concurrent operations accessing shared state.
State machine: A model with a finite set of states, transitions between them, and rules governing which transitions are valid.
Thread safety: The property of code that functions correctly when called from multiple threads simultaneously, without data corruption.
Fundamentals
Feynman technique: A learning method where you explain a concept in simple language, identify gaps in your understanding, then restudy and simplify again.
First principles: Reasoning from foundational truths rather than by analogy. Breaks problems into their most basic components and builds understanding from there.
Mental model: A simplified internal representation of how something works, used to reason about complex systems without needing full detail.
Pareto principle: The observation that roughly 80% of effects come from 20% of causes. In learning, a small set of fundamentals provides most of the practical value.
Spaced repetition: A study technique that reviews material at increasing intervals, exploiting the spacing effect to move knowledge into long-term memory.
Transferable knowledge: Understanding that applies across tools, languages, and frameworks. Fundamentals are transferable; implementation details are not.
Graph Databases
Node: An entity in a graph (e.g., a person, product, or concept). Has a label and optional properties.
Edge (Relationship): A connection between two nodes. Has a type, direction, and optional properties.
Property graph: A graph model where nodes and edges can have arbitrary key-value properties.
Traversal: Following edges from one node to others, possibly for multiple hops.
Cypher: A declarative query language for property graphs, used by Neo4j and others.
Gremlin: A traversal-oriented query language for property graphs, used by Apache TinkerPop-compatible databases.
RDF: Resource Description Framework. A triple-based model (subject-predicate-object) used for semantic data.
SPARQL: Query language for RDF data.
Javascript
Callback: A function passed as an argument to another function, to be called when an operation completes. The original async pattern in JavaScript.
Closure: A function combined with its lexical environment, specifically the variables that were in scope when the function was created. The function retains access to those variables even after the enclosing function has returned.
Coercion: Implicit type conversion performed by JavaScript when an operator or comparison expects a different type. The source of many unintuitive behaviors.
Event loop: The mechanism that allows JavaScript to perform non-blocking I/O on a single thread. It processes microtasks and macrotasks from queues when the call stack is empty.
First-class function: A function that can be assigned to variables, passed as arguments, and returned from other functions. JavaScript treats all functions as first-class values.
Hoisting: JavaScript's behavior of moving variable and function declarations to the top of their scope during compilation. var declarations are hoisted; let and const are hoisted but not initialized (temporal dead zone).
Microtask: A task queued by promises (.then, .catch, .finally) or queueMicrotask. Microtasks run before macrotasks and drain completely before the event loop moves on.
Macrotask: A task queued by setTimeout, setInterval, or I/O operations. One macrotask runs per event loop iteration, after all microtasks.
Promise: An object representing a value that may be available now, later, or never. Promises have three states: pending, fulfilled, or rejected. They compose with .then() and .catch().
Prototype: An object that another object delegates to for property lookup. Every JavaScript object has an internal [[Prototype]] link. The chain of prototypes ends at null.
Strict mode: A restricted variant of JavaScript ("use strict") that catches common mistakes: silent errors become thrown errors, this in plain function calls is undefined instead of the global object, and more.
Logical Fallacies
Appeal to authority: Using an expert's opinion as proof without verifying their accuracy or relevance.
Confirmation bias: Seeking and interpreting information that confirms beliefs while ignoring evidence.
False dichotomy: Presenting two options as the only choices when others exist.
Logical fallacy: A flaw in reasoning that invalidates an argument, even if persuasive.
Planning fallacy: Underestimating how long tasks will take despite evidence of previous delays.
Post hoc ergo propter hoc: Assuming A caused B because B followed A; correlation doesn't mean causation.
Strawman fallacy: Misrepresenting someone's argument to make it easier to attack, then attacking the misrepresentation instead of the actual argument.
Sunk cost: A past, unrecoverable investment of time, money, or effort.
Sunk cost fallacy: Continuing to invest in something due to prior investment, even when stopping would be better.
Maintainability
Abstraction: Removing physical, spatial, or temporal detail to focus on essentials. In code, hiding implementation behind interfaces so callers depend on behavior, not structure.
Afferent coupling: The number of modules that depend on a given module. High afferent coupling means many callers; changes ripple widely.
Code smell: A surface indication that code may have a design or maintainability problem. Suggests refactoring rather than a bug per se.
Cohesion: How closely the responsibilities of a module hang together. High cohesion means one clear purpose; low cohesion (e.g. a "utility" doing unrelated things) hurts maintainability.
Coupling: The degree to which modules depend on each other. Low coupling keeps changes local; high coupling makes changes ripple and tests harder.
Cyclomatic complexity: The number of linearly independent paths through code. Calculated from branches, loops, and conditionals.
Efferent coupling: The number of modules a given module depends on. High efferent coupling means many dependencies; the module is rigid.
Feature envy: A code smell where a method uses another object's data more than its own. Suggests the logic may belong in the other object.
God class: A class with excessive size (500+ lines) and many responsibilities. Hard to understand and change.
Refactoring: Changing the internal structure of code without changing its external behavior. Improves design and maintainability while preserving semantics.
Shotgun surgery: A code smell where one change requires edits in many files. Indicates scattered related logic.
Software maintenance: Modification of a software product after delivery to correct faults, improve performance, or adapt to a changed environment.
Technical debt: Deferred work that makes future changes harder. The metaphor: quick-and-dirty code "borrows" time and "pays interest" on every change.
Naming
Abbreviation: A shortened form of a word or phrase. Abbreviations can improve brevity but may reduce clarity if not universally understood.
Clarity: Names that quickly convey intent without explanation.
Consistency: The quality of names that follow predictable patterns throughout a codebase.
Context: The scope and visibility that determine name specificity.
Convention: A standard teams agree to follow for naming.
Discoverability: The quality of names that make code easy to find through search and navigation.
Identifier: A name that identifies a variable, function, class, or other code element.
Naming pattern: A reusable structure for common naming problems.
Scope: The context in which a name is visible and can be used.
Terminology: The words and phrases describing concepts in a domain or codebase.
Visibility: Access level to a name, like public, private, or protected.
Networking
Application layer: The protocols an application speaks, such as Hypertext Transfer Protocol (HTTP) and Domain Name System (DNS).
Authoritative nameserver: A Domain Name System (DNS) server that serves as the source of truth for a domain's records.
Domain Name System (DNS): The naming system that maps hostnames to Internet Protocol (IP) addresses.
Frame: A link-level unit of data on a local network, for example, Ethernet.
Head-of-line blocking: A condition where delayed segments in transport cause later data to wait, increasing tail latency.
Internet Protocol (IP): The network layer protocol that routes packets across networks.
Latency: The time delay between sending data and receiving a response.
Network Address Translation (NAT): A technique that rewrites addresses, commonly used with IPv4.
Open Systems Interconnection (OSI) model: A layered conceptual model for networking, often used as a vocabulary for locating failures.
Packet: A network layer unit of data sent across networks.
Port: A number that identifies a specific application endpoint on a host.
Recursive resolver: A Domain Name System (DNS) component that queries other nameservers on behalf of a client and returns the final answer.
Transmission Control Protocol and Internet Protocol (TCP/IP) model: A commonly used layered model that groups networking into link, internet, transport, and application layers.
Transmission Control Protocol (TCP): A reliable, connection-oriented transport protocol.
Transport Layer Security (TLS): A protocol for encrypting and authenticating data in transit.
User Datagram Protocol (UDP): A minimal, connectionless transport protocol.
Open Source
Contributor: A person who submits changes (code, documentation, tests) to an open-source project, typically through pull requests.
Copyleft: A licensing approach (e.g., GPL) that requires derivative works to be distributed under the same license, ensuring the code remains open.
Dual licensing: Offering software under both an open-source license and a commercial license, allowing businesses to choose based on their needs.
Fork: A copy of a repository that diverges from the original, allowing independent development. Can be a personal workspace or a permanent divergence.
Open core: A business model that offers core functionality as open source while selling proprietary features, support, or hosted services.
Open source: Software whose source code is publicly available and licensed to allow use, modification, and redistribution by anyone.
Permissive license: An open-source license (e.g., MIT, Apache, BSD) that allows almost unrestricted use, including incorporation into proprietary software.
Privacy and Compliance
Audit trail: A chronological record of who accessed or modified data and when, used to demonstrate compliance and investigate incidents.
CCPA: California Consumer Privacy Act. Gives California residents rights over their personal data, including the right to know, delete, and opt out of sale.
Data inventory: A catalog of what personal data a system collects, where it is stored, how it flows, and who has access.
Data lifecycle: The stages personal data passes through: collection, storage, use, sharing, retention, and deletion.
Data minimization: Collecting and retaining only the personal data strictly necessary for the stated purpose, reducing risk and compliance scope.
GDPR: General Data Protection Regulation. The EU law governing personal data protection, requiring lawful basis, minimization, and individual rights.
Least-privilege access: Granting users and services the minimum permissions needed to perform their tasks, limiting the blast radius of breaches.
PCI DSS: Payment Card Industry Data Security Standard. Security requirements for organizations that handle credit card data.
Personal data: Any information that can identify a person directly (name, email) or indirectly (IP address, device ID, behavioral patterns).
Retention policy: Rules defining how long data is kept and when it must be deleted, balancing legal requirements with minimization principles.
SOC 2: Service Organization Control 2. An audit framework assessing security, availability, processing integrity, confidentiality, and privacy controls.
Program Management
Program: A group of related projects managed together to achieve strategic objectives that individual projects can't deliver alone.
Program management: Coordination of related projects to meet strategic goals, covering alignment, project management, dependencies, and governance.
Project: A temporary effort with scope, timeline, and deliverables.
Project management: Application of knowledge, skills, tools, and techniques to project activities to meet requirements.
Portfolio: A collection of programs, projects, and work managed to achieve strategic goals.
Portfolio management: Selection and management of programs and projects for strategic goals.
Strategic alignment: Ensuring programs support organizational goals and deliver valuable outcomes.
Project coordination: Ensuring related projects collaborate toward shared outcomes, not in isolation.
Dependency management: Managing project interdependencies to prevent delays.
Governance: Structures and processes for decision-making, escalation, and accountability at the program level.
Interdependency: A relationship where one project's output affects another's work.
Program manager: The person coordinating a program to ensure strategic value.
Stakeholder: A person or group affected by or interested in a program.
Program objective: A strategic outcome a program aims for, often unachievable by individual projects.
Python
Duck typing: A typing system that assesses an object's suitability based on methods and properties, not its class or inheritance.
Bytecode: An intermediate Python code representation the Python Virtual Machine executes.
LEGB rule: The order Python searches for variables: Local, Enclosing function, Global module, Built-in.
Closure: A function that remembers variables from its scope even after exit.
Mutable: Objects that can be modified after creation (lists, dictionaries, sets).
Immutable: Objects that cannot be modified after creation (strings, tuples, numbers).
Aliasing: When multiple variables reference the same object in memory.
First-class function: Functions that can be passed as arguments, returned from other functions, and assigned to variables.
Special methods: Methods with double underscores (dunder methods) that customize object behavior, like __init__ or __str__.
Context manager: An object that defines __enter__ and __exit__ methods for resource management, typically used with the with statement.
Generator: A function using yield to lazily produce values one at a time instead of computing all at once.
Iterable: Any object that can be looped over (lists, tuples, strings, dictionaries, generators).
Type hints: Optional annotations that specify expected types for variables, parameters, and return values (PEP 484).
REPL: Read-Eval-Print Loop, an interactive environment where you can type Python expressions and see results immediately.
Rust
Borrow checker: The Rust compiler component that enforces ownership and borrowing rules, ensuring references don't outlive data and avoiding conflicting mutable access.
Borrowing: Using a reference (&T or &mut T) to access a value without taking ownership. The borrower can't outlive the owner, and mutable borrowing is exclusive.
Lifetime: How long a reference is valid. The compiler checks or infers lifetimes to prevent using a reference after its value is dropped.
Ownership: The rule that each value has one owner. When the owner goes out of scope, the value is dropped. Assigning or passing by value transfers ownership.
Result<T, E>: A type for success (Ok(T)) or failure (Err(E)), used in operations that can fail. The type system ensures callers handle both cases.
Send: A trait for types safe to transfer across thread boundaries, used by the compiler to prevent data races.
Sync: A trait for types safely shareable by reference across threads (&T is Send). Used with Send to ensure thread safety.
Trait: A set of methods or type requirements that can be implemented for abstraction and generic programming, such as Clone, Send, Sync, Display.
Zero-cost abstraction: Rust offers zero-cost abstractions like iterators and traits, ensuring safety and expressiveness without runtime costs, resulting in code as efficient as hand-written low-level code.
Software Accessibility
Accessibility: The practice of building interfaces that everyone can use, regardless of ability.
ARIA: Accessible Rich Internet Applications attributes that enhance HTML when semantic elements aren't sufficient.
ARIA live regions: ARIA attributes (aria-live, aria-atomic, aria-relevant) that announce dynamic content changes to screen reader users without requiring them to navigate to that content.
Assistive technology: Software or hardware that helps users with disabilities interact with interfaces, such as screen readers or voice control.
Focus indicator: Visual indication of which element currently has keyboard focus.
Semantic HTML: HTML elements that convey meaning about content structure and purpose.
Screen reader: Software that reads content aloud to users who are blind or have low vision.
WCAG: Web Content Accessibility Guidelines, international standards for web accessibility.
Software Architecture
Event-driven architecture: A pattern where components communicate by producing and consuming events asynchronously, enabling loose coupling and independent scaling.
Graceful degradation: Designing a system to maintain core functionality when non-critical components fail, rather than failing entirely.
Layered architecture: A pattern organizing code into horizontal layers (presentation, business logic, data access) where each layer depends only on the layer below.
Loose coupling: A design where components depend on each other as little as possible, so changes in one component have minimal impact on others.
Microservices: An architectural style decomposing an application into small, independently deployable services, each owning its own data and logic.
Monolithic architecture: A single deployable unit containing all application functionality. Simple to develop and deploy initially but harder to scale and modify as it grows.
Non-functional requirements: Quality attributes like performance, security, availability, and maintainability that constrain how a system must behave, not what it does.
Software architecture: The high-level structure of a system: its components, their relationships, communication patterns, and the principles guiding their design.
System boundary: The dividing line between what is inside a system or component and what is outside, defining interfaces and responsibilities.
Tight coupling: A design where components depend heavily on each other's internals, so changes in one force changes in others.
Software Availability
Availability: The percentage of time a system is accessible and functional when users need it.
Nines: Shorthand for availability percentages. "Three nines" means 99.9%, "four nines" means 99.99%.
SLA (Service Level Agreement): External contract with customers specifying guaranteed availability and consequences for failing to meet it.
SLO (Service Level Objective): Internal target for availability that's typically higher than the SLA.
SLI (Service Level Indicator): Actual measured availability metric.
Error Budget: The allowed downtime based on your availability target. If you target 99.9%, your error budget is 0.1%.
Redundancy: Having backup components ready to take over when primaries fail.
Active-Active: Multiple components handling traffic simultaneously.
Active-Passive: One component handles traffic, while the others remain on standby.
Failover: The process of switching from a failed component to a backup.
Health Check: A periodic test to verify that a component is working correctly.
Load Balancer: Distributes requests across multiple servers.
Circuit Breaker: Stops calling a failing service to prevent cascading failures.
Graceful Degradation: Maintaining core functionality when non-critical components fail.
Replication: Maintaining copies of data across multiple database instances.
Replication Lag: The delay between writing to a primary and the change appearing in replicas.
Eventual Consistency: Data will eventually become consistent across replicas, but may be temporarily inconsistent.
Timeout: Maximum time to wait for an operation before considering it failed.
Retry: Attempting an operation again after failure.
Exponential Backoff: Increasing wait time between retries exponentially (1s, 2s, 4s, 8s).
Jitter: Random variation added to retry timing to prevent thundering herds.
Cascading Failure: One component's failure triggers failures in other components.
Split Brain: Multiple components think they're primary because they can't communicate with each other.
Thundering Herd: Many clients simultaneously retry when a shared resource recovers from failure.
Idempotency: An operation that produces the same result when repeated multiple times.
Software Business Management
Balance sheet: Financial statement showing assets, liabilities, and equity at a point in time.
Budget: Financial plan for a year's resource allocation.
Competitive advantage: What makes a software company stand out to customers.
Controlling: Management monitors performance and adjusts.
Differentiation: Competitive strategy of offering unique value customers pay for.
Financial management: Practice of managing financial resources.
Human resource management (HRM): Practice of recruiting, developing, and retaining employees.
Income statement: Financial statement showing revenue, expenses, and profit.
Leading: Management involves motivating and guiding people toward goals.
Operations management: Practice of designing, managing, and improving software processes.
Organizing: Management of resources and workflows.
Planning: Management involves setting objectives and determining how to achieve them.
Strategic management: The process of setting long-term direction and making decisions to achieve competitive advantage.
SWOT analysis: Framework analyzing Strengths, Weaknesses, Opportunities, Threats.
Software Caching
Cache hit: The requested value is found in the cache and served from it.
Cache miss: The requested value is either not in the cache or expired, so the system must fetch or recompute it.
Hit rate: The fraction of requests that are cache hits.
Time-to-live (TTL): A duration after which a cached value is considered expired.
Eviction: Removal of cached items to make room for others, usually based on a policy like least recently used.
Stampede (dogpile): Many concurrent requests miss at the same time and overload the backend.
Negative caching: Caching a "not found" result to avoid repeated lookups.
Source of truth: The system that owns the authoritative version of the data (often a database).
Software Debugging
Correlation ID: A unique identifier generated at the edge of a request and propagated through all services, enabling tracking of a single request across a distributed system.
Evidence ladder: An ordered sequence of checks from cheap to expensive, designed to test the highest-probability explanations first.
Hypothesis: A proposed explanation that makes testable predictions.
Invariant: A condition that must always be true for correctness.
Reduction: The process of making a failing case smaller by removing dependencies, shrinking inputs, or eliminating variables until the explanation becomes obvious.
Regression: A bug where something that used to work stops working after a change.
Root cause: The most actionable explanation that, when fixed, prevents recurrence.
Symptom: The observed effect of an underlying problem.
Software Design
Cohesion: How closely the responsibilities within a module relate to each other. High cohesion means a single, clear purpose.
Coupling: The degree to which modules depend on each other. Low coupling keeps changes local and makes testing easier.
Design pattern: A reusable solution to a commonly occurring design problem, such as Factory, Observer, or Strategy.
DRY: Don't Repeat Yourself. A principle that every piece of knowledge should have a single, authoritative representation in the system.
KISS: Keep It Simple, Stupid. A principle favoring the simplest solution that meets requirements over clever or complex alternatives.
Principle of least surprise: Design should behave the way users and developers expect, minimizing confusion and reducing bugs caused by unexpected behavior.
Single responsibility principle: A class or module should have one reason to change. Part of SOLID; keeps units focused and easier to test.
SOLID principles: Five design principles (Single responsibility, Open/closed, Liskov substitution, Interface segregation, Dependency inversion) for maintainable object-oriented code.
YAGNI: You Aren't Gonna Need It. A principle advising against building features or abstractions until they are actually required.
Software Development
Agile development: An iterative approach to software delivery that builds working software incrementally, adapting to feedback and changing requirements.
Code review: A practice where developers examine each other's code changes to catch bugs, share knowledge, and maintain quality standards.
Continuous integration: Automatically building and testing code on every commit so integration problems are detected within minutes, not days.
Debugging: The process of finding, understanding, and fixing defects in software by forming and testing hypotheses about the root cause.
Refactoring: Changing code's internal structure without altering its external behavior to improve readability, reduce complexity, or eliminate duplication.
Technical debt: Shortcuts or deferred work that make future changes harder. Accumulates interest in the form of slower development and more bugs.
Version control: A system (like Git) that tracks changes to files over time, enabling collaboration, history review, and safe experimentation via branches.
Software Development Operations
API (Application Programming Interface): How software systems communicate with one another. Well-designed APIs enable integration and coordination. Poor APIs require custom workarounds for every integration.
CI/CD (Continuous Integration/Continuous Deployment): A development practice where code changes are integrated frequently and automatically deployed to production after passing automated tests.
Circuit Breaker: A pattern that prevents cascading failures. When a dependency fails, the circuit breaker stops sending requests and returns fallback responses instead of waiting for timeouts.
Deployment Frequency: How often code changes reach production. High-performing organizations deploy multiple times per day. Low-performing organizations deploy monthly or quarterly.
Distributed Tracing: Following a single transaction through multiple services. Essential for diagnosing problems in systems that span many services.
Graceful Degradation: Maintaining partial functionality when components fail. Example: showing cached product information when the inventory service is down.
Incident: A production problem that affects business operations. Examples: outages, performance degradation, data corruption.
Infrastructure as Code: Defining servers, networks, and configuration in version-controlled files instead of manual configuration.
Mean Time to Detect (MTTD): How long it takes to notice a problem occurred. High-performing organizations measure this in minutes.
Mean Time to Recovery (MTTR): How long it takes to restore normal operations after a failure. High-performing organizations resolve incidents in under one hour.
Observability: The ability to understand system behavior from external outputs like metrics, logs, and traces.
Operational Visibility: Whether leaders can see what is happening in systems and processes in real time to make effective decisions.
Technical Debt: Shortcuts taken during development that create future costs. Must be managed deliberately, or it accumulates and slows development velocity.
System Reliability: Whether systems work when operations need them. Measured by availability, accuracy, performance under load, and recovery time.
Software Maintainability
Code quality: Characteristics that make code readable, simple, consistent, and correct.
Code smell: An indicator of potential maintainability issues, though not necessarily a bug.
Cyclomatic complexity: A metric measuring the number of independent code paths, indicating logic complexity.
Dependency: External code your system uses for functionality without implementation.
Legacy code: Code that's difficult to understand or modify due to missing tests, poor structure, or lost knowledge.
Maintainability: The ease of modifying, debugging, and extending code over time.
Refactoring: Improving code structure incrementally without changing behavior.
Technical debt: Shortcuts taken during development that make future changes harder, accumulating cost over time.
Test coverage: The percentage of code executed by tests, showing how much is verified by automation tests.
Software Marketing
Attribution: Crediting marketing touchpoints for customer actions and revenue.
Channel: Medium for marketing messages (e.g., website, email, social media).
Conversion: Customer action indicating purchase progress (e.g., trial signup, demo request, purchase).
Go-to-market strategy: A strategy to reach customers and bring products to market.
Marketing funnel: Customer journey model from awareness to action, highlighting stages and drop-offs.
Messaging: Communication translating product capabilities into customer language and benefits.
Positioning: How customers perceive your product compared to alternatives, defining category, target, and differentiation.
Product-led growth (PLG): Growth strategy using the product as the main marketing and acquisition channel.
Value proposition: Clear statement of the unique value your product provides.
Software Performance
Latency: Time between a request and its response.
Throughput: Work completed per unit time (for example, requests per second).
Percentile: A value below which a given percentage of observations fall (for example, p95).
Tail latency: The slow end of the latency distribution (often p95 and p99).
Saturation: A resource is at capacity, and work must wait (queues form).
Service level objective (SLO): A target for system behavior, like reliability or latency, used to make trade-offs.
Software Performance Testing
Bottleneck: A component or resource that limits system performance.
Endurance testing: Testing system behavior over time to detect memory leaks, resource exhaustion, and degradation.
Load testing: Testing system behavior under expected load to verify performance.
Performance requirements: Specific, measurable criteria that define "good performance" for a system.
Performance testing: Verifying systems meet performance under expected and peak conditions.
Response time: Time from request to response, usually in milliseconds.
Spike testing: Testing system response to sudden load spikes to verify capacity.
Stress testing: Testing system limits to find breaking points and max capacity.
Throughput: Requests processed per second.
Volume testing: Testing system behavior with large data to verify it can handle expected volumes.
Software Project Management
Buffer: Extra time added to estimates to account for uncertainty and risk.
Critical Path: The sequence of dependent tasks that defines the minimum project duration. Delays in these tasks delay the whole project.
Dependency: A relationship where one task depends on another's completion.
Estimate: A prediction of work duration or cost based on available information.
Milestone: A key point that marks the completion of a significant phase or deliverable.
Risk: An uncertain event that negatively impacts the project if it occurs.
Scope: What the project will deliver and exclude.
Scope Creep: Gradual expansion of project scope without adjusting time, cost, or resources.
Slack (or Float): Extra time for non-critical tasks before they impact the schedule.
Stakeholder: Anyone impacted by the project, including sponsors, users, team members, and external parties.
Triple Constraint: The relationship between scope, time, and cost that shapes software project trade-offs. Also called the project management triangle.
Work Breakdown Structure (WBS): Hierarchical decomposition of project scope into manageable pieces.
Software Quality Assurance
Quality assurance (QA): Practices that shape software production to prevent defects and reduce risk.
Quality control (QC): Practices that evaluate software for defects and gaps.
Continuous integration (CI): A practice of frequent code integration and automated validation.
Defect: A software problem that can cause incorrect behavior, user harm, or operational pain.
Regression: A defect where something that used to work stops working after a change.
Software Scalability
Scalability: A system's ability to handle increased load by adding resources.
Horizontal scaling (scale out): Adding more instances of a component to handle increased load.
Vertical scaling (scale up): Adding more resources to existing instances to handle increased load.
Elasticity: A system's ability to automatically add or remove capacity based on demand.
Bottleneck: The component that limits system capacity. The slowest component determines overall performance.
Stateless design: Application design that eliminates server-side state, making horizontal scaling easier.
Stateful design: Application design that maintains server-side state, creating scalability constraints.
Load balancing: Distributing requests across multiple instances to prevent any single instance from becoming overloaded.
Caching: Storing frequently accessed data in fast storage (memory) to reduce load on slower systems.
Read replicas: Database copies that handle read queries, distributing read load across multiple instances.
Sharding: Partitioning data across multiple databases, with each shard handling a subset of data.
Microservices: An architecture pattern that decomposes applications into small, independent services that can scale independently.
Message queue: An asynchronous messaging system that decouples components, enabling independent scaling of producers and consumers.
Scalability ceiling: The point where adding resources provides diminishing returns or no benefit due to coordination overhead or shared bottlenecks.
Coordination overhead: The cost of coordinating multiple components (consensus, locking, synchronization) that reduces efficiency as systems scale.
Software Security
Authentication: The process of verifying a user's identity.
Authorization: The process of determining user permissions.
Attack surface: All possible attacker entry points, including APIs, user interfaces, endpoints, and integrations.
Threat modeling: A structured method to identify what you're protecting, who you're protecting it from, potential attack vectors, and essential defenses.
Ciphertext: Encrypted data unreadable without the key.
Confidentiality: The security goal of keeping data private and accessible only to authorized users.
Defense in depth: Using multiple security layers so that if one fails, others protect.
Encryption: The process of transforming readable data into unreadable data using an algorithm and a key.
Integrity: The security goal of keeping data accurate and unmodified by unauthorized changes.
Multi-factor authentication (MFA): Authentication that requires two or more factors to verify identity.
Plaintext: Unencrypted data that is readable.
Principle of least privilege: The security principle that users should have the minimum permissions needed to perform their tasks.
Threat: A potential attack that could harm a system.
Vulnerability: A weakness in a system that attackers can exploit.
Software Testing
Assertion: A statement in a test that checks whether an actual result matches the expected result. The test fails if the assertion is false.
End-to-end test: A test that exercises the full system from user input to final output, verifying that integrated components work together correctly.
Flaky test: A test that passes or fails inconsistently without code changes, often due to timing, shared state, or external dependencies.
Integration test: A test that verifies interactions between components, such as a service calling a database or another service.
Mocking: Replacing a real dependency with a controlled substitute in tests to isolate the unit under test and control its environment.
Regression testing: Re-running tests after changes to verify that existing functionality still works and no new bugs were introduced.
Test coverage: The percentage of code exercised by tests. Useful as a trend indicator but not a guarantee of quality by itself.
Test-driven development: A practice of writing a failing test first, then writing the minimum code to pass it, then refactoring. Drives design through tests.
Unit test: A test that verifies a single function or method in isolation, running fast and without external dependencies.
Software Usability
Affordance: A visual or functional cue showing what users can do with an interface element.
Efficiency: Speed at which users complete tasks.
Error prevention: How interfaces prevent user errors and support recovery.
Learnability: How easily users perform basic tasks on first use.
Memorability: How easily users can remember how to use software after not using it for a while.
Progressive disclosure: Revealing complexity gradually with simple interfaces first and advanced features as needed.
Satisfaction: The software is pleasant and enjoyable to use.
Usability: How effectively users accomplish tasks with software, covering learnability, efficiency, memorability, error prevention, and satisfaction.
Usability testing: Evaluating user effectiveness through observation and measurement.
User-centered design: Design approach focusing on user needs and goals.
Software User Experience
Accessibility: Designing so people with disabilities can use the product effectively.
Cognitive load: The mental effort required to understand and use the interface.
Information architecture (IA): How content and navigation are organized.
Jank: Visible stutter or lag during interactions, usually caused by dropped frames or main-thread work.
Task success rate: The percentage of users who complete a task successfully.
Telemetry: The events, logs, metrics, and traces you collect to understand system behavior.
User experience (UX): The end-to-end experience of using a product to achieve goals.
User interface (UI): The screens and controls someone uses to interact with a product.
Statistics
Central limit theorem: The principle that the distribution of sample means approaches a normal distribution as sample size grows, regardless of the population's shape.
Confidence interval: A range of values constructed so that it contains the true population parameter with a specified probability (e.g., 95%).
Effect size: A measure of the magnitude of a result, independent of sample size. Tells you whether a statistically significant finding is practically meaningful.
Hypothesis testing: A procedure that uses sample data to evaluate a claim about a population, typically comparing a null hypothesis against an alternative.
Mean: The arithmetic average of a dataset, calculated by summing all values and dividing by the count.
Median: The middle value when data is sorted. More robust to outliers than the mean.
Normal distribution: A symmetric, bell-shaped probability distribution defined by its mean and standard deviation. Many natural phenomena approximate it.
Null hypothesis: The default assumption that there is no effect or no difference. Statistical tests evaluate evidence against this assumption.
P-value: The probability of observing results at least as extreme as the data, assuming the null hypothesis is true. Not the probability that the hypothesis is correct.
Standard deviation: A measure of how spread out values are from the mean. Low values indicate data clustered near the mean; high values indicate wide dispersion.
Statistical power: The probability that a test correctly rejects a false null hypothesis. Depends on sample size, effect size, and significance level.
Type I error: Rejecting a true null hypothesis (a false positive). The probability is controlled by the significance level (alpha).
Type II error: Failing to reject a false null hypothesis (a false negative). The probability decreases as sample size and effect size increase.
Technical Writing
Active voice: Sentence structure where the subject performs the action (e.g., "the server returns an error"), preferred in technical writing for clarity and directness.
Cognitive load: The mental effort required to process information. Good technical writing minimizes unnecessary cognitive load through clear structure and language.
Curse of knowledge: A cognitive bias where experts assume their audience knows what they know, leading to explanations that skip essential context.
Diátaxis framework: A documentation framework organizing content into four types by purpose: tutorials (learning), how-to guides (tasks), reference (information), and explanation (understanding).
Information architecture: The organization and structure of content, including navigation, hierarchy, and labeling, so readers can find what they need.
Progressive disclosure: Presenting essential information first and revealing complexity gradually, so readers are not overwhelmed by detail they do not yet need.
Scannable content: Content structured with headings, lists, and short paragraphs so readers can quickly locate relevant information without reading everything.
The Web
Browser: Software that requests and displays web pages (Chrome, Firefox, Safari, Edge).
CSS: Cascading Style Sheets, the language that styles HTML content.
DNS: Domain Name System, converts domain names like example.com to IP addresses.
DOM: Document Object Model, the browser's tree representation of HTML that JavaScript can manipulate.
HTTP: Hypertext Transfer Protocol, the protocol browsers use to request web content.
HTTPS: HTTP with TLS encryption.
HTML: Hypertext Markup Language, the language that structures web content.
JavaScript: The programming language that runs in browsers to add interactivity.
Rendering: The process of converting HTML, CSS, and JavaScript into pixels on screen.
Same-origin policy: Security policy preventing JavaScript from accessing data on different origins.
URL: Uniform Resource Locator, the address that identifies a web resource.
Web standards: Specifications that define how web technologies should work, ensuring browser compatibility.
Timeouts
Timeout: Maximum operation duration before failure.
Connection timeout: Maximum time to establish a connection (e.g., TCP/TLS handshake).
Read timeout: Maximum wait time for response data after connecting.
Write timeout: Maximum time to complete sending the request.
Idle timeout: Maximum time a connection can sit unused before closing.
Cascading failure: When failure or slowness in one component causes others to fail, like exhausted connections.
Tail latency: High latency percentiles (e.g., p99, p99.9) often dominate large-scale user experience.
Exponential backoff: Increasing delay between retries (e.g., 1s, 2s, 4s) reduces load on a failing dependency.
Jitter: Random variation added to retry delay to prevent many clients retrying simultaneously.
Circuit breaker: Pattern that halts calling a failing service after a threshold and permits retries after cooldown.
SLO (Service Level Objective): Internal target for meeting availability or latency goals.
SLA (Service Level Agreement): External customer contracts specifying guaranteed availability or latency and consequences for failure.
Typography
Ascender: The part of a lowercase letter that extends above the x-height (as in "b", "d", "h").
Baseline: The imaginary line on which most letters sit. Descenders extend below the baseline.
Descender: The part of a lowercase letter that extends below the baseline (as in "g", "p", "y").
Font: A digital file containing a typeface design. In traditional typography, a font was a specific size of a typeface.
Kerning: Adjusting spacing between specific character pairs to improve appearance.
Leading: Line spacing, the vertical space between lines of text. Named for the lead strips used in metal type.
Legibility: How easily individual characters can be distinguished from each other.
Ligature: Two or more characters combined into a single glyph (as in "fi" or "fl").
Measure: The width of a line of text, typically measured in characters.
Readability: How easily text can be read and understood as a whole.
Serif: Small strokes at the ends of letterforms in serif typefaces.
Tracking: Adjusting overall spacing between characters in a block of text.
Typeface: A design family of characters (like Helvetica or Times New Roman). Often used interchangeably with "font" in digital contexts.
Widow: A single word or short line at the top of a column or page, separated from the rest of its paragraph.
X-height: The height of lowercase letters (excluding ascenders and descenders), typically measured using the letter "x".
Comments #