GK One-Line Question & Answer

A technical spike is a time-boxed research or proof-of-concept effort used when a team faces significant technical uncertainty — the spike produces knowledge (not shippable product) that enables accurate estimation and informed design decisions

Story mapping arranges stories in a two-dimensional grid (horizontal: user journey steps; vertical: priority/detail) — solving the flat backlog's problem of losing the narrative and context of how features relate to user goals

Cynefin (Snowden) categorises problems as Obvious, Complicated, Complex, or Chaotic — guiding process selection: Waterfall suits Obvious/Complicated domains (best practices exist); Agile suits Complex domains (practices emerge through experimentation); chaotic domains require immediate action

MoSCoW classifies requirements as Must-have, Should-have, Could-have, and Won't-have this time; ignoring it risks delivering complete features of low importance while must-have requirements remain unfinished at delivery

Volere shell is a template for documenting individual requirements capturing: requirement number, description, rationale, originator, fit criterion, customer satisfaction/dissatisfaction, conflicts, priority, history, and supporting material

Contextual inquiry involves observing users in their actual work environment while they perform real tasks — revealing workarounds, informal processes, environmental constraints, and tacit knowledge that users would never articulate in interviews

Impact mapping models the causal chain: WHY (business goal) → WHO (actors) → HOW (impacts on actors) → WHAT (deliverables/features) — preventing feature factories that deliver functionality disconnected from business outcomes

Requirements inspection applies Fagan-style checklists targeting requirements-specific defects: ambiguity (multiple interpretations), incompleteness (missing states/conditions), inconsistency (contradicting requirements), unverifiability (no testable criterion), and infeasibility

QFD (from manufacturing, applied to software) translates customer requirements (WHATs) into technical design characteristics (HOWs) via a correlation matrix — the 'house of quality' is this matrix showing which technical parameters satisfy which customer needs and their interactions

Stated: explicitly requested by stakeholders; Implied: expected by convention but not stated (e.g., system should not lose data); Latent: unknown even to stakeholders until they experience a prototype — all three must be elicited for a complete system

SBE describes requirements through concrete examples of desired system behaviour rather than abstract statements — concrete examples remove ambiguity, serve as acceptance tests, and create shared understanding across business and technical stakeholders

Requirements conflicts arise when stakeholders have incompatible needs (e.g., security vs usability, performance vs cost); resolutions include: negotiation to find compromise, creating priority rankings, architectural solutions satisfying both, or explicitly deferring one requirement

JAD (Joint Application Design) brings all stakeholders together in intensive structured workshops to jointly produce requirements — the joint authoring advantage is that conflicts surface and are resolved in real time rather than circulating documents with contradictory comments over weeks

Design for testability structures software so components can be isolated and tested independently — requiring: well-defined interfaces, dependency injection, avoidance of global state, separation of I/O from logic, and observable internal state

Interface design for APIs applies principles of least surprise (behave as expected by experienced users), consistency (similar operations work similarly), minimal surface area (expose only what is needed), and progressive disclosure (simple cases are simple; complex cases are possible)

OCP (Bertrand Meyer/Martin): software entities should be open for extension but closed for modification — commonly implemented through abstract base classes/interfaces where new behaviours are added by creating new implementing classes rather than modifying existing ones

ISP states that clients should not be forced to depend on methods they don't use — large fat interfaces force implementing classes to provide empty or throw-not-implemented implementations, indicating a design smell that should be split into focused interfaces

Decorator pattern wraps an object to add responsibilities dynamically at runtime — enabling combinations of behaviours (Logging + Caching + Authentication) without the combinatorial explosion that inheritance requires (LoggingCachingAuthWrapper vs AuthCachingWrapper etc.)

CK (Chidamber and Kemerer) suite measures OO design quality: WMC (Weighted Methods per Class), DIT (Depth of Inheritance Tree), NOC (Number of Children), CBO (Coupling Between Objects), RFC (Response for a Class), LCOM (Lack of Cohesion in Methods)

Template method defines a skeleton algorithm in a base class with abstract steps implemented by subclasses — solving the problem of algorithm variants that share the same skeleton but differ in specific steps, without duplicating the skeleton in each variant

Design by committee occurs when too many stakeholders have equal authority over design decisions — producing incoherent architectures that are compromises between conflicting visions, lacking the conceptual integrity that a single architectural mind would provide

Proxy wraps an object to control access — three uses: Virtual proxy (lazy loading of expensive objects), Remote proxy (local representation of a remote object), Protection proxy (access control/authentication before delegating to real object)

SemVer (MAJOR.MINOR.PATCH) communicates: MAJOR increment = breaking API changes (consumers must update); MINOR = backward-compatible new features; PATCH = backward-compatible bug fixes — enabling automated dependency management decisions

Literate programming (Knuth) interweaves human-readable prose explaining the program's design with code snippets in any order — the document is primary; code is extracted by a preprocessor (TANGLE). Knuth claimed it led to his best programs and fewest bugs

Dead code is reachable or referenced code that is never actually executed in any deployment scenario — it misleads maintainers about system scope, may contain security vulnerabilities, and creates ambiguity about whether removing it would break something

At code level, strangler fig refactoring wraps an old implementation with a new interface, routing calls through the wrapper that gradually replaces internal behaviour — it applies the same incremental replacement principle as the architectural pattern but within a single codebase

Good identifier naming encodes domain concepts, intent, and level of abstraction — grounded in the cognitive principle that working memory is limited (Miller's law: 7±2 chunks) and meaningful names reduce cognitive load by making identifiers carry semantic content rather than requiring decode from arbitrary symbols

Code coverage measures which lines/branches are executed during testing; 100% coverage is insufficient because coverage only proves code was executed, not that correct assertions were made — a test with no assertions achieves 100% coverage while detecting zero defects

Pair programming provides continuous lightweight review as code is written (low overhead, catches defects early, knowledge transfer); formal inspection is a structured defect-removal process for critical high-risk modules (higher overhead but finds more defects per review hour on complex code)

Self-documenting code uses expressive naming and clean structure so code communicates intent without comments; comments are reserved for WHY decisions were made (not WHAT the code does, which should be obvious), especially counter-intuitive choices and invariants

Technical documentation (architecture decision records, API docs, internal wikis) targets developers/maintainers who need to understand, extend, or fix the system; user documentation (manuals, tutorials, help systems) targets end users who need to accomplish tasks

Exploratory testing simultaneously designs and executes tests using tester judgment and domain knowledge — it excels at finding defects in unanticipated scenarios, complex interaction chains, and edge cases that no specification anticipated

Fuzzing automatically generates large volumes of random, malformed, or unexpected inputs and feeds them to the system — particularly effective at finding memory safety vulnerabilities (buffer overflows, use-after-free, integer overflows) in C/C++ code

MBT derives test cases automatically from a formal model (finite state machine, UML statechart) of expected system behaviour — guaranteeing that all specified transitions or states in the model are covered, making test completeness formally measurable

Load testing verifies system meets performance SLAs at expected peak load; stress testing finds the breaking point by exceeding normal load; soak testing runs normal load for extended periods to find memory leaks and resource exhaustion over time

Contract testing verifies that a service provider's API matches the expectations of its consumers — solving the problem of integration tests being too slow and brittle by enabling each team to test against consumer-driven contracts independently, without deploying all services

Stub returns hard-coded responses (controls indirect inputs); Mock verifies expected interactions were made (verifies indirect outputs); Spy wraps a real object recording calls for later verification without replacing behaviour by default

Test pyramid (Fowler/Cohn) recommends many fast unit tests at base, fewer integration tests in middle, fewest UI/E2E tests at top; inverted 'ice cream cone' (mostly E2E tests) causes slow CI (hours per run), brittle tests (UI changes break everything), and poor defect isolation

Architectural patterns describe system-level structure (Microservices, MVC, Event-driven, Layered); design patterns describe local object-level solutions (Singleton, Observer, Factory) — architectural patterns have system-wide impact; design patterns are applied within individual components

A code review checklist provides explicit prompts for reviewers to inspect specific defect categories — counteracting confirmation bias (reviewers unconsciously confirming the code does what they expect rather than looking for what it does wrong)