Software Engineering Glossary
Key terms from the Software Engineering course, linked to the lesson that introduces each one.
736 terms.
A
- Abbreviated approval chains
- A designated "break glass" authority (often a senior engineer or on-call lead) can greenlight the release without full stakeholder sign-off
- Lesson 1549 — Emergency Release Procedures
- Abstract Factory
- An Abstract Factory is like ordering a complete dining set.
- Lesson 238 — Abstract Factory vs Factory Method
- Accept when
- The reviewer raises valid concerns about bugs, readability, maintainability, or team standards you missed.
- Lesson 1619 — Receiving Code Review Feedback
- Acceptance Criteria
- Acceptance Criteria are specific to one user story.
- Lesson 149 — Acceptance Criteria vs Definition of Done
- Accepted
- The team has agreed and implementation is underway or complete
- Lesson 1703 — ADR Status and Lifecycle
- Access control
- Access control means restricting secret access to only those who need it—the principle of least privilege.
- Lesson 746 — Access Control and Audit Logging for Secrets
- Access control changes
- A user requests elevated permissions, but only an administrator can grant them
- Lesson 1037 — Separation of Duties
- Access tokens
- Access tokens are short-lived credentials that grant access to protected resources—think of them as temporary visitor badges.
- Lesson 1021 — Access Tokens, Refresh Tokens, and Token Lifetime
- Accessibility
- Accessibility is ensuring people with disabilities can use your system equally well.
- Lesson 1245 — Usability and Accessibility
- Action
- A log message or expression to evaluate
- Lesson 1730 — Conditional Breakpoints and Breakpoint Actions
- Adapter
- Adapter is like buying a power plug adapter when traveling abroad—your device already exists, the outlet already exists, and they don't match.
- Lesson 262 — Adapter vs Bridge: Understanding the DistinctionLesson 1264 — The Ports and Adapters Pattern
- Adapters
- Adapters are like specialized bridges or mechanisms that connect those ports to the outside world.
- Lesson 1264 — The Ports and Adapters Pattern
- Added complexity
- More code means more to test, debug, and maintain
- Lesson 170 — You Aren't Gonna Need It (YAGNI)
- Adding new states
- Adding new states is likely (system will evolve)
- Lesson 311 — State Pattern vs Conditional Logic
- Adding required parameters
- requests missing the new mandatory field are rejected
- Lesson 847 — Breaking vs Non-Breaking Changes
- Additional Method Calls
- A Decorator wraps another object, forwarding each method call. That's an extra function call on the stack for every operation. A chain of three decorators means three extra calls.
- Lesson 282 — Performance Overhead of Structural Patterns
- Additive changes
- Adding optional fields is safe—old consumers ignore them
- Lesson 1343 — Event Schemas and Contracts
- Affected Scope
- Include labels or tags showing which instances, regions, or customers are impacted.
- Lesson 1160 — Alert Context: Including Diagnostic Information
- aggregate
- An aggregate is a cluster of related domain objects (entities and value objects) treated as a single unit for data changes.
- Lesson 1284 — Aggregates and Consistency Boundaries
- Aggregations happen frequently
- Storing pre-calculated totals (like order_total alongside order items) avoids re-summing every time
- Lesson 865 — Strategic Denormalization
- Amplification
- Amplification means repeating or crediting ideas from underrepresented colleagues when they're overlooked.
- Lesson 1854 — Allyship and Advocacy in Engineering
- Analogy
- Imagine a coffee shop queue. In a push system, the barista is handed five orders at once (overwhelming). In a pull system, they take the next order slip only when they finish the current drink—smooth, sustainable flow.
- Lesson 414 — Moving Tests Down the PyramidLesson 1339 — Events vs Messages vs CommandsLesson 1596 — Pull Systems vs Push Systems
- Annotated tags
- Annotated tags are full Git objects that store the tagger's name, email, date, and a message.
- Lesson 1556 — Version Tagging in Git
- Annotations
- Annotations are also key-value pairs, but they're for storing non-identifying metadata that you don't query on.
- Lesson 1445 — Labels, Selectors, and Annotations
- Another example
- The Classpath Exception in OpenJDK allows linking GPL Java libraries into non-GPL applications, solving a major compatibility problem.
- Lesson 1876 — Dual Licensing and License Exceptions
- API Gateway
- An API Gateway is a server that acts as a single entry point for all external clients (web apps, mobile apps, third-party systems) into your microservices ecosystem.
- Lesson 1327 — API Gateway Pattern
- API Server
- The central hub. Every request (deploy a container, scale up, check status) goes through the API server. It's the only component that talks directly to the datastore (etcd).
- Lesson 1443 — Kubernetes Architecture Overview
- Application servers
- Application servers are immutable containers or instances that hold no local state
- Lesson 1477 — Handling State in Immutable Systems
- Architecture alignment
- Architecture alignment means translating these goals into technical decisions that make them achievable.
- Lesson 1233 — Business Goals and Architecture Alignment
- Architecture governance
- Architecture governance is the framework of processes, policies, and practices that ensure technical decisions align with organizational goals and standards.
- Lesson 1251 — Architecture Governance and Standards
- Arrange
- Set up everything your test needs—create objects, configure dependencies, prepare test data. This is your setup phase.
- Lesson 446 — Arrange-Act-Assert Pattern
- Artifacts
- Artifacts are immutable build outputs (compiled binaries, container images, packages) that flow through the pipeline.
- Lesson 700 — Anatomy of a Deployment Pipeline
- Assumptions
- Clarifying constraints ("Assumes input array is pre-sorted")
- Lesson 132 — Constraints and AssumptionsLesson 1684 — Code Comments and Inline Documentation
- Asynchronous processing
- Asynchronous processing means separating the acceptance of work from its execution.
- Lesson 1385 — Asynchronous Processing and Message Queues
- Asynchronous replication
- The leader acknowledges writes immediately without waiting for followers. Faster, but followers may temporarily lag behind—creating the risk of reading stale data or losing recent writes if the leader fails.
- Lesson 1402 — Leader-Follower Replication
- At-Least-Once
- The event is delivered one or more times. It will definitely arrive, but you might receive duplicates due to retries after network failures or timeouts. This is the most common practical guarantee.
- Lesson 1344 — At-Least-Once vs Exactly-Once DeliveryLesson 1361 — Delivery Guarantees: At-Most, At-Least, Exactly-Once
- At-Most-Once
- The event is delivered zero or one time. It might get lost, but never duplicated. Think of throwing a letter into a mailbox and hoping it arrives—no tracking, no retries.
- Lesson 1344 — At-Least-Once vs Exactly-Once Delivery
- Attack surface
- Attack surface refers to the sum total of all possible entry points an attacker could use to compromise your system.
- Lesson 1038 — Minimize Attack Surface
- attack tree
- An attack tree is a visual diagram that breaks down how an attacker might achieve a specific goal.
- Lesson 1082 — Attack Trees and Risk Prioritization
- Auditing
- Auditing means examining your declared dependencies to understand what's actually being used in your codebase.
- Lesson 681 — Dependency Pruning and Auditing
- authentication
- Think of a hotel: authentication is proving you're a guest (showing your ID at check-in), while authorization is determining which room you can enter (your key card only opens your room, not others).
- Lesson 1025 — Authorization Fundamentals: Who Can Do What
- authentication factors
- Authentication relies on three distinct types of proof, called authentication factors:
- Lesson 991 — The Three Factors of Authentication
- authorization
- Think of a hotel: authentication is proving you're a guest (showing your ID at check-in), while authorization is determining which room you can enter (your key card only opens your room, not others).
- Lesson 1025 — Authorization Fundamentals: Who Can Do What
- Automated Refactorings
- Automated Refactorings are your safest bet.
- Lesson 1756 — Preserving Behavior While Changing Structure
- availability
- Think of it like a local fire station: availability means the station is open and staffed 24/7, while reliability means when you call 911, the equipment works, trucks start, and firefighters actually arrive.
- Lesson 131 — Reliability and Availability Requirements
- Available but unreliable
- The machine is always powered on and accepts your money (high availability), but occasionally gives you the wrong snack or wrong change (low reliability).
- Lesson 1241 — Availability and Reliability
- axe-core
- axe-core is a widely-used JavaScript library that integrates into your E2E or UI tests.
- Lesson 582 — Automated Accessibility Testing
B
- backing service
- A backing service is any service your application consumes over the network—databases, message queues, email services, caching systems, or third-party APIs.
- Lesson 750 — Backing Services and Build-Release-Run Factors
- Backward compatibility
- Backward compatibility means new versions of your software can work with data, configurations, or clients designed for older versions.
- Lesson 790 — Why API Versioning MattersLesson 1553 — Version Compatibility and Breaking Changes
- Backward recovery
- Backward recovery means abandoning the original goal and executing compensating transactions for all previously completed steps.
- Lesson 1369 — Forward Recovery vs Backward Recovery
- baseline
- A baseline is your system's "normal" performance profile—a reference snapshot of latency, throughput, CPU usage, and other metrics when everything is working well.
- Lesson 1211 — Baseline Metrics and Regression Detection
- Batch Fetching
- Batch Fetching is a lazy loading optimization—it loads related data in chunks as accessed.
- Lesson 945 — Eager Loading and Fetch Strategies
- Behavior verification
- Behavior verification is different: it tests how your code interacts with its dependencies, not just what it produces.
- Lesson 483 — Behavior Verification: Testing Interactions
- Better minimization
- The framework can explore the entire space of simpler inputs more systematically
- Lesson 619 — Integrated Shrinking
- Better partition tolerance
- The system continues working during network splits
- Lesson 922 — Understanding Eventual Consistency
- Better visibility
- The coordinator tracks progress, making debugging and monitoring straightforward
- Lesson 1375 — Trade-offs: Coupling and Visibility
- blackout periods
- Release windows are pre-approved time slots when deployments are permitted, while blackout periods are times when releases are prohibited or severely restricted.
- Lesson 1548 — Release Windows and Blackout Periods
- blast radius
- The blast radius is the scope of impact when something goes wrong.
- Lesson 719 — Deployment Risk and the Need for Rollback
- bottleneck
- In Kanban (and Agile in general), a bottleneck is any stage in your workflow where work piles up faster than it can be completed.
- Lesson 1597 — Identifying and Resolving Bottlenecks
- Boundaries
- Boundaries are the limits of valid ranges:
- Lesson 604 — Boundary Value and Edge Case Coverage
- boundary
- The boundary is where one module ends and another begins—the point where they communicate.
- Lesson 522 — What Are Module Boundaries
- bounded context
- A bounded context is an explicit boundary within which a domain model and its ubiquitous language are internally consistent.
- Lesson 1306 — Domain-Driven Design Bounded Contexts
- Boxes
- Boxes are stacked to show which function called which
- Lesson 1196 — CPU Profiling and Flame Graphs
- Branches
- Branches are just movable pointers to commits in the graph
- Lesson 65 — Understanding Git History as a DAG
- branching strategy
- A branching strategy is a shared agreement within your team that defines:
- Lesson 82 — What Are Branching Strategies and Why Do They Matter
- breaking change
- This is called a breaking change: any modification that makes existing client code stop working.
- Lesson 790 — Why API Versioning Matters
- Breaking changes
- Breaking changes are prominently highlighted
- Lesson 1555 — Automating Changelog Generation
- Breakpoints
- Breakpoints are markers you place on specific lines of code.
- Lesson 1728 — Debugger Fundamentals: Breakpoints and Execution Control
- Bridge
- Bridge is like designing a universal remote control from scratch—you intentionally separate the remote's interface (buttons, display) from the TV brands it controls, knowing you'll add support for new brands without redesigning the remote itself.
- Lesson 262 — Adapter vs Bridge: Understanding the Distinction
- Bugs in production
- Bugs in production are exponentially more expensive than bugs caught during development.
- Lesson 426 — The Cost of Not Testing
- Build agents
- Build agents are separate machines or containers that:
- Lesson 640 — Build Agents and Executors
- Build artifacts
- Build artifacts are the outputs of your build process (compiled binaries, test results, packaged applications), while caching saves dependencies and intermediate files so they don't need to be recreated from scratch every time.
- Lesson 641 — Build Artifacts and Caching
- build configuration file
- A build configuration file is a text file you store alongside your code that tells the CI server exactly what to do when someone pushes code.
- Lesson 638 — Build Configuration Files
- build script
- A build script is like following handwritten notes you made yourself—flexible and personal, but you write every step from scratch.
- Lesson 659 — Build Scripts vs Build Tools
- Build scripts
- Build scripts are simple executable files (shell scripts, batch files, Python scripts) you write to automate tasks like compiling code, running tests, or packaging applications.
- Lesson 659 — Build Scripts vs Build Tools
- Build time
- Build time is critical—if builds take 30 minutes, developers stop running them frequently.
- Lesson 650 — CI Metrics and Visibility
- build tool
- A build tool is like a recipe app with pre-programmed functions—it knows common patterns, handles timing automatically, and prevents common mistakes.
- Lesson 659 — Build Scripts vs Build Tools
- Built-in practices
- Code review, automated testing, and monitoring are non-negotiable defaults, not optional extras
- Lesson 1832 — Defining Quality Culture
- bulkheads
- In software, bulkheads are resource partitions that isolate different parts of your system.
- Lesson 1105 — Bulkheads and Isolation
- Business goals
- Business goals are strategic objectives like increasing revenue, reducing time-to-market, entering new markets, or improving customer retention.
- Lesson 1233 — Business Goals and Architecture Alignment
- Business stakeholders
- Business stakeholders are the people who have a vested interest in the project's success: executives, department heads, clients, or investors.
- Lesson 21 — The Product Owner and Business Stakeholders
- Bypassing the ORM
- Bypassing the ORM means writing raw SQL for specific operations.
- Lesson 948 — Write Performance and Batch Operations
C
- cache key
- The cache key is the unique identifier you use to retrieve cached data, like a library card number that retrieves exactly one borrower's record.
- Lesson 961 — Cache Keys and Lookup Mechanisms
- cache miss
- A cache miss means the data must be fetched from the slower underlying source.
- Lesson 959 — Cache Hit Ratios and Effectiveness
- Cache tags
- Cache tags are labels you attach to cache entries when storing them.
- Lesson 981 — Tagging and Bulk Invalidation
- Cache-Control
- Defines how long and under what conditions browsers should cache a resource (e.g., max-age=3600 means cache for one hour)
- Lesson 984 — Browser and Client-Side Caching
- canary release
- A canary release is a deployment technique where you send new code to a tiny fraction of your users first—maybe 5% or even 1%—while the rest continue using the stable version.
- Lesson 710 — Canary Releases
- Capacity
- Capacity is theoretical—how much work your team could do.
- Lesson 1656 — Velocity and Capacity Planning
- Capacity planning
- Capacity planning means calculating how much work your team can realistically handle.
- Lesson 1602 — Effective Sprint Planning Practices
- card
- Each card represents a single work item—a user story, bug fix, feature, or task.
- Lesson 1593 — The Kanban Board
- Cardinality
- Cardinality refers to the number of distinct values in a column.
- Lesson 875 — Index Selectivity and Cardinality
- Career goals
- An engineer aiming for architecture roles needs different guidance than one focused on deep technical specialization or moving toward management.
- Lesson 1798 — Tailoring Mentorship Styles
- cargo
- cargo is Rust's all-in-one solution, praised for its elegant design that handles dependencies, compilation, testing, and documentation out of the box.
- Lesson 660 — Common Build Tools Overview
- Catch regressions early
- A code change might reintroduce a parser bug that fuzzing previously found. Continuous fuzzing detects this immediately.
- Lesson 625 — Integrating Fuzzing into CI/CD
- Causal consistency
- Operations that are causally related are seen in order by all nodes
- Lesson 1410 — Consistency Models and the Spectrum
- Challenge acknowledgment
- Admitting when projects are struggling or behind schedule
- Lesson 1828 — Transparency and Open Communication
- Change ripple effect
- If modifying one class forces changes in 3+ other classes, coupling is too tight
- Lesson 183 — Measuring Coupling and Cohesion in Practice
- changelog
- A changelog is a structured, chronological record of every meaningful modification to your software.
- Lesson 1687 — Changelog and Release Notes
- CI culture
- A CI culture means the entire team shares ownership of build health, treats broken builds as urgent, and integrates frequently without being reminded.
- Lesson 651 — Building a CI Culture
- CI server
- A CI server is the central coordinator that receives build requests when webhooks trigger.
- Lesson 640 — Build Agents and Executors
- Circuit Breaker
- After repeated failures, stop trying for a period to avoid cascading problems, then gradually test if recovery is possible.
- Lesson 1090 — Error Recovery and Graceful Degradation
- Classes of Service
- Classes of Service (CoS) are categories that define how different types of work should be handled, especially based on urgency and business value.
- Lesson 1598 — Policies and Classes of Service
- Client Credentials Grant
- The Client Credentials Grant is for machine-to-machine communication where no user is involved.
- Lesson 1020 — Implicit and Client Credentials Grants
- Client-Server Separation
- Client-Server Separation is a REST architectural principle that mandates keeping the user interface (client) and data storage (server) as independent components.
- Lesson 756 — Client-Server Separation
- Client-Side Discovery
- The client queries a service registry (like Consul or Eureka) directly, receives a list of available service instances, and chooses one to call. The client is responsible for load balancing.
- Lesson 1324 — Client-Side vs Server-Side Discovery
- Cloning
- Cloning is how you download an entire repository—complete with all its history, branches, and files—from a remote location (like GitHub, GitLab, or a company server) to your local machine.
- Lesson 54 — Cloning Existing Repositories
- code formatter
- A code formatter is a tool that automatically restructures your code's appearance according to a predefined set of rules.
- Lesson 392 — Code Formatters and Prettier
- Code organization
- Code organization means structuring your source files and directories in a way that reflects what your program does and how its parts relate to each other.
- Lesson 373 — Code Organization and File Structure
- code smell
- A code smell is a surface-level symptom in your code that suggests something might be wrong underneath—like how a weird smell in your kitchen might indicate spoiled food hidden in the back of the fridge.
- Lesson 335 — What Are Code Smells?
- Coherence
- Coherence means ensuring all cache layers reflect a consistent view of your data.
- Lesson 988 — Multi-Layer Cache Coordination
- Collaboration Over Silos
- Collaboration Over Silos means actively breaking down these barriers.
- Lesson 1830 — Collaboration Over Silos
- Color Contrast
- Users with color blindness or low vision need sufficient contrast between text and backgrounds (WCAG requires 4.5:1 for normal text). Never rely solely on color to convey information—red/green status indicators are meaningless to colorblind users. Use icons, patterns, or text labels alongside color.
- Lesson 1929 — Designing for Diverse Abilities
- combinator
- A combinator is a function that takes one or more generators and combines them into a new, more complex generator.
- Lesson 615 — Generators and Combinators
- Command Interface
- Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
- Lesson 291 — Implementing the Command Pattern
- commit
- A commit is like taking a photograph of your project at a specific moment in time.
- Lesson 48 — Committing Changes with 'git commit'
- Commits
- These are the snapshots you create with git commit. A commit object points to a tree (your project's state), contains metadata (author, date, message), and points to its parent commit(s). This creates the chain you see with git log.
- Lesson 50 — Understanding Git Objects: Blobs, Trees, and Commits
- Community of Practice
- A Community of Practice (CoP) is a voluntary group of engineers from different teams who share a common technical interest or domain—like frontend development, security, databases, or infrastructure.
- Lesson 1846 — Building Technical Communities of Practice
- Complete audit trail
- Every state change is recorded with context—who did what, when, and why.
- Lesson 1347 — Event Sourcing Fundamentals
- Complex conflict resolution
- The system must decide which write "wins" or merge changes
- Lesson 1403 — Multi-Leader and Leaderless Replication
- Complex data graphs
- Complex data graphs are where GraphQL truly excels.
- Lesson 826 — When to Choose GraphQL
- Complex logic
- Areas where bugs are more likely (calculations, conditionals, integrations)
- Lesson 428 — Test ROI and Prioritization
- Complexity Tolerance
- Cache-aside is straightforward—your application controls everything explicitly. Write-through and read-through push logic into infrastructure but require careful setup. Write-behind adds queuing, retry logic, and potential data loss scenarios. Multi-level caching multiplies these considerations.
- Lesson 975 — Pattern Selection Trade-offs
- components
- A reusable library of definitions—schemas for request/response bodies, parameters, headers, and more. Instead of repeating the same "User" object structure everywhere, define it once here and reference it throughout.
- Lesson 838 — Anatomy of an OpenAPI Document
- Composition
- Composition means building objects by combining smaller, independent components—essentially "has-a" relationships.
- Lesson 173 — Favor Composition Over Inheritance
- Comprehensive coverage
- Test edge cases and states that are hard to trigger in full flows
- Lesson 565 — Component Testing vs Full Page Testing
- Compromise
- Compromise means splitting differences to end disagreement—often leaving everyone partially unhappy.
- Lesson 1811 — Understanding Consensus vs Compromise
- Concrete Commands
- Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
- Lesson 291 — Implementing the Command Pattern
- Concrete Products
- the actual classes being instantiated
- Lesson 234 — Factory Method Pattern: Intent and Structure
- Concurrent system chaos
- In distributed systems with multiple servers, some instances might still be running code that expects the new schema while the database is being rolled back.
- Lesson 889 — Forward-Only Migration Philosophy
- Condition
- A boolean expression (e.g., status == "error")
- Lesson 1730 — Conditional Breakpoints and Breakpoint Actions
- Confidentiality with Limits
- Respect proprietary information and trade secrets, but this duty has boundaries. If you discover your employer is violating laws, harming users, or creating dangerous systems, whistleblowing may be ethically required despite confidentiality agreements.
- Lesson 1896 — Client and Employer Obligations
- configuration drift
- One server gets a manual patch, another has slightly different configuration files—this is called configuration drift.
- Lesson 1472 — The Concept of Immutable Infrastructure
- Configuration Management
- Configuration Management means applying tenant-specific settings: feature flags, billing tiers, localization preferences, and custom branding.
- Lesson 1533 — Tenant Onboarding and Provisioning
- Connection pooling
- Connection pooling means maintaining a collection of already-established connections to backend servers that can be reused across multiple requests.
- Lesson 1395 — Connection Pooling and Keep-Alive
- Consensus
- Consensus means everyone genuinely understands and supports the decision, even if it wasn't their first choice.
- Lesson 1811 — Understanding Consensus vs Compromise
- Consistency
- The same container runs identically everywhere
- Lesson 1423 — What Are Containers and Why Use Them
- Consistency guarantee
- The next read always gets truth from the database
- Lesson 979 — Cache-Aside Invalidation Pattern
- Consistency Needs
- If you need strong consistency (financial transactions, inventory counts), write-through ensures cache and database stay in sync. If eventual consistency is acceptable (social media feeds, view counts), write-behind or cache-aside with TTL-based expiration offers better performance.
- Lesson 975 — Pattern Selection Trade-offs
- Consistent resource identification
- Resources are identified by URLs (/users/123)
- Lesson 759 — Uniform Interface Principle
- Constraints
- Constraints are the hard boundaries you must work within—things you cannot change.
- Lesson 132 — Constraints and Assumptions
- Consumers
- Consumers are components that listen for specific events and react accordingly.
- Lesson 1340 — Event Producers and Consumers
- container
- A container is a lightweight, standalone executable package that bundles application code together with all its dependencies—libraries, runtime, system tools, and configuration files—into a single isolated unit.
- Lesson 1423 — What Are Containers and Why Use Them
- container registry
- A container registry is a centralized repository for storing and distributing container images.
- Lesson 1430 — Container Registries
- container runtime
- While container images define what should run, the container runtime is the low-level software responsible for actually running containers.
- Lesson 1426 — The Container RuntimeLesson 1443 — Kubernetes Architecture Overview
- containerd
- A higher-level runtime that manages runc and handles image operations
- Lesson 1426 — The Container Runtime
- Content negotiation
- Content negotiation is elegant but harder to debug.
- Lesson 848 — API Versioning Strategies
- Context
- The situation requiring a decision
- Lesson 1698 — What Are Architecture Decision Records (ADRs)?
- Context changes
- A variable named user now holds multiple users
- Lesson 348 — Rename Method and Rename Variable
- Context propagation
- Context propagation means attaching identifying information (typically a correlation ID or request ID) to every log statement related to the same logical operation.
- Lesson 1132 — Context Propagation in LogsLesson 1147 — Traces, Spans, and Context Propagation
- Continuous Delivery
- Continuous Delivery means every code change that passes automated tests is packaged and ready for production deployment.
- Lesson 15 — DevOps and Continuous Delivery in the SDLCLesson 692 — Continuous Delivery vs Continuous Deployment
- Contributing factors
- Contributing factors are conditions, circumstances, or weaknesses that enabled the failure to occur or made it worse.
- Lesson 1746 — Contributing Factors vs. Root Causes
- Control
- Self-hosting gives you complete configuration freedom and direct access to underlying infrastructure. Managed services impose constraints—you can't tune kernel parameters or install custom extensions. This reduced control is sometimes the cost of simplicity.
- Lesson 1518 — Evaluating Managed Service Trade-offs
- Control flow
- Control flow is the path your program takes when it runs—which function calls which, where data moves at runtime.
- Lesson 224 — The Dependency Flow vs Control Flow
- Controller Manager
- Runs multiple controllers that continuously monitor the cluster's state. If you requested 3 replicas of a container but only 2 are running, a controller detects this and creates the third.
- Lesson 1443 — Kubernetes Architecture Overview
- core dump
- A core dump is a snapshot of your program's memory at the moment it crashed—like a freeze-frame of everything that was in RAM.
- Lesson 1734 — Post-Mortem Debugging with Core Dumps and Crash Reports
- Core needs
- The fundamental problems you're solving (e.g., "Users must authenticate before accessing data")
- Lesson 165 — Building Flexibility into Requirements
- cost of delay
- In software engineering, cost of delay is the financial impact of not shipping a feature or product on time.
- Lesson 34 — The Cost of Delay and Opportunity Cost
- Coverage-guided fuzzing
- Coverage-guided fuzzing is smarter: it monitors which parts of your code each input reaches, then evolves inputs that discover new code paths.
- Lesson 622 — Coverage-Guided Fuzzing
- covering composite index
- A covering index (also called a covering composite index) is an index that includes every column referenced in a query—not just the columns in the WHERE clause, but also those in the SELECT list and any ORDER BY or GROUP BY clauses.
- Lesson 874 — Covering Indexes
- CPU limits
- Restrict CPU shares or cores (e.g., 0.5 CPUs means half a core's worth of time).
- Lesson 1438 — Container Resource Limits and Health Checks
- Creation logic changes frequently
- The "how" of building objects evolves, and you want to isolate those changes
- Lesson 242 — Factory Pattern Trade-offs
- Critical bugs
- Critical bugs are causing production outages or data corruption
- Lesson 1568 — What are Hotfixes and When to Use Them
- critical path
- The critical path is the longest chain of dependent tasks—the minimum time your project will take even with infinite engineers.
- Lesson 1664 — Parallel vs Sequential WorkLesson 1669 — Critical Path and Slack Time
- Critical paths
- Critical paths are the core workflows users depend on.
- Lesson 402 — What to Test: Risk-Based Testing
- cross-cutting concerns
- These are called cross-cutting concerns because they literally cut across all your carefully drawn layer boundaries.
- Lesson 1260 — Cross-Cutting Concerns in Layers
- cryptographic hash function
- A cryptographic hash function is a mathematical algorithm that transforms any input (like a password) into a fixed-size string of characters called a "digest" or "hash." Think of it like a meat grinder: you can turn a steak into ground beef, but you can't reconstruct the original steak from the ground meat.
- Lesson 1000 — Cryptographic Hash Functions for Password Storage
- Customer collaboration
- Customer collaboration means treating your stakeholders as ongoing partners throughout development, not just at the contract-signing and delivery phases.
- Lesson 1578 — Customer Collaboration Over Contract Negotiation
- Customer empathy
- The team viscerally understands how quality affects real users
- Lesson 1832 — Defining Quality Culture
- customer stakeholders
- In software engineering, end users are the people who actually interact with your software to get their work done, while customer stakeholders are often the decision-makers who purchase or approve the software.
- Lesson 22 — End Users and Customer Stakeholders
- Cycle time
- Cycle time is the duration from when a team starts working on an item until it's marked "Done."
- Lesson 1595 — Managing Flow and Cycle Time
D
- dark launching
- Shadow deployment (also called dark launching or shadow testing) means running a new version of your software alongside the current production version, feeding it real user traffic, but discarding its responses.
- Lesson 713 — Shadow Deployment
- Dashboard Links
- Include direct links to pre-filtered dashboards showing the relevant metrics. If CPU is spiking, link to the CPU dashboard for that specific service and time window.
- Lesson 1160 — Alert Context: Including Diagnostic Information
- Data Coupling
- Data Coupling means Service A directly queries Service B (or its database) for that data.
- Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
- Data Duplication
- Data Duplication means Service A stores its own copy of data that originates in Service B.
- Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
- Data hiding
- Data hiding means restricting direct access to that data from outside code.
- Lesson 171 — Encapsulation and Data Hiding
- data isolation
- In a multi-tenant system, data isolation is your insurance policy against catastrophic breaches.
- Lesson 1531 — Data Isolation Strategies
- Data Ownership
- Each microservice typically manages its own database or data store. No shared database means no hidden coupling through data access.
- Lesson 1294 — Defining Microservices
- Data Transfer Object
- A Data Transfer Object is a simple, flat data structure with no business logic — just fields and basic getters/setters.
- Lesson 1278 — Crossing Boundaries with DTOs
- Database Layer
- The last resort. Some databases support row-level security or view-based restrictions. This protects against bugs or compromised application code, but shouldn't be your primary authorization mechanism—it's slow and hard to express complex rules in SQL.
- Lesson 1030 — Implementing Authorization in Applications
- Database Per Service Pattern
- In microservices architecture, the Database Per Service Pattern means each service manages its own dedicated database that no other service can access directly.
- Lesson 1307 — Database Per Service Pattern
- Debugging Confidence
- If you can't reproduce a build, you can't truly know what's running in production. Reproducibility means your local debugging environment matches reality.
- Lesson 691 — Benefits and Trade-offs
- Declarative configuration
- Declarative configuration is like giving a destination: "Take me to 123 Main Street." The system figures out how to get there from wherever you currently are.
- Lesson 1489 — Declarative vs Imperative Configuration
- Declarative provisioning
- Declarative provisioning is like ordering from a menu: "I want lasagna." You describe the desired end state, and the system figures out how to get there.
- Lesson 1480 — Declarative vs Imperative Provisioning
- Decompose Conditional
- Decompose Conditional means extracting both the conditional expression and its resulting actions into separate, well-named methods.
- Lesson 355 — Decompose Conditional
- Decorator
- Decorator is more flexible—infinite combinations without new classes.
- Lesson 271 — Decorator vs. Inheritance: Flexibility and Complexity
- Decoupling
- Producers don't need to know which consumer will handle their message, or even if consumers are currently online. The queue handles delivery guarantees.
- Lesson 1359 — Message Queues and Point-to-Point Messaging
- Dedicated Learning Time
- Many teams allocate 10-20% of sprint capacity for learning—reading, experimentation, or skill development. Google's "20% time" is the famous example, but even small teams can protect Friday afternoons for exploration.
- Lesson 1840 — Creating a Culture of Continuous Learning
- Default Values
- Return sensible defaults instead of crashing—show a generic profile picture if the image service is down.
- Lesson 1090 — Error Recovery and Graceful Degradation
- Defense in depth
- Defense in depth means never relying on a single security control.
- Lesson 1069 — Defense in Depth for Cross-Site Attacks
- Defensive Programming
- Defensive Programming means anticipating problems and handling them gracefully.
- Lesson 176 — Fail Fast and Defensive Programming
- Definition of Done
- The Definition of Done (DoD) is a checklist or set of criteria that every work item—whether a user story, task, or feature—must satisfy before it's considered complete.
- Lesson 1591 — Definition of Done
- DELETE
- Idempotent but not safe. Deleting a resource once removes it; deleting it again still leaves it deleted (404s are acceptable).
- Lesson 765 — Safe and Idempotent Methods
- Deliverables
- Deliverables are the tangible outputs you produce: working features, documentation, deployed systems, or test reports.
- Lesson 1659 — Identifying Milestones and Deliverables
- Demonstrated Expertise
- Show depth in areas that matter to your team. This doesn't mean knowing everything; it means having deep knowledge where it counts and knowing your limits elsewhere. Answer questions thoroughly, explain trade-offs clearly, and share insights that others miss.
- Lesson 1795 — Building Technical Credibility
- Denial of Service
- Inputs that cause crashes, infinite loops, or excessive resource consumption are security issues. Fuzzing finds them by generating pathological cases.
- Lesson 624 — Detecting Security Vulnerabilities
- Dependency direction
- Dependency direction refers to which components depend on which others.
- Lesson 189 — Dependency Direction and Stability
- Dependency flow
- Dependency flow is about which modules or files know about (depend on) other modules at compile-time.
- Lesson 224 — The Dependency Flow vs Control Flow
- Dependency registers
- Dependency registers are living documents (spreadsheets, project management tools, or wikis) that list each dependency, its owner, expected completion date, and current health status.
- Lesson 1672 — Tracking and Communicating Dependency Status
- Dependency unavailability
- Dependency unavailability means an external service you rely on is either:
- Lesson 1108 — Handling Dependency Unavailability
- Deployable
- The code can be packaged, deployed, and run in production-like environments. Build processes complete successfully, and deployment scripts work without manual intervention.
- Lesson 694 — Production-Ready Definition
- deployment pipeline
- A deployment pipeline is an automated process that takes every code change from commit to production-ready state through a series of increasingly rigorous environments and tests.
- Lesson 693 — The Deployment Pipeline Concept
- Deprecated
- The decision is no longer recommended but may still be in use
- Lesson 1703 — ADR Status and Lifecycle
- Deprecation
- Deprecation is the formal process of announcing that a feature, function, or version is scheduled for removal or no longer recommended.
- Lesson 676 — Deprecation and Version Lifecycle
- Deprecation warnings
- Mark features as deprecated in documentation, release notes, and ideally in code (like log warnings). Explain what is deprecated, why, and when it will be removed.
- Lesson 676 — Deprecation and Version Lifecycle
- Detection
- An alert fires or someone notices something wrong. This is where your monitoring and alerting setup (covered in previous lessons) kicks in. The faster detection happens, the smaller the impact.
- Lesson 1165 — Incident Response Workflow
- development
- Profiling in development is like practicing with training wheels—you can use heavyweight tools, run them continuously, and experiment freely because user impact doesn't matter.
- Lesson 1199 — Profiling in Production vs Development
- Difficult to test
- Testing one giant method means testing everything it does at once. You can't easily test individual pieces of logic in isolation.
- Lesson 336 — Bloaters: Long Method
- Digital stewardship
- Digital stewardship means recognizing that your code doesn't just serve this sprint's goals—it shapes infrastructure, behaviors, and ecosystems that may outlive your tenure at the company.
- Lesson 1933 — Long-term Thinking and Digital Stewardship
- Diminishing returns
- For simple CRUD APIs or internal services, Level 2 is often sufficient
- Lesson 797 — HATEOAS Trade-offs and Maturity Models
- Direct Instantiation
- Direct Instantiation means calling a constructor yourself:
- Lesson 235 — Factory Method vs Direct Instantiation
- Directed
- The connections have arrows—they point from one node to another
- Lesson 65 — Understanding Git History as a DAG
- dirty reads
- This means you might see changes that could be rolled back—these are called dirty reads.
- Lesson 905 — Read Uncommitted Isolation
- Discipline
- Discipline means actually doing these things every time, even when you're tired, rushed, or convinced "this small change doesn't need tests."
- Lesson 6 — Process and Discipline
- Discovery work
- The time spent understanding a problem is itself hard to estimate
- Lesson 1648 — Why Estimation is Hard
- Disparate treatment
- Disparate treatment means explicitly using protected attributes in decisions—easier to spot but often hidden in proxy variables (ZIP code correlating with race, for example).
- Lesson 1915 — Evaluating Models for Bias
- Distributed failures
- Failures are harder to detect because no central observer exists
- Lesson 1375 — Trade-offs: Coupling and Visibility
- Diverse client needs
- Diverse client needs are GraphQL's primary strength.
- Lesson 826 — When to Choose GraphQL
- Documentation as Code
- Documentation as Code means storing your documentation files (often Markdown, AsciiDoc, or similar formats) directly in your project's version control repository alongside your source code.
- Lesson 1706 — Documentation as Code
- Documentation generators
- Documentation generators are tools that automatically extract specially-formatted comments from your code and transform them into beautiful HTML pages, PDFs, or interactive websites.
- Lesson 379 — Documentation Tools and Standards
- Domain alignment
- The boundary follows natural divisions in your business domain, not technical convenience
- Lesson 1290 — Defining Module Boundaries
- domain event
- A domain event is a record of something meaningful that happened in your system — like "Order Placed," "Payment Completed," or "Inventory Reserved." When one bounded context needs to know about changes in another, domain events provide a clean way to communicate without direct dependencies.
- Lesson 1285 — Domain Events for Context Integration
- Domain terminology
- The exact words professionals use, so your requirements match their mental models
- Lesson 140 — Domain Research and Competitive Analysis
- Dual licensing
- Dual licensing means offering the same code under two (or more) different licenses simultaneously.
- Lesson 1876 — Dual Licensing and License Exceptions
- Dummies
- Dummies are perfect when you need to satisfy a function signature but the parameter isn't actually used in your test scenario.
- Lesson 472 — When to Use Each Type of Test Double
- dummy object
- A dummy object is the simplest form of test double—it's passed as an argument to satisfy a method's parameter list, but it's never actually used within the test.
- Lesson 465 — Dummy Objects: The Simplest Test Double
- Duplicated Data
- Duplicated Data means copying information from one table into another to avoid joins.
- Lesson 866 — Denormalization Patterns
E
- E2E tests
- E2E tests are like driving the car from your house to the grocery store and back—testing everything together in real-world conditions
- Lesson 407 — The Testing Pyramid ConceptLesson 554 — What is End-to-End Testing
- Early wins
- Begin with configuration management (Factor III) and dependency management (Factor II)—these are low-hanging fruit that prevent common production issues
- Lesson 754 — Applying Twelve-Factor Principles in Practice
- Easier debugging
- Small scope means fewer variables to investigate
- Lesson 526 — Narrow Integration Tests
- Easy setup
- Fewer dependencies means simpler test data requirements
- Lesson 565 — Component Testing vs Full Page Testing
- Edge cases
- Edge cases are unusual but valid scenarios:
- Lesson 604 — Boundary Value and Edge Case Coverage
- Edge locations
- Edge locations are data centers positioned strategically around the world.
- Lesson 985 — CDN and Edge Caching
- Efficient Code
- Efficient Code means choosing algorithms and data structures wisely.
- Lesson 1932 — Sustainable Software Engineering Practices
- Email notifications
- Email notifications are the traditional approach—send build results to individuals or team lists.
- Lesson 643 — Build Notifications and Reporting
- Emergent design
- Emergent design means starting with minimal structure and letting better patterns reveal themselves through the red-green-refactor cycle.
- Lesson 512 — Emergent Design vs. Upfront Design
- Encapsulation
- Encapsulation means bundling related data and the methods that work with that data into a single unit (like a class or module).
- Lesson 171 — Encapsulation and Data Hiding
- End Users
- In software engineering, end users are the people who actually interact with your software to get their work done, while customer stakeholders are often the decision-makers who purchase or approve the software.
- Lesson 19 — Who Are Stakeholders?Lesson 22 — End Users and Customer Stakeholders
- End-to-end tests
- End-to-end tests are expensive—they can take minutes to run, require full system setup, and break whenever UI or workflows change.
- Lesson 409 — The Cost-Confidence Trade-off
- Enforce consistency
- The tool continuously checks and corrects drift
- Lesson 1488 — Introduction to Configuration Management
- Entities
- Entities are the innermost layer of Clean Architecture—they contain the core business logic that would exist even if you never built any software.
- Lesson 1274 — Entities: Enterprise Business Rules
- Environment variables
- Environment variables are the primary way to inject this configuration at runtime without rebuilding images.
- Lesson 642 — Environment Variables and SecretsLesson 734 — Configuration Files vs Environment VariablesLesson 1436 — Environment Variables and Configuration
- Equal trade-offs
- Multiple options are genuinely equivalent, but paralysis persists
- Lesson 1816 — Making Decisions When Consensus Fails
- error budget
- An error budget is the amount of unreliability your service can tolerate before violating its SLO (Service Level Objective).
- Lesson 1175 — The Error Budget Concept
- Error handling gaps
- Untested catch blocks, error callbacks, or validation paths are red flags. These are precisely the code paths that execute when things go wrong—critical to test.
- Lesson 594 — Reading Coverage Reports
- Error recovery
- Error recovery means detecting a problem and automatically correcting it, allowing the system to return to normal operation.
- Lesson 1090 — Error Recovery and Graceful Degradation
- Errors
- Errors are predictable problems that are part of normal operation.
- Lesson 1084 — Errors vs Exceptions vs Failures
- ETag
- A version identifier that lets browsers check if their cached copy is still current without downloading the whole file again
- Lesson 984 — Browser and Client-Side Caching
- event bus
- An event bus is a publish-subscribe pattern where events are broadcast to all interested subscribers without the publisher knowing who's listening.
- Lesson 1357 — Message Brokers vs Event Buses: Core Concepts
- Event Channel
- The infrastructure (message queue, event stream) that routes events from producers to consumers
- Lesson 1338 — What is Event-Driven Architecture
- Event-driven workloads
- Event-driven workloads are serverless's sweet spot.
- Lesson 1527 — When Serverless is and Isn't Appropriate
- Exactly-Once
- The event is delivered precisely one time. The holy grail, but incredibly difficult (sometimes impossible) to guarantee end-to-end in distributed systems.
- Lesson 1344 — At-Least-Once vs Exactly-Once Delivery
- Examine the critical path
- Trace the sequence of spans from start to finish. Spans that block other work are more important than parallel operations.
- Lesson 1151 — Analyzing Traces for Performance Issues
- Exceptions
- Exceptions are unexpected but recoverable conditions that disrupt the normal flow of execution.
- Lesson 1084 — Errors vs Exceptions vs Failures
- Excessive data transfer
- Retrieving entire datasets when only a subset is needed
- Lesson 1198 — I/O and Network Profiling
- Experience level
- A junior developer might need more structured guidance and explicit examples, while a senior engineer benefits from thought-provoking questions that help them discover solutions independently.
- Lesson 1798 — Tailoring Mentorship Styles
- Expires
- An older header specifying an absolute expiration date
- Lesson 984 — Browser and Client-Side Caching
- Exposure through process listings
- On many systems, environment variables are visible to other processes. Commands like ps -e on Linux can reveal them to anyone with system access.
- Lesson 742 — Secrets in Environment Variables
- External Services
- This is where boundaries get fuzzy. For critical third-party services (payment processors, authentication providers), consider using their sandbox/test environments. For less critical services, mocks or stubs might be appropriate to avoid flakiness and cost.
- Lesson 556 — E2E Test Scope and Boundaries
- Externalizing state
- Externalizing state means moving session and transient data out of your application servers into shared, dedicated systems that all servers can access:
- Lesson 1394 — Externalizing State
- Extract Class
- Extract Class means taking a subset of fields and methods from an oversized class and moving them into a new, separate class.
- Lesson 350 — Extract Class and Inline Class
- Extrinsic state
- Extrinsic state is the data that's unique to each usage context.
- Lesson 275 — Intrinsic vs Extrinsic State in Flyweight
F
- Face-to-face conversation
- Face-to-face conversation is the most efficient communication method
- Lesson 1580 — The Twelve Principles Behind the Agile Manifesto
- Factory Method
- Factory Method means asking a method to create the object for you:
- Lesson 235 — Factory Method vs Direct Instantiation
- Fail Fast
- Fail Fast means detecting problems as early as possible and stopping immediately.
- Lesson 176 — Fail Fast and Defensive Programming
- fail-secure
- Fail-safe and fail-secure are two philosophies for making that choice, and picking the right one depends on what you're protecting.
- Lesson 1107 — Fail-Safe and Fail-Secure Defaults
- Failures
- Failures are catastrophic, unrecoverable problems that compromise system integrity.
- Lesson 1084 — Errors vs Exceptions vs Failures
- fake
- A fake is a test double that actually works—it's a real, functioning implementation, just simpler than the production version.
- Lesson 467 — Fakes: Working Implementations for Testing
- Fallback to Alternative
- If one payment gateway fails, try another. If the primary database is down, read from a replica.
- Lesson 1090 — Error Recovery and Graceful Degradation
- False confidence
- Teams believe their code is well-tested when it isn't
- Lesson 599 — The Danger of Coverage Theater
- Faster execution
- Fewer real components means less setup overhead
- Lesson 526 — Narrow Integration Tests
- Feature branching
- Feature branching means developers create separate branches for each feature, merging back to main only when complete—sometimes after days or weeks.
- Lesson 646 — Working on the Trunk vs Feature Branches
- Feature Flags
- Since incomplete features get merged into trunk, teams use feature flags (toggles) to hide work-in-progress from users. The code is there, but turned "off" until ready.
- Lesson 83 — Trunk-Based Development
- feedback loop
- In the SDLC, a feedback loop is when you use information discovered in a later phase to inform and improve decisions made in earlier phases.
- Lesson 17 — Feedback Loops Across the SDLC
- Final shutdown
- After the deadline, return 410 Gone status codes indicating the resource is permanently unavailable, with links to migration documentation.
- Lesson 853 — API Sunset and End-of-Life
- Fitness functions
- These are automated checks that protect important architectural characteristics during evolution. If you value performance, you'd have tests that fail if response times degrade. If you value modularity, you'd have tools that prevent unwanted dependencies between components.
- Lesson 1227 — Evolutionary Architecture
- Flag debt
- Flag debt is the accumulation of obsolete or stale feature flags in your codebase—similar to technical debt.
- Lesson 1566 — Flag Debt and Cleanup Strategies
- flaky test
- A flaky test is one that sometimes passes and sometimes fails—without any code changes.
- Lesson 656 — Flaky Test Management
- flame graph
- A flame graph is a visualization that shows the entire call stack hierarchy and how much CPU time each function consumed.
- Lesson 1196 — CPU Profiling and Flame Graphs
- flow
- In Kanban, flow refers to the smooth, continuous movement of work items through your process.
- Lesson 1595 — Managing Flow and Cycle Time
- Flux
- Flux is a lightweight, Kubernetes-native operator that monitors Git repositories and Helm releases.
- Lesson 1498 — GitOps Tools and Operators
- Forward compatibility
- Forward compatibility means old versions can handle artifacts from newer versions gracefully.
- Lesson 1553 — Version Compatibility and Breaking Changes
- Forward recovery
- Forward recovery means persisting through the failure by retrying the failed step, possibly with exponential backoff or adjusted parameters.
- Lesson 1369 — Forward Recovery vs Backward Recovery
- Frameworks and Drivers Layer
- The Frameworks and Drivers Layer is the most external circle in Clean Architecture.
- Lesson 1277 — Frameworks and Drivers Layer
- Frequent Integration
- Developers integrate their code into the trunk multiple times per day. This means everyone always sees the latest changes from the team.
- Lesson 83 — Trunk-Based Development
- Frontend
- Always include your actual UI—the buttons, forms, and pages users interact with. This is non-negotiable for true E2E testing.
- Lesson 556 — E2E Test Scope and Boundaries
G
- gauge
- A gauge represents a value that can go up or down arbitrarily.
- Lesson 1139 — Counter, Gauge, and Histogram Metrics
- generator
- A generator is a function that produces random test values (like integers, strings, or booleans).
- Lesson 615 — Generators and Combinators
- Geographic distribution
- Cross-datacenter or cross-region links are particularly vulnerable
- Lesson 1407 — Network Partitions in Practice
- Git
- Git is a distributed version control system created by Linus Torvalds in 2005.
- Lesson 43 — What is Version Control and Why Git?
- God Object
- A Large Class (sometimes called a God Object) is a class that has grown so big it's doing far too many things.
- Lesson 337 — Bloaters: Large Class and God Object
- good design
- Think of it like furniture assembly instructions: good design means the pieces fit together obviously (self-documenting), but you still need warnings like "Don't overtighten bolt C—it will crack the frame" (comments for non-obvious details).
- Lesson 375 — Self-Documenting Code vs Comments
- Graceful degradation
- Graceful degradation means acknowledging that full functionality isn't available, but providing a reduced, still-useful experience instead of complete failure.
- Lesson 1090 — Error Recovery and Graceful Degradation
- Graph
- A collection of nodes (points) connected by edges (lines)
- Lesson 65 — Understanding Git History as a DAG
- Green Hosting
- Green Hosting means selecting cloud providers powered by renewable energy.
- Lesson 1932 — Sustainable Software Engineering Practices
- Growing systems
- traffic doubles yearly; yesterday's "high" is today's normal
- Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
- guard clause
- A guard clause is a conditional check at the beginning of a method that handles a special case and returns immediately.
- Lesson 354 — Replace Nested Conditionals with Guard Clauses
H
- Handler Interface
- Defines how requests are received and optionally passed to the next handler.
- Lesson 287 — Chain of Responsibility Pattern: Core Concept
- health check
- A health check is an endpoint (typically /health or /actuator/health) that your service exposes.
- Lesson 1326 — Health Checks and Registration
- Health Checks
- These are simple endpoints or tests that verify your application is responding correctly. If health checks start failing after deployment, that's a clear signal something's broken.
- Lesson 722 — Monitoring and Automated Rollback Triggers
- Health-Aware Routing
- Don't just know where services are—know which instances are healthy. Route traffic only to instances passing health checks.
- Lesson 1116 — Fallacy 5: Topology Doesn't Change
- heap dump
- A heap dump is a snapshot of all live objects in memory at a specific moment.
- Lesson 1197 — Memory Profiling and Heap Analysis
- High change frequency
- The code changes often (new features, bug fixes). Refactoring reduces future maintenance costs significantly.
- Lesson 1765 — The Economics of Legacy Refactoring
- High cohesion
- High cohesion means the methods and data in a class work together toward a single, well-defined purpose.
- Lesson 182 — The Relationship Between Coupling and CohesionLesson 197 — Cohesion and SRP
- High throughput approach
- The kitchen batches orders, cooking multiple steaks simultaneously. More customers fed per hour, but each individual waits longer.
- Lesson 1204 — Latency vs Throughput
- High WIP in one column
- If "In Review" consistently hits its WIP limit while "Development" is empty, reviews are your bottleneck.
- Lesson 1597 — Identifying and Resolving Bottlenecks
- Higher availability
- Systems remain responsive even when some nodes are unreachable
- Lesson 922 — Understanding Eventual Consistency
- Hook methods
- Hook methods are those optional steps—they provide default (often empty) behavior that subclasses can choose to customize.
- Lesson 316 — Hook Methods in Template Method
- hotfix
- A hotfix is an emergency code change deployed directly to production, bypassing your standard release process.
- Lesson 1568 — What are Hotfixes and When to Use Them
- how it handles failures
- But in performance engineering, how often your system fails and how it handles failures are critical performance dimensions.
- Lesson 1209 — Error Rate and Success Metrics
- HTTP Strict Transport Security
- HTTP Strict Transport Security is a security header your server sends that instructs browsers: "For the next X seconds, only communicate with me over HTTPS, even if the user types http:// or clicks an HTTP link."
- Lesson 1071 — HTTP Strict Transport Security (HSTS)
- Hypothesis
- Hypothesis (Python) is the most feature-rich modern implementation.
- Lesson 613 — Property Testing Tools and Frameworks
I
- Idempotence
- Idempotence means applying an operation multiple times has the same effect as applying it once.
- Lesson 609 — Common Property Patterns
- Idempotency
- Idempotency means running the same playbook multiple times produces the same result without unintended side effects.
- Lesson 1490 — Ansible Fundamentals
- Identifying actionable improvements
- Identifying actionable improvements means translating your root cause analysis into specific, measurable tasks that close the gaps revealed by the incident.
- Lesson 1184 — Identifying Actionable Improvements
- Immutability
- Immutability is important (build once, never change)
- Lesson 246 — Builder vs Constructor: When to Use Each
- immutable artifact
- An immutable artifact is a packaged version of your application that contains everything needed to run: the application code, runtime dependencies, libraries, configuration files, and even the operating system components.
- Lesson 1475 — Building Immutable Artifacts
- Imperative configuration
- Imperative configuration is like giving turn-by-turn directions: "Go straight, turn left at the light, then right after the bridge." You specify the exact sequence of steps to execute.
- Lesson 1489 — Declarative vs Imperative Configuration
- Imperative provisioning
- Imperative provisioning is like giving step-by-step cooking instructions: "First, preheat the oven to 350°F.
- Lesson 1480 — Declarative vs Imperative Provisioning
- Implementation
- Implementation is the actual carpentry, wiring, and painting.
- Lesson 1219 — Defining Software Architecture
- Improve query performance
- The database can scan a smaller, more focused index with higher selectivity
- Lesson 876 — Partial and Filtered Indexes
- Improves Readability
- A method named calculateTotalWithTax() tells you immediately what it does. Five lines of arithmetic scattered in your code forces readers to decode your intent.
- Lesson 346 — Extract Method
- Incomplete transactions
- A user update fails halfway through, leaving elevated privileges in place
- Lesson 1034 — Fail Securely
- Increased Abstraction
- Patterns add layers between your intent and implementation. Instead of directly creating an object, you might use a Factory. Instead of calling a method, you might dispatch a Command. Each layer is one more thing to understand.
- Lesson 323 — The Cost of Pattern Overhead
- Increasing cycle time
- If tasks suddenly take longer to complete, measure time spent in each stage. The stage with growing wait times is likely your constraint.
- Lesson 1597 — Identifying and Resolving Bottlenecks
- Independence
- Service A runs even if Service B is down
- Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
- Independent Deployment
- You can update, deploy, and scale one service without touching others. This is the fundamental difference from modular monoliths where modules deploy together.
- Lesson 1294 — Defining Microservices
- index
- An index is a separate data structure that maintains an organized copy of specific columns from your table, along with pointers to where the full rows live.
- Lesson 869 — What Indexes Are and How They Work
- Information hiding
- Information hiding means keeping implementation details private, so other parts of your system don't depend on them.
- Lesson 167 — Abstraction and Information Hiding
- Infrastructure as Code
- Infrastructure as Code is the practice of managing and provisioning computing infrastructure through machine-readable configuration files rather than manual processes or interactive configuration tools.
- Lesson 1464 — What is Infrastructure as Code
- Ingress
- An Ingress is a Kubernetes resource that defines rules for routing external HTTP/S traffic to internal Services.
- Lesson 1463 — Ingress Controllers and HTTP Routing
- Ingress Controller
- An Ingress Controller is the actual component that implements these rules.
- Lesson 1463 — Ingress Controllers and HTTP Routing
- Inheritance
- Inheritance means creating a parent-child relationship where the child "is-a" type of parent and inherits all its behaviors.
- Lesson 173 — Favor Composition Over InheritanceLesson 271 — Decorator vs. Inheritance: Flexibility and Complexity
- Injection Flaws
- SQL injection, command injection, and script injection happen when untrusted input is incorporated into queries or commands. Fuzzing with special characters ('; DROP TABLE--, $(rm -rf /)) exposes insufficient sanitization.
- Lesson 624 — Detecting Security Vulnerabilities
- Inline Class
- Inline Class is the reverse: when a class is doing so little that it doesn't justify existing separately, you fold its responsibilities back into another class.
- Lesson 350 — Extract Class and Inline Class
- input domain
- The input domain is the complete set of all valid inputs your function should handle.
- Lesson 610 — Generators and Input Domains
- Insider threats
- A malicious employee can abuse their complete access
- Lesson 1037 — Separation of Duties
- Integrated
- The code successfully integrates with the rest of the system. It's been merged into the mainline branch, and all integration points work correctly with other components.
- Lesson 694 — Production-Ready Definition
- Integration tests
- Integration tests are like checking that your car's engine connects properly to the transmission
- Lesson 407 — The Testing Pyramid ConceptLesson 554 — What is End-to-End Testing
- Intent locks
- Intent locks are lightweight locks placed at higher levels of a hierarchy (like tables or pages) to signal that finer-grained locks (like row locks) exist or are needed below.
- Lesson 920 — Intent Locks and Lock Hierarchies
- interactors
- In Clean Architecture, use cases (also called interactors) represent your application's specific business rules—the workflows and scenarios your system performs.
- Lesson 1275 — Use Cases: Application Business Rules
- Interface Definition Language
- An Interface Definition Language (IDL) is a specification format that describes the interface of a service—what methods it offers, what parameters they accept, and what they return—in a language-agnostic way.
- Lesson 800 — Interface Definition Languages (IDLs)
- Internal fragmentation
- Pages are only partially filled, wasting space
- Lesson 877 — Index Maintenance and Statistics
- Intervention
- Intervention means addressing exclusionary behavior in the moment.
- Lesson 1854 — Allyship and Advocacy in Engineering
- Interviews
- Interviews are your most powerful tool for depth.
- Lesson 1674 — Understanding Stakeholder Needs and Concerns
- Intrinsic state
- Intrinsic state is the data that can be shared across many objects.
- Lesson 275 — Intrinsic vs Extrinsic State in Flyweight
- Introduce Parameter Object
- Introduce Parameter Object means creating a new class or struct to hold related parameters, then passing that single object instead.
- Lesson 353 — Introduce Parameter Object
- invalidation pattern
- The invalidation pattern means that whenever you modify data in the primary data store (database), you explicitly delete the corresponding cache entry rather than updating it.
- Lesson 979 — Cache-Aside Invalidation Pattern
- Invariants
- Invariants are conditions that must always hold true for the object's state.
- Lesson 209 — Behavioral Subtyping and ContractsLesson 609 — Common Property Patterns
- Invoker
- Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
- Lesson 291 — Implementing the Command Pattern
- Isolating the problem domain
- Isolating the problem domain means systematically determining which layer or component is responsible for the failure.
- Lesson 1723 — Isolating the Problem Domain
- Isolation
- Processes are isolated from each other, preventing conflicts
- Lesson 899 — The Isolation PropertyLesson 901 — ACID Trade-offs and PerformanceLesson 1423 — What Are Containers and Why Use Them
- It's easier to test
- Fewer unrelated concerns means simpler, focused tests
- Lesson 180 — Understanding Cohesion: What Belongs Together
- It's more reusable
- A focused module can be used elsewhere without dragging along unrelated baggage
- Lesson 180 — Understanding Cohesion: What Belongs Together
- Its own network namespace
- a private networking environment with its own network interfaces, routing tables, and IP addresses
- Lesson 1428 — Container Networking Basics
K
- Kanban board
- A Kanban board is a visual tool that makes work visible and tracks progress through defined stages.
- Lesson 1593 — The Kanban Board
- key-value pairs
- While structured logging gives you machine-readable format (like JSON), key-value pairs are what you actually put inside that structure.
- Lesson 1130 — Key-Value Pairs and Log Fields
- kill switch
- A kill switch is a flag designed to instantly disable a problematic feature without deploying new code.
- Lesson 1567 — Advanced Patterns: Kill Switches and Experiments
- Knowledge Barriers
- New team members struggle to understand the system because everything is interconnected. There's no clear boundary where one responsibility ends and another begins.
- Lesson 179 — The Cost of Tight Coupling
- Known short-term needs
- A feature needed for one event, then retired
- Lesson 42 — Balancing Debt and Delivery
- Kubelet
- An agent that ensures containers are running as specified. It receives Pod specifications from the API server and manages the containers on its node using the container runtime.
- Lesson 1443 — Kubernetes Architecture Overview
- Kubernetes Service Discovery
- Kubernetes Service Discovery is more sophisticated.
- Lesson 1329 — DNS-Based and Kubernetes Service Discovery
L
- Labels
- Labels are key-value pairs you attach to Kubernetes resources like Pods.
- Lesson 1445 — Labels, Selectors, and Annotations
- Lack of Test Coverage
- The defining trait. Without tests, you can't verify changes didn't break something unexpected.
- Lesson 1749 — Defining Legacy Code
- latency
- Think of a coffee shop: latency is how long one customer waits for their drink.
- Lesson 1188 — Latency vs Throughput Trade-offs
- Layered System Architecture
- In REST, Layered System Architecture means you can add intermediate servers between the client and the origin server without either side knowing or caring.
- Lesson 763 — Layered System Architecture
- Lazy Loading
- Cache-Aside (also called Lazy Loading) is a caching strategy where your application code manages the cache explicitly.
- Lesson 966 — Cache-Aside (Lazy Loading)
- Learning Through Building
- Here's the paradox: you can't fully understand the problem until you start solving it. Stakeholders see a working prototype and realize, "Actually, that's not quite what we meant." Users interact with the first version and discover workflows nobody anticipated. Building software is a discovery process, and discoveries mean course corrections.
- Lesson 160 — Why Requirements Change
- Learning-Focused Feedback
- Frame comments as learning opportunities. Instead of "This is wrong," try "Consider extracting this logic into a separate function for testability—here's why..." This shifts the tone from criticism to shared problem-solving.
- Lesson 1617 — Creating a Constructive Review Environment
- Length over complexity
- A 16-character passphrase like correct-horse-battery-staple is exponentially stronger than P@ssw0rd! and easier to remember.
- Lesson 1004 — Password Strength Requirements and Policies
- Less code
- You don't write custom shrinking functions—the generation strategy is the shrinking strategy
- Lesson 619 — Integrated Shrinking
- Level A
- The minimum level of accessibility. Addresses fundamental barriers that would completely block some users from accessing content (e.g., providing text alternatives for images, ensuring keyboard navigation).
- Lesson 1928 — WCAG Guidelines and Compliance Standards
- Level AA
- The recommended target for most organizations. Covers a broader range of accessibility barriers and is often the legal standard (e.g., minimum color contrast ratios, resizable text, consistent navigation).
- Lesson 1928 — WCAG Guidelines and Compliance Standards
- Level AAA
- The highest level, though not always achievable for all content. Includes the most stringent requirements (e.g., sign language interpretation for videos, enhanced contrast ratios).
- Lesson 1928 — WCAG Guidelines and Compliance Standards
- Lightweight tags
- Lightweight tags are simple pointers to a commit—just a name.
- Lesson 1556 — Version Tagging in Git
- limit
- Your request is the minimum room size you need (the scheduler won't place you somewhere smaller), and your limit is the maximum space you can occupy without disturbing other guests.
- Lesson 1451 — Resource Requests and Limits
- Limit charts per dashboard
- 5–10 is often enough. Too many splits attention.
- Lesson 1144 — Dashboard Design Principles
- Live validation
- The interface checks inputs against your schemas before sending requests
- Lesson 844 — Interactive API Documentation
- Living documentation
- The schema is the documentation—always accurate, never stale
- Lesson 841 — Benefits of Schema-First Development
- Load balancing
- Load balancing is the practice of distributing incoming network requests across multiple servers (often called a "server pool" or "backend servers") so that no single server bears too much burden.
- Lesson 1388 — What is Load Balancing?
- lock file
- A lock file is an automatically generated file that records the exact version of every dependency (direct and transitive) that was installed at a specific moment.
- Lesson 671 — Lock Files and Reproducibility
- Lock granularity
- Lock granularity refers to the size of the resource being locked—from an entire table down to individual rows or even smaller units.
- Lesson 916 — Row-Level vs Table-Level Locking
- Long Method
- A Long Method is a code smell where a single method or function becomes bloated with too many lines of code and too many responsibilities.
- Lesson 336 — Bloaters: Long Method
- Low coupling
- Low coupling means your modules depend on each other as little as possible.
- Lesson 182 — The Relationship Between Coupling and Cohesion
- Lower memory usage
- Smaller indexes are easier to cache in memory
- Lesson 876 — Partial and Filtered Indexes
M
- magic link
- A magic link is a unique, time-limited URL sent to your email.
- Lesson 997 — Passwordless Authentication Methods
- maintenance
- The SDLC acknowledges that software isn't "done" after the first release—maintenance is ongoing, which aligns with what we learned about how most engineering time goes toward keeping systems running and evolving.
- Lesson 9 — What is the Software Development Lifecycle (SDLC)?
- Maintenance burden
- Complex solutions require more documentation, more context to understand, and more careful changes. A simple three-line function is far easier to debug than a chain of decorators, factories, and abstract base classes—unless that complexity genuinely solves a real problem.
- Lesson 1825 — Simplicity Over Complexity
- Make
- Make is the grandfather of build tools, dating back to Unix systems.
- Lesson 660 — Common Build Tools Overview
- Making trade-offs
- choosing between competing needs when resources are limited
- Lesson 21 — The Product Owner and Business Stakeholders
- Managed services
- Managed services are like the restaurant: the cloud provider handles the infrastructure, maintenance, patching, scaling, and operations of a service (like a database or message queue), while you simply use it.
- Lesson 1511 — What Are Managed Services
- Managing contract changes
- Managing contract changes means deciding how to signal and implement changes.
- Lesson 552 — Contract Versioning and Evolution
- Manual instrumentation
- Manual instrumentation means you explicitly add code to create spans around important business logic or custom operations.
- Lesson 1149 — Instrumenting Code for Tracing
- Masked variables
- The platform stores secrets encrypted and injects them as environment variables at runtime, automatically hiding their values in logs (showing * instead)
- Lesson 747 — Secrets in CI/CD Pipelines
- Materialized Views
- Materialized Views are precomputed query results stored as physical tables.
- Lesson 866 — Denormalization Patterns
- merge strategy
- A merge strategy is the algorithm Git uses to combine changes from different branches.
- Lesson 64 — Merge Strategies and Options
- message broker
- A message broker is infrastructure that sits between services, managing message queues and routing.
- Lesson 1357 — Message Brokers vs Event Buses: Core Concepts
- Message queues
- Message queues are the infrastructure that makes this possible.
- Lesson 1316 — Message Queues for Async Communication
- Metrics
- Metrics are numerical measurements aggregated over time.
- Lesson 1136 — Metrics vs Logs vs Traces
- microservices architecture
- A microservices architecture is like a neighborhood of separate houses (services).
- Lesson 1295 — Monolith vs Microservices
- Migration paths
- Tell users exactly how to upgrade. "Replace oldFunction() with newFunction(param)" is far better than "this is going away."
- Lesson 676 — Deprecation and Version Lifecycle
- Migration script quality
- Rollback scripts are rarely tested as thoroughly as forward migrations. They're written "just in case" but seldom executed until the worst moment—when you're already in crisis mode.
- Lesson 889 — Forward-Only Migration Philosophy
- Milestones
- Milestones are significant points in your project timeline that mark the completion of major phases or achievements.
- Lesson 1659 — Identifying Milestones and Deliverables
- MIME sniffing
- This behavior is called MIME sniffing or content sniffing.
- Lesson 1074 — X-Content-Type-Options and MIME Sniffing
- Minimal input
- The most basic valid input (empty collection, zero, single item)
- Lesson 497 — Starting with the Simplest Test
- Misleading names
- The name suggests one thing but does another
- Lesson 348 — Rename Method and Rename Variable
- Missing Encryption in Transit
- Sending data over HTTP instead of HTTPS means attackers can intercept it (man-in-the-middle attacks).
- Lesson 1043 — A02: Cryptographic Failures
- Mistakes have smaller impact
- A developer with read-only database access can't accidentally DROP TABLE in production
- Lesson 1033 — Principle of Least Privilege
- Mocking frameworks
- Mocking frameworks are specialized libraries that let you create test doubles on-the-fly using a simple API, rather than writing full classes.
- Lesson 471 — Test Double Libraries and Frameworks
- Mocks
- Mocks are your choice when the interaction itself is what you're testing—when calling the right method with the right parameters is the behavior.
- Lesson 472 — When to Use Each Type of Test Double
- modular monolith
- A modular monolith is a single deployable application that's internally organized into well-defined, loosely coupled modules with explicit boundaries and strong encapsulation.
- Lesson 1288 — What is a Modular Monolith
- module
- A module is a distinct unit of deployment—a piece of software that can be built, packaged, and released independently.
- Lesson 522 — What Are Module Boundaries
- Molecule
- Molecule is specifically designed for testing Ansible roles.
- Lesson 1494 — Testing Configuration Code
- Monolithic Applications
- Within a single codebase, compile-time type checking and standard integration tests are usually sufficient. The overhead of contract tooling outweighs benefits.
- Lesson 553 — When to Use Contract Tests
- monolithic architecture
- A monolithic architecture is like living in a single house where all rooms are connected through shared hallways and infrastructure.
- Lesson 1295 — Monolith vs Microservices
- More than ~400 lines changed
- This is a rough guideline, not a hard rule, but beyond this point reviews become significantly harder.
- Lesson 107 — Knowing When to Split a Pull Request
- MoSCoW Method
- The MoSCoW Method is a prioritization technique that sorts requirements into four categories based on necessity.
- Lesson 153 — MoSCoW Method
- Move Field
- Move Method and Move Field are refactorings that relocate these misplaced elements to where they naturally fit.
- Lesson 349 — Move Method and Move Field
- Mutations
- Mutations are how you write data—creating new records, updating existing ones, or deleting them.
- Lesson 808 — Mutations: Writing Data in GraphQL
N
- Name encodings
- Name encodings are systems where you add prefixes or suffixes to variable names to indicate their type, scope, or other metadata.
- Lesson 371 — Avoiding Encodings and Hungarian Notation
- Networks
- Networks are unreliable and unpredictable
- Lesson 516 — External Dependencies and Infrastructure
- Nightly builds
- Run the full E2E suite when time constraints are relaxed
- Lesson 561 — E2E Test Execution Strategy
- No single source of truth
- The same conceptual value might be written slightly differently in different places
- Lesson 352 — Replace Magic Numbers with Constants
- non-deterministic builds
- This is called non-deterministic builds—the same inputs produce different outputs depending on when or where you build.
- Lesson 671 — Lock Files and Reproducibility
- non-repeatable reads
- These are called non-repeatable reads, and Read Committed allows them.
- Lesson 906 — Read Committed Isolation
- Novel or surprising failures
- New failure modes are learning opportunities, regardless of customer impact
- Lesson 1181 — When to Conduct a Postmortem
O
- Object Mother
- The Object Mother is a pattern where you create a dedicated class (or set of classes) containing factory methods that build common test objects with reasonable default values.
- Lesson 451 — Object Mother Pattern
- Object Pool
- An Object Pool is related but distinct: instead of cloning prototypes, you recycle actual object instances.
- Lesson 249 — Prototype Registry and Object Pools
- Observability
- Observability means building systems that expose their internal state and behavior so you can understand what's happening in production without guessing.
- Lesson 1244 — Testability and Observability
- Octopus
- Octopus is used when merging three or more branches simultaneously.
- Lesson 64 — Merge Strategies and Options
- on-call rotation
- An on-call rotation is a schedule that determines which engineer is responsible for responding to alerts and incidents during specific time periods.
- Lesson 1163 — The On-Call Rotation
- One reason to change
- One reason to change means one source of requirements.
- Lesson 194 — What is the Single Responsibility Principle
- Openness
- Teams and stakeholders are open about work and challenges
- Lesson 1581 — Scrum Framework Overview
- Operational Burden
- Managed services handle undifferentiated heavy lifting: backups, patching, scaling, high availability. Self-hosting means your team owns these responsibilities 24/7. Think of it like renting vs. buying a house—one includes maintenance, the other puts you on-call.
- Lesson 1518 — Evaluating Managed Service Trade-offs
- Operations naturally belong in the classes
- if drawing a shape is its primary purpose, shape.draw() is clearer than DrawVisitor
- Lesson 320 — When Visitor Adds vs Removes Flexibility
- Opportunistic refactoring
- Opportunistic refactoring means you clean up code while doing feature work—you're adding a function and notice messy code nearby, so you tidy it up before continuing.
- Lesson 363 — Opportunistic vs Planned Refactoring
- Opportunity cost
- Opportunity cost is what you sacrifice when choosing one option over another.
- Lesson 34 — The Cost of Delay and Opportunity Cost
- Optimization per service
- A recommendation engine might benefit from Python's data science libraries, while a payment processor needs Java's mature financial libraries and strict typing.
- Lesson 1335 — Technology Heterogeneity and Experimentation
- OPTIONS
- While GET, POST, PUT, and DELETE manipulate resource data, HEAD and OPTIONS are special HTTP verbs designed purely for gathering information about resources—without modifying them or even retrieving their full content.
- Lesson 767 — HEAD and OPTIONS: Metadata Operations
- orchestrator
- An orchestrator is a dedicated service that manages the entire saga workflow.
- Lesson 1370 — Saga Execution Coordinators
- Order of operations matters
- A notification was sent (behavior) after validation succeeded (state)
- Lesson 486 — Combining State and Behavior Verification
- Organizational accountability
- Organizational accountability means companies face:
- Lesson 1923 — Professional Liability and Accountability
- OWASP Top 10
- The OWASP Top 10 is a regularly updated list (roughly every 3-4 years) that ranks the most critical security risks facing web applications.
- Lesson 1041 — Introduction to the OWASP Top 10
P
- Pa11y
- Pa11y is a command-line tool that can test pages in isolation or as part of your CI/CD pipeline, providing detailed reports of accessibility issues.
- Lesson 582 — Automated Accessibility Testing
- Parallel Change
- The Expand-Contract Pattern (also called Parallel Change) gives you a safe, gradual path forward.
- Lesson 892 — The Expand-Contract Pattern
- Parallelization
- Parallelization means identifying which stages are independent and configuring your pipeline to execute them simultaneously.
- Lesson 706 — Parallelization and Pipeline Efficiency
- partial mocking
- This is called partial mocking or spying.
- Lesson 479 — Partial Mocking and Spying on Real Objects
- Partitioning by entity or tenant
- Partitioning by entity or tenant means organizing your data so that all records related to a specific entity (like a user, customer, or organization) live together in the same partition.
- Lesson 1399 — Partitioning by Entity or Tenant
- pass-through layers
- These are called pass-through layers or thin layers, and they're a sign of architectural over-engineering.
- Lesson 1261 — When Layers Become Too Thin
- Passkeys
- Passkeys are the user-facing implementation—cryptographic key pairs stored on your device.
- Lesson 997 — Passwordless Authentication Methods
- Patent Trolls
- These are entities (often called "non-practicing entities") that acquire patents solely to extract licensing fees or lawsuit settlements. They don't build products—they monetize legal threats. Defending against them is expensive, even when you'd likely win.
- Lesson 1888 — Patent Risks in Software Development
- paths
- The heart of the document. Each path (like /users or /products/{id}) represents an API endpoint. Under each path, you define operations (GET, POST, PUT, DELETE) that specify what actions are possible.
- Lesson 838 — Anatomy of an OpenAPI Document
- Per-test fixtures
- Per-test fixtures are created fresh before each test and torn down after.
- Lesson 542 — Shared vs Per-Test Fixtures
- Perceived reduced output
- Perceived reduced output is the biggest concern.
- Lesson 1626 — Benefits and Trade-offs of Pair Programming
- Performance
- No network calls; data is local
- Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
- Performance problems
- Performance problems are debuggers' Achilles heel.
- Lesson 1735 — Debugger Limitations and When to Use Alternative Tools
- Performance regression
- Performance regression means your system got slower, uses more memory, or handles fewer requests after a code change.
- Lesson 1211 — Baseline Metrics and Regression Detection
- Performance requirements outweigh storage costs
- If milliseconds matter and disk space is cheap
- Lesson 865 — Strategic Denormalization
- Periodic scanning
- Periodic scanning is the most common approach.
- Lesson 1492 — Configuration Drift Detection
- Persisted to disk
- Messages are written to disk storage before acknowledging receipt. The broker can recover messages after a restart by reading from disk. Like writing in a notebook—slower, but permanent.
- Lesson 1360 — Message Durability and Persistence
- persona
- A persona is a specific type of user with particular characteristics and needs.
- Lesson 146 — User Story Components: Personas and Goals
- Personal accountability
- Personal accountability means you can face:
- Lesson 1923 — Professional Liability and Accountability
- Personal data
- Personal data is any information that can identify a living individual, directly or indirectly.
- Lesson 1900 — Personal Data and Sensitive Information
- Phantom Reads
- Phantom Reads are when a transaction executes the same query twice and gets different sets of rows because another transaction inserted or deleted rows that match the query.
- Lesson 904 — What Isolation Levels Protect Against
- Pipeline as Code
- Pipeline as Code means writing your entire deployment pipeline—all its stages, tests, gates, and deployment steps—in text-based configuration files that live in your repository alongside your application code.
- Lesson 708 — Pipeline as Code
- Planned refactoring
- Planned refactoring means you schedule dedicated time specifically to improve code structure, often for larger improvements that can't be done in small increments.
- Lesson 363 — Opportunistic vs Planned Refactoring
- playbooks
- Runbooks and playbooks are pre-written, step-by-step guides that document how to handle specific incidents or operational tasks.
- Lesson 1168 — Runbooks and PlaybooksLesson 1490 — Ansible Fundamentals
- plugin architecture
- A plugin architecture is a design pattern where your core system defines these extension points, and separate modules (plugins) provide implementations that hook into them.
- Lesson 192 — Plugin Architectures and Extension Points
- pod
- A pod is Kubernetes' fundamental building block—the smallest unit you can create, deploy, and manage.
- Lesson 1444 — Pods: The Atomic Unit of DeploymentLesson 1454 — Pods: The Basic Unit of Deployment
- Pointer Chasing
- Following references through layers (Facade → Subsystem A → Component X) means more memory accesses, which can hurt CPU cache performance.
- Lesson 282 — Performance Overhead of Structural Patterns
- poison messages
- These are called poison messages—they're toxic to your system and can clog up your message queue if not handled properly.
- Lesson 1363 — Dead Letter Queues and Error Handling
- policies
- In Kanban (and other Agile frameworks), policies are explicit, written rules that define how work items move through your workflow.
- Lesson 1598 — Policies and Classes of Service
- port
- A port is an interface that defines how your core application interacts with the outside world.
- Lesson 1264 — The Ports and Adapters Pattern
- postcondition
- A postcondition is a guarantee a method makes about what will be true after it executes.
- Lesson 211 — LSP Violations: Weakening Postconditions
- Postconditions
- Postconditions are what must be true after a method completes.
- Lesson 209 — Behavioral Subtyping and Contracts
- Pre-commit hooks
- Pre-commit hooks are the most common type.
- Lesson 393 — Pre-commit Hooks and Git Hooks
- pre-population
- Cache warming (also called pre-population) means deliberately loading frequently accessed data into your cache before users request it.
- Lesson 970 — Cache Warming and Pre-population
- Preconditions
- Preconditions are what must be true before a method runs.
- Lesson 209 — Behavioral Subtyping and Contracts
- Predicate pushdown
- Predicate pushdown is the database optimizer's technique of applying these filters as early as possible in the query execution process—ideally before joining tables or scanning large datasets.
- Lesson 881 — Filtering and Predicate Pushdown
- Premature abstraction
- Premature abstraction means introducing interfaces, inheritance hierarchies, or plugin systems before you have concrete evidence they're needed.
- Lesson 207 — Balancing OCP with Simplicity
- prepared statements
- Parameterized queries (also called prepared statements) treat SQL code and user data as fundamentally separate things.
- Lesson 1055 — Preventing SQL Injection with Parameterized Queries
- Preserved knowledge
- The team understands the business logic embedded in the code. Rewriting risks losing this knowledge.
- Lesson 1765 — The Economics of Legacy Refactoring
- Prettier
- Prettier is one of the most popular code formatters, especially for JavaScript, TypeScript, CSS, and many other languages.
- Lesson 392 — Code Formatters and Prettier
- Prevent dead code elimination
- The compiler will remove calculations whose results aren't used. Always "use" benchmark results—print them, return them, or pass them to functions that prevent optimization. Many benchmarking frameworks provide special functions to mark values as "used" without adding overhead.
- Lesson 1200 — Writing Effective Benchmarks
- Prevent production vulnerabilities
- Issues are caught before merging, not after deployment.
- Lesson 625 — Integrating Fuzzing into CI/CD
- Primary Ports
- Primary Ports (driving ports) are entry points where external actors initiate requests into your application.
- Lesson 1266 — Primary and Secondary Ports
- Prior art
- Prior art is any publicly available evidence that your invention already existed before your patent filing date.
- Lesson 1887 — The Patent Process and Prior Art
- Privacy by Default
- Privacy by Default means users get maximum privacy protection out of the box:
- Lesson 1905 — Privacy by Design and Default
- Privacy by Design
- Privacy by Design means considering privacy at every stage:
- Lesson 1905 — Privacy by Design and Default
- Privilege escalation
- Privilege escalation is the nightmare scenario.
- Lesson 1031 — Choosing and Evolving Authorization Models
- Process
- Process means following systematic steps that keep work organized and verifiable:
- Lesson 6 — Process and Discipline
- Producers
- Producers are components that detect something noteworthy has happened and emit an event to announce it.
- Lesson 1340 — Event Producers and Consumers
- Product Backlog
- The Product Backlog is an ordered, living list of everything that might be needed in the product.
- Lesson 1585 — The Product Backlog
- production
- Profiling in production is like checking vital signs on a patient: you need accurate data from real conditions, but you must minimize disruption and overhead.
- Lesson 1199 — Profiling in Production vs Development
- Production traffic analysis
- Production traffic analysis means systematically examining metrics from your live system to understand actual usage patterns and plan accordingly.
- Lesson 1218 — Production Traffic Analysis for Planning
- professional code of ethics
- A professional code of ethics is a formal document that outlines the moral principles, values, and standards of conduct expected from practitioners in a field.
- Lesson 1892 — What Are Professional Codes of Ethics
- Project Description
- A clear 1-2 sentence summary of what the software does and who it's for. Don't assume readers understand your context—they may have just discovered your project through a search.
- Lesson 1683 — README Files
- Projection-Join Normal Form
- Fifth Normal Form (5NF), also called Projection-Join Normal Form, handles join dependencies where information can be reconstructed losslessly by joining three or more tables, but combining them creates redundancy.
- Lesson 863 — Higher Normal Forms (4NF, 5NF)
- promotion packet
- Your promotion packet is a structured document that proves you're already performing at the staff level.
- Lesson 1823 — The Staff Engineer Promotion Path
- Prototype Registry
- A Prototype Registry is a centralized collection of pre-made prototype objects that you can clone whenever you need similar instances.
- Lesson 249 — Prototype Registry and Object Pools
- providers
- In Terraform, providers are plugins that enable communication with specific platforms or services (AWS, Azure, GCP, Kubernetes, Docker, etc.).
- Lesson 1482 — Terraform Resources and Providers
- Pruning
- Pruning is the act of removing dependencies identified as unused during auditing.
- Lesson 681 — Dependency Pruning and Auditing
- Public API
- The only way other modules interact with yours—typically services, commands, or queries
- Lesson 1290 — Defining Module Boundaries
- Pull request triggers
- Build runs when a PR is opened or updated
- Lesson 639 — Build Triggers and Webhooks
- Pure interfaces
- Pure interfaces are perfect for ISP because they only declare methods—no implementation.
- Lesson 219 — ISP and Language Features: Abstract Classes vs Interfaces
Q
- Quality Attribute Scenario
- A Quality Attribute Scenario is a structured, three-part statement that makes quality requirements concrete:
- Lesson 1248 — Quality Attribute Scenarios
- quality gate
- A quality gate is a set of automated checks that run in your CI (Continuous Integration) pipeline and must pass before code can be merged into your main branch.
- Lesson 394 — CI-Based Quality Gates
- query
- In GraphQL, a query is how clients read data from the server.
- Lesson 807 — Queries: Reading Data in GraphQL
- query side
- In CQRS, the query side is entirely separate from the command side.
- Lesson 1352 — Query Side and Projections
- query whitelisting
- Taking persisted queries further, query whitelisting means the server only accepts pre-registered queries—rejecting any arbitrary query text.
- Lesson 821 — Persisted Queries and Query Whitelisting
- Quick Start Guide
- A minimal working example showing how to use the core functionality. Think "hello world" for your project—the fastest path to seeing value.
- Lesson 1683 — README Files
R
- Randomizing test execution order
- Randomizing test execution order means shuffling tests so they run in a different sequence each time.
- Lesson 460 — Randomizing Test Execution Order
- Rarely touched code
- If nobody needs to modify it, the refactoring ROI is near zero.
- Lesson 1765 — The Economics of Legacy Refactoring
- Rate-of-change
- sudden drops (100→10 req/sec) matter even if both are "low"
- Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
- Readability matters
- a class named AlwaysSuccessfulPaymentGateway is clearer than mock configuration
- Lesson 478 — Mock Frameworks and Hand-Rolled Doubles
- Real-time
- Invalidation happens immediately when events are processed
- Lesson 980 — Event-Driven Invalidation
- Rebalancing
- Rebalancing is the process of redistributing data across the cluster when the number of partitions or nodes changes.
- Lesson 1400 — Rebalancing Partitions
- Receiver
- Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
- Lesson 291 — Implementing the Command Pattern
- Recovery Point Objective
- Recovery Point Objective is the maximum amount of data loss you can tolerate, measured in time.
- Lesson 724 — Recovery Point and Time Objectives
- Recovery Time Objective
- Recovery Time Objective is the maximum acceptable downtime—how long your system can be unavailable before causing unacceptable business impact.
- Lesson 724 — Recovery Point and Time Objectives
- Recursive
- Recursive is Git's default strategy for merging two branches.
- Lesson 64 — Merge Strategies and Options
- Redeployment-Required Configuration
- Redeployment-Required Configuration means configuration is loaded once at startup.
- Lesson 732 — Configuration Changes Without Redeployment
- Reduced risk
- Changes are localized, so bugs are less likely to spread unexpectedly
- Lesson 177 — Understanding Coupling: How Components Depend on Each Other
- Redundancy
- The same information appears in multiple places. Imagine storing a customer's address with every order they place—that's wasteful and error-prone.
- Lesson 860 — What is Normalization?
- Refactoring
- Refactoring is the process of restructuring existing code to improve its internal design, readability, and maintainability without changing what the code actually does from the outside.
- Lesson 327 — What is Refactoring?Lesson 334 — Refactoring vs RewritingLesson 1757 — When to Rewrite vs Refactor
- Reflected XSS
- Script comes from the URL or request and is immediately echoed back
- Lesson 1062 — Cross-Site Scripting (XSS) Overview
- reflog
- The reflog (reference log) is Git's secret insurance policy.
- Lesson 70 — The Reflog: Git's Safety Net
- refresh token
- A refresh token is a long-lived credential issued alongside your short-lived access token.
- Lesson 1013 — Token Refresh and Rotation
- Refresh tokens
- Refresh tokens are long-lived credentials used solely to obtain new access tokens when the old ones expire—like a special ID card you show at the security desk to get a new visitor badge.
- Lesson 1021 — Access Tokens, Refresh Tokens, and Token Lifetime
- Regression tests
- Regression tests are tests that verify previously fixed bugs stay fixed and that existing functionality continues to work after new changes.
- Lesson 419 — Regression Tests: Preventing Old Bugs
- rehydration
- This process is called rehydration or reconstitution.
- Lesson 1349 — Rebuilding State from Events
- Release notes
- Release notes are user-facing summaries accompanying specific releases, often extracted from or based on the changelog but written with your audience in mind.
- Lesson 1687 — Changelog and Release Notes
- Release windows
- Release windows are pre-approved time slots when deployments are permitted, while blackout periods are times when releases are prohibited or severely restricted.
- Lesson 1548 — Release Windows and Blackout Periods
- reliability
- If a server crashes, clients just retry with another server; nothing is lost
- Lesson 131 — Reliability and Availability RequirementsLesson 757 — Statelessness in REST
- Reliability and Reproducibility
- Reliability and Reproducibility are the crown jewels.
- Lesson 1478 — Benefits and Challenges of Immutability
- Reliable but less available
- The machine is offline for maintenance regularly (lower availability), but when it works, it always dispenses exactly what you paid for (high reliability).
- Lesson 1241 — Availability and Reliability
- remote proxy
- A remote proxy represents an object in a different address space—perhaps on another server or process.
- Lesson 278 — Types of Proxies: Virtual, Protection, and Remote
- remote repository
- A remote repository is simply a copy of your Git repository that lives somewhere else, typically on a server or cloud platform like GitHub, GitLab, or Bitbucket.
- Lesson 73 — What Are Remote Repositories
- Removing obsolete items
- Delete or archive stories that are no longer relevant
- Lesson 157 — Backlog Management
- Rename Method
- Rename Method means changing a method's name to better express what it does.
- Lesson 348 — Rename Method and Rename Variable
- Replace Global State
- Globals and singletons (like Database.getInstance()) are testing nightmares. Wrap them in a parameter or instance variable you control.
- Lesson 1754 — Breaking Dependencies to Enable Testing
- Replace Temp with Query
- Replace Temp with Query means taking that calculation, moving it into its own method (a "query"), and calling that method instead of using the temp variable.
- Lesson 357 — Replace Temp with Query
- representation
- While the resource itself is the underlying concept (like "a user" or "an order"), the representation is how you package that data—typically as JSON.
- Lesson 779 — Designing Resource Representations
- Reproducibility
- Reproducibility means you can make the bug happen on demand, reliably, following specific steps.
- Lesson 1720 — The Importance of Reproducibility
- reproducible build
- A reproducible build means that given the same source code and build environment, you should get byte-for-byte identical output every time.
- Lesson 687 — Sources of Non-Determinism
- request
- Your request is the minimum room size you need (the scheduler won't place you somewhere smaller), and your limit is the maximum space you can occupy without disturbing other guests.
- Lesson 1451 — Resource Requests and Limits
- Request and response validation
- Request and response validation means using these schemas to automatically verify that actual HTTP traffic conforms to your specification.
- Lesson 843 — Request and Response Validation
- requestBody
- The structure of data sent to the API (for POST/PUT)
- Lesson 838 — Anatomy of an OpenAPI Document
- Resilience patterns
- Resilience patterns are battle-tested architectural strategies that help systems continue functioning (even in degraded modes) when parts fail.
- Lesson 1093 — Introduction to Resilience Patterns
- Resource constraints
- Locust and k6 are lighter than JMeter
- Lesson 1213 — Load Testing Tools and Frameworks
- Resources
- Resources are the actual infrastructure components you want to create or manage—virtual machines, databases, networks, storage buckets, or anything else your platform offers.
- Lesson 1482 — Terraform Resources and ProvidersLesson 1484 — Terraform Modules and Reusability
- Response urgency
- P0 means wake everyone up at 3 AM. P3 can wait until Monday morning.
- Lesson 1164 — Incident Severity Levels
- Responsive design
- Responsive design means your layout, navigation, and interactive elements adjust based on available screen space.
- Lesson 568 — Mobile and Responsive Testing
- Return consistent metadata
- Your response should include total count (after filtering), current page, and links to navigate—regardless of which combination of features is used.
- Lesson 789 — Combining Pagination, Filtering, and Sorting
- revert-first strategy
- The revert-first strategy means your default action is to revert the breaking commit immediately, restoring the build to green, then fix the problem properly in a new commit.
- Lesson 655 — The Revert-First Strategy
- Rewriting
- Rewriting means building a new system from scratch to replace the old one—you're demolishing the house and constructing a new one, hoping everyone can move seamlessly.
- Lesson 334 — Refactoring vs RewritingLesson 1757 — When to Rewrite vs Refactor
- Ripple Effects
- A bug fix in one area creates bugs elsewhere. Teams become afraid to refactor or improve code because the blast radius is unpredictable. This leads to technical debt accumulation as developers work around problems instead of fixing them.
- Lesson 179 — The Cost of Tight Coupling
- Risk
- High-churn code areas or complex business logic deserve more tests. Stable utility functions might need less. Focus testing where bugs are most likely or most damaging.
- Lesson 427 — Finding the Testing Sweet Spot
- Risk-based testing
- Risk-based testing means directing your testing energy toward the code that poses the highest risk if it fails.
- Lesson 402 — What to Test: Risk-Based Testing
- rituals
- Agile ceremonies (also called rituals or events) are recurring, time-boxed team meetings designed to create rhythm and transparency in Agile workflows.
- Lesson 1600 — What Are Agile Ceremonies?
- Rollback
- Rollback is your safety net—the ability to quickly return to the last known-good state.
- Lesson 719 — Deployment Risk and the Need for Rollback
- Root cause
- A specific code path that fails to release memory after processing certain requests
- Lesson 1742 — Learning from Production IncidentsLesson 1746 — Contributing Factors vs. Root Causes
- Root causes
- Root causes are the fundamental issues that, if addressed, would prevent the problem from happening again.
- Lesson 1746 — Contributing Factors vs. Root Causes
- runc
- The most widely-used low-level runtime, implements the OCI (Open Container Initiative) specification
- Lesson 1426 — The Container Runtime
S
- Safety thresholds
- some values are always dangerous regardless of patterns
- Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
- saga
- A saga is a sequence of local transactions where each service performs its own database transaction and publishes an event or message to trigger the next step.
- Lesson 1366 — What is the Saga Pattern
- salt
- A salt is a unique, random value generated for each user that gets combined with their password before hashing.
- Lesson 1001 — Salt: Preventing Rainbow Table Attacks
- Sanity tests
- Sanity tests are similar but slightly different—they verify that a specific area or recent change makes logical sense before proceeding.
- Lesson 423 — Smoke and Sanity Tests: Quick Health Checks
- schema
- In GraphQL, the schema is the single source of truth—it's the formal contract that describes exactly what data clients can query and what operations they can perform.
- Lesson 806 — GraphQL Schema and Type SystemLesson 1364 — Message Schemas and Evolution
- schema registry
- A schema registry is a centralized service that stores, versions, and validates schemas.
- Lesson 1364 — Message Schemas and Evolution
- Schema-first design
- Schema-first design means you start by writing your OpenAPI document (or similar contract) before touching any implementation code.
- Lesson 840 — Schema-First vs Code-First Design
- Screen Readers
- Blind and low-vision users navigate via text-to-speech software. Every interactive element needs semantic HTML and meaningful labels. An icon button without alt text is invisible to screen readers—like a door with no handle. Images, forms, and dynamic content all need textual descriptions that convey purpose, not just presence.
- Lesson 1929 — Designing for Diverse Abilities
- seam
- A seam is a place in your code where you can alter behavior without editing the code at that location.
- Lesson 1311 — Service Decomposition PatternsLesson 1753 — Finding Seams in Legacy CodeLesson 1769 — Seams and Dependency Breaking
- Secondary Ports
- Secondary Ports (driven ports) are exit points where your application initiates calls out to external systems.
- Lesson 1266 — Primary and Secondary Ports
- Secrets
- While most configuration values (like server ports or feature flags) are safe to share openly, secrets are different.
- Lesson 642 — Environment Variables and SecretsLesson 740 — What Are Secrets and Why They Matter
- Security and Trust
- Anyone can verify that your published binary actually came from the claimed source code. No hidden backdoors or malicious modifications can slip in undetected. This is critical for security-sensitive applications.
- Lesson 691 — Benefits and Trade-offs
- Security Breaches
- Source code often gets shared widely—through version control systems, code reviews, shared repositories, or even accidentally public GitHub repositories. Once a secret is in your code history, it's there forever, even if you delete it later. Attackers actively scan public repositories for hardcoded credentials.
- Lesson 741 — The Dangers of Hardcoding Secrets
- Security by design
- Security by design means building systems that remain secure even when attackers know exactly how they work—like using a high-quality lock that can't be picked even when the attacker understands its mechanism.
- Lesson 1035 — Security by Design, Not Obscurity
- seed
- A seed is a number that initializes the random number generator.
- Lesson 620 — Reproducing and Seeding
- Seed data
- Pre-populated rows inserted before tests run. You might create sample users, products, or orders that multiple tests can reference. This data represents the "baseline" state of your database.
- Lesson 543 — Database Fixtures and Test Data
- Self-hosted infrastructure
- Self-hosted infrastructure is like having the chef: you control everything but must manage all the cooking, cleaning, and equipment maintenance yourself.
- Lesson 1511 — What Are Managed Services
- Sensitive information
- Sensitive information is a subset of personal data that carries higher risk if exposed.
- Lesson 1900 — Personal Data and Sensitive Information
- Separation of Concerns
- Separation of Concerns means organizing your software so that different parts handle different responsibilities, and each part focuses on one thing without overlapping with others.
- Lesson 166 — Separation of Concerns
- Server-side
- You tell the host you need a table, and they escort you wherever they think is best. Simpler for you, but you depend on their judgment.
- Lesson 1324 — Client-Side vs Server-Side Discovery
- Server-Side Discovery
- The client makes a request to a load balancer or API gateway at a well-known location. This intermediary queries the registry and routes the request to an appropriate service instance. The client remains unaware of individual instances.
- Lesson 1324 — Client-Side vs Server-Side Discovery
- Serverless computing
- Serverless computing is a cloud execution model where you write and deploy code without provisioning, configuring, or managing servers.
- Lesson 1519 — What is Serverless and Function as a Service
- service mesh
- A service mesh is a dedicated infrastructure layer that manages inter-service communication concerns outside your application code.
- Lesson 1318 — Service Mesh and Communication Infrastructure
- service registry
- A service registry is the authoritative directory that tracks which service instances are currently running and where they're located.
- Lesson 1325 — Service Registry Patterns
- Session-per-request
- Session-per-request is typical in web apps: one session for the entire HTTP request lifecycle.
- Lesson 950 — Session and Transaction Management
- Set meaningful thresholds
- Color-code green/yellow/red zones so problems are obvious
- Lesson 1144 — Dashboard Design Principles
- sharding
- Data partitioning (also called sharding) solves this by dividing your dataset across multiple databases or storage nodes.
- Lesson 1396 — Why Partition Data?
- Shared fixtures
- Shared fixtures are set up once before all tests run and torn down once at the end.
- Lesson 542 — Shared vs Per-Test Fixtures
- shared lock
- A shared lock is acquired when a transaction wants to read data.
- Lesson 915 — Shared and Exclusive Locks
- Shotgun Surgery
- Shotgun Surgery is the opposite: one conceptual change requires modifying many unrelated classes.
- Lesson 340 — Change Preventers: Divergent Change and Shotgun Surgery
- Shrinking
- Shrinking is the process where the framework automatically tries to find a smaller, simpler input that still causes the same failure.
- Lesson 617 — Shrinking Fundamentals
- Simple Factory Pattern
- The Simple Factory Pattern is the most basic form of factory pattern.
- Lesson 241 — Simple Factory Pattern
- Simplified systems
- Less data means simpler storage, processing, and maintenance
- Lesson 1901 — Data Minimization Principle
- Single logical purpose
- Single logical purpose means one commit or pull request should do one thing: fix a bug, add a feature, refactor a function, or update documentation—not all four.
- Lesson 100 — Writing Small, Focused Changes
- Single point of failure
- If that person is compromised, the entire system is at risk
- Lesson 1037 — Separation of Duties
- Single source of truth
- Maintain one place where project status is always current
- Lesson 25 — Communication Channels and Stakeholder Management
- Skip persistence when
- Messages are transient notifications or easily regenerated data (cache invalidations, metrics)
- Lesson 1360 — Message Durability and Persistence
- SMS-Based Codes
- The server sends a temporary code via text message. While convenient, this is the weakest MFA method since SMS can be intercepted or SIM-swapped.
- Lesson 994 — Multi-Factor Authentication (MFA)
- snapshot
- A snapshot is a stored copy of an aggregate's complete state at a specific point in time.
- Lesson 1354 — Snapshots and Performance
- snapshot testing
- Approval testing (also called snapshot testing) works differently than assertion-based tests.
- Lesson 1762 — Approval Testing for Complex Outputs
- software entropy
- Your code experiences the same phenomenon, called software entropy.
- Lesson 41 — Code Evolution and Entropy
- Some upfront thinking
- Some upfront thinking is essential: You need to know your domain, identify key boundaries, and understand major components.
- Lesson 512 — Emergent Design vs. Upfront Design
- span
- A span is one unit of work within that trace—a single operation like a database query, HTTP call, or function execution.
- Lesson 1147 — Traces, Spans, and Context Propagation
- spans
- Distributed tracing follows a single request (called a trace) as it flows through your entire system, creating a timeline of connected events (called spans).
- Lesson 1146 — What is Distributed Tracing
- spatial decoupling
- In Event-Driven Architecture, spatial decoupling means that event producers don't need to know who is listening or where those listeners are located.
- Lesson 1342 — Spatial Decoupling
- specific name and contact details
- The specific name and contact details are extrinsic—unique to each individual card and provided at print time.
- Lesson 275 — Intrinsic vs Extrinsic State in Flyweight
- Spies
- Spies are ideal when you care about both the return value and whether/how something was called.
- Lesson 472 — When to Use Each Type of Test Double
- spike
- A spike is a time-boxed investigation task designed to answer a specific unknown.
- Lesson 1663 — Identifying Unknowns and Spikes
- spike solution
- A Proof of Concept (PoC) or spike solution is a focused, time-limited technical investigation designed to answer a specific question or validate an approach.
- Lesson 1844 — Proof of Concepts and Spike Solutions
- Sprint
- A Sprint is a time-boxed iteration—usually lasting two weeks (though one to four weeks is common)—during which the Development Team works to create a potentially releasable increment of the product.
- Lesson 1586 — Sprints in Scrum
- Sprint Retrospective
- The Sprint Retrospective is a dedicated meeting held at the end of every sprint where the entire Scrum team examines how they worked together, not just what they delivered.
- Lesson 1590 — Sprint Retrospective
- Sprint Review
- The Sprint Review is a collaborative ceremony held at the end of each Sprint where the Development Team demonstrates the working software they've completed to stakeholders, customers, and the Product Owner.
- Lesson 1589 — Sprint Review
- spy
- A spy is a test double that wraps around a real object (or function), allowing it to execute normally while secretly recording every interaction.
- Lesson 468 — Spies: Recording Interactions for Verification
- SSL stripping
- A man-in-the-middle attacker can intercept that initial HTTP request and keep the user on an insecure connection — a technique called SSL stripping.
- Lesson 1071 — HTTP Strict Transport Security (HSTS)
- stakeholder
- A stakeholder is anyone affected by your software or who can affect its success.
- Lesson 133 — Stakeholder Identification and Analysis
- Stakeholder-driven prioritization
- Stakeholder-driven prioritization means actively engaging those different voices, understanding their perspectives, and making deliberate trade-offs that the team can explain and defend.
- Lesson 156 — Stakeholder-Driven Prioritization
- stakeholders
- In software engineering, stakeholders are all the people or groups who care about, influence, or are affected by your software project.
- Lesson 19 — Who Are Stakeholders?
- State management
- State management is the system that tracks the real-world resources your IaC has created, so it can compare reality against your declarations.
- Lesson 1469 — State Management in IaC
- State Pattern
- State Pattern is about managing object behavior that changes based on internal state.
- Lesson 313 — Strategy vs State Pattern
- State-specific logic
- State-specific logic is complex and scattered
- Lesson 311 — State Pattern vs Conditional Logic
- statelessness
- In REST, statelessness means the server doesn't remember anything about previous requests from a client.
- Lesson 757 — Statelessness in REST
- static factory method
- A static factory method is simply a public static method that returns an instance of a class, instead of calling a constructor directly.
- Lesson 240 — Static Factory Methods
- Static thresholds
- Static thresholds are fixed values that never change.
- Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
- Statistics
- Statistics are metadata about your data: how many rows, distribution of values, histogram of common values.
- Lesson 877 — Index Maintenance and Statistics
- Status badges
- Status badges are visual indicators embedded in your README or project dashboard.
- Lesson 643 — Build Notifications and Reporting
- Step Out
- Finish executing the current function and pause when returning to the caller. Use this when you've seen enough of the current function and want to return to the calling context. This is "go back up."
- Lesson 1728 — Debugger Fundamentals: Breakpoints and Execution Control
- Steps
- The actual commands—install dependencies, run tests, build artifacts
- Lesson 638 — Build Configuration Files
- sticky sessions
- Session affinity, often called sticky sessions, is when a load balancer consistently routes all requests from the same user to the same backend server.
- Lesson 1392 — Session Affinity and Its Problems
- StorageClass
- A template defining how to dynamically provision storage (e.g., AWS EBS, Google Persistent Disk, NFS). When a PVC references a StorageClass, Kubernetes automatically creates a matching PV on-demand.
- Lesson 1459 — Persistent Volumes and Claims
- Stored XSS
- Malicious script is saved in your database
- Lesson 1062 — Cross-Site Scripting (XSS) Overview
- Storing Sensitive Data in Plain Text
- Transmitting passwords, credit cards, or personal information without encryption. We covered password hashing earlier—storing passwords as plain text is a classic cryptographic failure.
- Lesson 1043 — A02: Cryptographic Failures
- strangulation boundary
- A strangulation boundary is the dividing line between old and new code where you'll intercept requests and route them to either the legacy system or your modern replacement.
- Lesson 1775 — Identifying Strangulation Boundaries
- Strategic denormalization
- Strategic denormalization means deliberately adding redundancy or flattening data structures to speed up common read operations—while being fully aware of the trade-offs.
- Lesson 865 — Strategic Denormalization
- Strategy pattern
- The Strategy pattern is a design pattern that encapsulates different algorithms or behaviors into separate classes, all implementing the same interface.
- Lesson 205 — The Strategy Pattern and OCPLesson 313 — Strategy vs State Pattern
- stub
- A stub is a test double that provides hardcoded answers to method calls made during tests.
- Lesson 466 — Stubs: Providing Canned Responses
- Stubs
- Stubs are further up because they only return pre-programmed responses without real logic.
- Lesson 476 — The Test Double Pyramid
- sunset date
- A sunset date is the final day a version remains available.
- Lesson 794 — Managing Multiple API Versions
- Support tiers
- Clarify which versions get bug fixes, security patches, or new features. Users need to know if staying on an old version is risky.
- Lesson 676 — Deprecation and Version Lifecycle
- survey
- A survey is a structured collection of questions distributed to many people simultaneously.
- Lesson 139 — Questionnaires and Surveys
- Swimlanes
- Swimlanes are horizontal rows that divide the board by category.
- Lesson 1593 — The Kanban Board
- Synchronous replication
- The leader waits for at least one follower to confirm it received the write before acknowledging success to the client. Guarantees consistency but adds latency.
- Lesson 1402 — Leader-Follower Replication
- System archaeology
- System archaeology is similar: you dig through old code, manuals, specifications, and process documents to uncover what a system actually does and what requirements it must fulfill.
- Lesson 137 — Document Analysis and System Archaeology
- System integration
- A function that's 10% faster in isolation might not matter if it consumes only 0.5% of your total runtime. Conversely, optimizing a microbenchmark-winning approach might worsen overall performance by increasing memory pressure or blocking other operations.
- Lesson 1201 — Microbenchmarks and Their Limitations
T
- Task-to-task dependencies
- Task-to-task dependencies are the most common: "We can't start database migration testing until we finish writing the migration scripts."
- Lesson 1666 — What Are Project Dependencies
- Tasks
- Tasks are individual units of work (install package, copy file, restart service).
- Lesson 1490 — Ansible Fundamentals
- Team bottlenecks
- Multiple teams are blocked waiting to deploy shared code
- Lesson 1330 — Microservices Are Not a Goal
- Team Context
- A junior team benefits from more comprehensive tests as guardrails. Experienced teams might confidently write fewer tests. Consider your team's speed, skill, and comfort level.
- Lesson 427 — Finding the Testing Sweet Spot
- tech lead
- A tech lead is someone who simultaneously writes code and guides the technical direction of a team or project.
- Lesson 1786 — What is a Tech Lead?
- Tech Talks
- Tech Talks are scheduled presentations where engineers share deep dives into technologies, architecture decisions, or lessons learned.
- Lesson 1843 — Knowledge Sharing Mechanisms
- Technical debt
- Technical debt is a metaphor that compares software development shortcuts to financial debt.
- Lesson 36 — What is Technical Debt
- Technology obsolescence
- The language, framework, or platform is unsupported or unhireable.
- Lesson 1765 — The Economics of Legacy Refactoring
- Test brittleness
- If tests break whenever unrelated code changes, coupling is high
- Lesson 183 — Measuring Coupling and Cohesion in Practice
- test double
- A test double is a stand-in replacement for a real dependency during testing.
- Lesson 464 — What are Test Doubles and Why Use Them
- test environment
- A test environment is a complete, isolated copy of your production infrastructure—databases, services, APIs, and configurations—but separate and safe for testing.
- Lesson 558 — Test Environments for E2E Testing
- test fixture
- A test fixture is the fixed state of objects, data, and environment that you set up before running a test.
- Lesson 540 — What Are Test Fixtures
- Test fixtures
- Test fixtures are shared setup objects created once (often in setup methods) and reused across multiple tests.
- Lesson 455 — Test Fixtures vs Builders
- Test Kitchen
- Test Kitchen is a framework that spins up temporary virtual machines or containers, applies your configuration code (Ansible, Chef, Puppet), and then runs verification tests against the configured system.
- Lesson 1494 — Testing Configuration Code
- Testability
- Testability means designing software so it's easy to verify correctness through automated tests.
- Lesson 1244 — Testability and Observability
- Tested
- The code has comprehensive test coverage—unit tests, integration tests, and any other relevant tests have passed. Edge cases are handled, and the behavior is verified.
- Lesson 694 — Production-Ready Definition
- Testing
- A real database adapter vs. an in-memory test adapter
- Lesson 1270 — Multiple Adapters for One Port
- testing pyramid
- The testing pyramid is a visual guide for balancing your testing strategy.
- Lesson 407 — The Testing Pyramid Concept
- testing trophy
- The testing trophy is an alternative to the testing pyramid, proposed by Kent C.
- Lesson 412 — The Testing Trophy Alternative
- Tests that duplicate coverage
- Tests that duplicate coverage are the most common offenders.
- Lesson 429 — When to Skip or Delete Tests
- Think of it like urban planning
- A city planner doesn't just design roads for today's traffic—they consider population growth, economic trends, and quality of life goals. Similarly, you're architecting systems that must support future scale, new markets, and evolving customer needs.
- Lesson 1821 — Technical Strategy and Vision
- Think time
- Think time is the pause between requests that simulates human behavior.
- Lesson 1214 — Designing Realistic Load Tests
- Throughput
- Throughput is how many drinks the shop makes per hour.
- Lesson 1188 — Latency vs Throughput Trade-offs
- thundering herd
- This is the cache stampede (also called thundering herd): when a popular cache entry expires, a stampede of requests rushes to rebuild it, overwhelming the backend.
- Lesson 983 — Cache Stampede and Thundering Herd
- Tight Coupling
- If you need to create five other objects just to test one class, those dependencies are too tangled. The test's pain signals: "simplify these relationships."
- Lesson 507 — TDD as a Design Tool
- Time-critical opportunities
- A competitor launches tomorrow, and you need a minimum viable response today
- Lesson 42 — Balancing Debt and Delivery
- Timeboxing
- Accept data within a known time window. If TTL is 60 seconds, you know data is at most 60 seconds old.
- Lesson 982 — Dealing with Stale Data
- Token rotation
- Token rotation means issuing a new refresh token every time one is used—the old refresh token becomes invalid.
- Lesson 1013 — Token Refresh and Rotation
- trace
- Distributed tracing follows a single request (called a trace) as it flows through your entire system, creating a timeline of connected events (called spans).
- Lesson 1146 — What is Distributed TracingLesson 1147 — Traces, Spans, and Context Propagation
- trace ID
- A trace ID is a globally unique identifier assigned when a request enters your system.
- Lesson 1148 — Trace IDs and Correlation
- tracking
- This relationship is called tracking (or sometimes "upstream tracking").
- Lesson 79 — Tracking Branches
- trade secret
- A trade secret is confidential business information that provides a competitive advantage and is actively protected from disclosure.
- Lesson 1889 — Trade Secrets: Definition and Protection
- Transparency
- Everything needed to understand a request is visible in that request
- Lesson 757 — Statelessness in REST
- Treat each invocation independently
- Design as if every call is the first call ever.
- Lesson 1522 — Stateless Function Design
- Triangulation
- Triangulation is the technique of adding more test cases with different inputs until the hard-coded approach breaks, forcing you to generalize.
- Lesson 494 — Triangulation: Adding Tests to Drive Generalization
- Troubleshooting Tips
- Address common pitfalls. "If you see error X, check that Y is configured."
- Lesson 1681 — User Guides and Tutorials
- Trunk-Based Development
- Trunk-Based Development (TBD) is a branching strategy where everyone works on a single main branch—the "trunk." Instead of creating long-lived feature branches that exist for days or weeks, developers either commit directly to the trunk or create branches that last only a few hours before merging.
- Lesson 83 — Trunk-Based DevelopmentLesson 646 — Working on the Trunk vs Feature Branches
- trust boundary
- A trust boundary is any point where data crosses from an untrusted source into your application's trusted zone.
- Lesson 1039 — Trust Boundaries and Input Validation
- Twelve-Factor App
- The Twelve-Factor App is a methodology created by engineers at Heroku that defines best practices for building software-as-a-service applications.
- Lesson 1503 — The Twelve-Factor App Methodology
- Type Safety
- Strong typing ensures field names don't become typos scattered across your codebase. Some libraries offer compile-time checks that "userId" is always a number, never a string.
- Lesson 1133 — Structured Logging Libraries and APIs
U
- Unclear Intent
- The code works, but why it works or what business rules it implements may be mysterious. Comments are sparse or outdated.
- Lesson 1749 — Defining Legacy Code
- Unit tests
- Unit tests are cheap—they run in milliseconds, test small pieces in isolation, and rarely break when you refactor unrelated code.
- Lesson 407 — The Testing Pyramid ConceptLesson 409 — The Cost-Confidence Trade-off
- Upfront design
- Upfront design means planning your architecture, classes, and relationships before writing code.
- Lesson 512 — Emergent Design vs. Upfront Design
- upstream
- The original repository you forked from (where you pull updates)
- Lesson 81 — Working with Multiple Remotes
- URI versioning
- URI versioning is easiest for clients and testing.
- Lesson 848 — API Versioning Strategies
- Usability
- Usability is how easily users can accomplish their goals with your system.
- Lesson 1245 — Usability and Accessibility
- user story
- A user story is a short, simple description of a software feature written from the end-user's point of view.
- Lesson 143 — What is a User Story?
- Using data and evidence
- Opinions are weak; data is strong. Show metrics, prototype results, or case studies that demonstrate your point.
- Lesson 1794 — Influence Without Authority
V
- Velocity
- Velocity is empirical—what they actually deliver.
- Lesson 1656 — Velocity and Capacity Planning
- Vendoring
- Vendoring means copying dependency source code directly into your project's repository.
- Lesson 680 — Vendor Dependencies and Private Packages
- Verbose error messages
- Verbose error messages are surprisingly dangerous.
- Lesson 1046 — A05: Security Misconfiguration
- Version control
- Every pipeline change is tracked in Git with commit messages explaining why
- Lesson 43 — What is Version Control and Why Git?Lesson 708 — Pipeline as Code
- version lifecycle
- A version lifecycle describes the stages a version goes through: active development, maintenance mode, and eventual end-of-life (EOL).
- Lesson 676 — Deprecation and Version Lifecycle
- Vertical scaling
- Vertical scaling is simpler initially—no changes to your application architecture needed, just more powerful hardware.
- Lesson 1240 — Scalability: Horizontal and Vertical
- Vertical slicing
- Vertical slicing means decomposing work so each slice goes "vertically" through your entire application stack—from user interface through business logic to database and back—rather than working on one layer at a time ("horizontal slicing").
- Lesson 1661 — Vertical Slicing
- Visualization
- Log management tools (like Elasticsearch, Splunk, or CloudWatch) can graph trends, build dashboards, and alert on thresholds—all because the data fields are predictable and machine-readable.
- Lesson 1135 — Querying and Analyzing Structured Logs
W
- Weak typing
- Weak typing means errors surface at runtime
- Lesson 1315 — gRPC for Service-to-Service Communication
- WebAuthn
- WebAuthn is a web standard that lets users authenticate using biometrics, security keys, or device credentials.
- Lesson 997 — Passwordless Authentication Methods
- webhook
- A webhook is how your version control system (like GitHub or GitLab) notifies your CI server that something happened.
- Lesson 639 — Build Triggers and Webhooks
- Whether assertions check the right behavior
- A test might execute code but only verify trivial or wrong conditions
- Lesson 592 — Limitations of Coverage Metrics
- Whistleblowing
- Whistleblowing is the act of reporting illegal, unethical, or dangerous practices to external authorities or the public when internal channels fail or are unsafe.
- Lesson 1921 — Whistleblowing and Legal Protections
- Work Breakdown Structure
- A Work Breakdown Structure is a hierarchical decomposition of your entire project into smaller, progressively more detailed components.
- Lesson 1658 — Work Breakdown Structures (WBS)
- Work Distribution
- Multiple workers pull from the same queue, naturally load-balancing tasks across the pool. If one worker is busy, another picks up the next message.
- Lesson 1359 — Message Queues and Point-to-Point Messaging
- Working infrastructure
- The surrounding systems, deployment pipelines, and integrations can remain intact.
- Lesson 1765 — The Economics of Legacy Refactoring
- Wrong guesses
- Your prediction about future needs is often incorrect, making the work useless
- Lesson 170 — You Aren't Gonna Need It (YAGNI)
Y
- YAML
- JSON and YAML are great for structured, hierarchical data like objects or nested records.
- Lesson 544 — Fixture Files and Data Formats
- You'll learn
- The two fundamental approaches to creating API contracts—whether you design the contract upfront or generate it from your code.
- Lesson 840 — Schema-First vs Code-First Design
Z
- Zipkin
- Jaeger and Zipkin are two popular open-source tracing backends.
- Lesson 1153 — Tracing Infrastructure and Tools