GK One-Line Question & Answer

Maintenance release planning allocates capacity across maintenance types based on business priorities: critical defects addressed immediately; adaptive work driven by external deadlines (OS upgrades, regulation changes); perfective work in regular releases; the allocation ratio reflects risk tolerance and strategic investment decisions

Architecture erosion occurs when implemented code progressively diverges from intended architecture due to expedient fixes and shortcut implementations — slowed by Architecture Decision Records (ADRs), automated architectural fitness functions, and regular architecture review sessions

Software retirement decommissions a system and migrates its functions — criteria: maintenance cost exceeds business value delivered, replacement system has achieved equivalent functionality, user migration is complete, and data archival/legal retention requirements are satisfied

Rehosting ('lift and shift') moves to new infrastructure without code changes; replatforming makes minimal code changes to leverage cloud capabilities; refactoring restructures code for maintainability while preserving functionality — cost/risk increases in that order, as does modernisation value

MTBF is the average time between failures (reliability measure); MTTR is the average time to restore service after failure (recovery measure) — for high-availability systems, minimising MTTR often provides more availability improvement than reducing MTBF, as modern systems accept failures as inevitable

Re-engineering examines and alters an existing system to reconstruct it in a new form at a higher level of abstraction — it includes reverse engineering (understanding existing system), restructuring, and forward engineering, often transforming the system's architecture, not just code quality

CMM describes software process maturity in five levels; Level 5 (Optimising) means the organisation uses quantitative data from its defined processes to drive continuous process improvement — defect prevention through systematic root cause analysis

Software metrics quantify attributes of software or processes; Goodhart's Law implies that once a metric becomes a management target, it ceases to be a good measure — developers optimise for the metric rather than the underlying quality it was meant to represent

Software dependability is the degree to which a system can be trusted to deliver its service — constituted by: Availability (ready when needed), Reliability (correct service over time), Safety (no catastrophic consequences on failure), and Security (no unauthorised access or use)

Formal methods use mathematical notation to specify and verify software properties; they are most justified for safety-critical systems (nuclear reactor control, aircraft fly-by-wire, pacemakers) where the cost of failure in human lives justifies the high upfront mathematical specification cost

The cone shows that early project estimates have inherent uncertainty ranges of 4x — managers should express early estimates as ranges (not single values), track how the range narrows as design proceeds, and avoid making firm commitments before the range has narrowed sufficiently

Software ergonomics (HCI) studies how humans interact with software systems; governing principles: recognition over recall (show options rather than requiring memory), feedback (acknowledge every action), error prevention over recovery, consistency, and user control and freedom

Conway's Law: organisations design systems that mirror their communication structures — it implies that to get the architecture you want, you must first structure your teams to mirror that architecture (the 'inverse Conway manoeuvre')

FURPS+ (Grady, HP) is a quality model: Functionality (features, capabilities), Usability (human factors, aesthetics), Reliability (frequency of failure, recoverability), Performance (speed, throughput, memory), Supportability (maintainability, testability); + adds constraints (design, implementation, interface, physical)

ISO/IEC 25010 addresses product quality from two perspectives: quality in use (effectiveness, efficiency, satisfaction, freedom from risk, context coverage — how well users achieve goals) and product quality (functional suitability, reliability, performance efficiency, usability, security, maintainability, portability, compatibility)

The software crisis arose from unmanageable complexity in large programs built with unrestricted GOTO statements — structured programming (Dijkstra, Böhm-Jacopini) directly responded by restricting control flow to sequence, selection, and iteration, making programs provably analysable

Software reuse leverages existing software artefacts to build new systems — practised at three levels: component level (reusing libraries/APIs), architectural level (reusing patterns and frameworks), and product line level (systematic reuse of a family of systems' shared assets)

Immature processes are ad-hoc and person-dependent — outcomes depend entirely on individual heroics rather than systematic practices; when key people leave or are unavailable, the process breaks down, creating unpredictable results even with competent individual developers

Product quality measures attributes of the delivered software (correctness, reliability, usability); process quality measures how well the development process is executed (adherence to standards, predictability, defect removal efficiency) — high process quality tends to yield high product quality but is not guaranteed

ISO/IEC 12207 defines a comprehensive set of software lifecycle processes (acquisition, supply, development, operation, maintenance, support, organisational) providing a common framework for organisations to specify and implement software processes

Fault tolerance continues operation despite faults; fail-safe defaults to a safe state on failure (fire door opens when power fails — safe for occupants); fail-secure defaults to a secure state on failure (electronic lock locks when power fails — secure against intruders) — these may conflict in some systems

Kruchten's 4+1 view model documents architecture from five stakeholder perspectives: Logical (classes, components), Process (concurrency, threads), Development (source organisation, build), Physical (deployment, servers), + Use cases (scenarios tying the four views together)

Cost estimation predicts effort, schedule, and resources needed; underestimation is driven by: optimism bias (planning fallacy), omitting activities (testing, documentation, meetings), unclear requirements at estimation time, political pressure to win contracts, and the cone of uncertainty being ignored

Scrum at 200+ developers faces: dependency management across 20+ teams, synchronisation overhead (Scrum of Scrums coordination), architectural alignment (preventing Conway's Law fragmentation), release coordination (all teams must be shippable simultaneously), and cultural resistance from middle management whose roles are disrupted

Hybrid models combine elements from different process models tailored to specific project characteristics — appropriate when part of the system has stable requirements (use plan-driven phases for architecture/safety-critical components) while other parts have volatile requirements (use agile for UI/features)

Executable specifications express requirements as runnable tests (BDD scenarios, acceptance tests) — changing the role of requirements documents from static text to living documentation that is simultaneously a specification, a test suite, and proof of implementation correctness

Dual-track agile runs a discovery track (UX research, prototyping, user testing to validate ideas) parallel to a delivery track (engineering sprints building validated features) — addressing the problem of building features without validating they're the right features to build

Evolutionary prototyping builds a prototype with the intention of continuously evolving it into the final system; throwaway prototyping builds a quick-and-dirty prototype solely to elicit requirements, then discards it and rebuilds properly — evolutionary carries architectural risk if not carefully managed

The value prioritises ongoing customer collaboration over rigid contract terms — supported by time-and-materials or outcome-based contracts that allow scope to evolve, rather than fixed-price fixed-scope contracts that make change adversarial

Safe-to-fail experiments are small, low-cost probes designed so that failure provides learning rather than catastrophe — applied to software by running multiple small A/B tests or MVP variants simultaneously rather than betting everything on a single large release

Continuous delivery ensures every commit is releasable (deployable on demand by business decision); continuous deployment automatically releases every passing commit to production without human approval — distinguished by organisational capability: trust in automated testing, deployment automation, monitoring, and cultural acceptance of frequent small releases

Value stream mapping traces the flow of a feature from idea to production, identifying waste in the process — waste categories in software (Poppendieck's lean): partially done work, extra processes, extra features, task switching, waiting, motion (handoffs), defects

Mob programming has the entire team (3-5+ developers) working at one computer simultaneously with rotating 'drivers' — research and practitioner reports suggest: significantly better code quality and knowledge sharing, lower defect rates, faster onboarding, but higher initial cognitive overhead and requires strong facilitation

Traditional iron triangle fixes scope and varies time/cost; agile inverts this by fixing time (sprint length) and cost (team size) while varying scope — delivery management shifts from schedule tracking (will we finish everything?) to value maximisation (are we delivering the highest value within the fixed cadence?)

Product discovery identifies validated customer needs and solutions before engineering commitment; the opportunity solution tree (Teresa Torres) maps: desired outcome → opportunities (customer needs) → solutions → experiments — ensuring solutions are traceable to real customer problems

INVEST: Independent (can be developed in any order, no story blocking another), Negotiable (details subject to discussion), Valuable (delivers user value), Estimable (team can estimate effort), Small (fits in one sprint), Testable (has clear acceptance criteria) — each criterion addresses a failure mode of poorly written stories

Knowledge management in maintenance preserves and distributes understanding of the system — 'knowledge debt' accumulates when: key developers leave without knowledge transfer, documentation is not updated with changes, and tribal knowledge is never externalised into wikis or decision records

The broken windows theory (Hunt and Thomas) suggests that visible neglect (bad code, commented-out code, inconsistent style) signals that the codebase has no standards, inviting further neglect — empirically, modules with high existing defect density attract disproportionately more new defects

Maintenance cost models predict long-term maintenance effort — empirical research (Boehm, Jones, Lehman) consistently identifies the system's structural complexity (cyclomatic complexity, coupling, cohesion) and the quality of design documentation as the dominant maintenance cost drivers

SQA is a systematic, planned set of actions ensuring the software development process is followed correctly; testing is a subset of SQA that verifies the product — SQA audits the process, testing evaluates the product