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.
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.
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 #