A government agency is building a safety-critical air traffic control system with fully specified requirements that will not change. Which software development model is most appropriate?

Agile — iterative sprints allow rapid changes to meet evolving needs Waterfall — sequential phases suit stable, fully-specified requirements where changing mid-project is very costly No formal model — experienced engineers do not need a process Agile — all software must use Agile as it is always superior

A start-up is building a consumer app where users provide feedback after each release and requirements change frequently. Which development model is most appropriate?

Waterfall — complete all planning before building to avoid rework Agile — short sprints deliver working software quickly and allow requirements to evolve based on feedback No testing — move fast and fix bugs after launch Waterfall — it is always safer to complete requirements analysis first

A developer writes a function that converts temperature from Celsius to Fahrenheit. Using test-driven development (TDD), what should she do first?

Write the conversion formula first, then write tests to verify it Write a test that checks the function converts 0°C to 32°F and 100°C to 212°F — before writing any conversion code Deploy the function immediately and fix errors reported by users Write documentation explaining the formula, then implement it

A team uses Git and makes a change that accidentally breaks a feature. What Git capability allows them to quickly restore the codebase to the last working state?

Deleting the repository and starting again — Git history is not reliable Reverting to a previous commit — Git stores the complete history of every change Contacting GitHub support to restore the deleted code Using find-and-replace to manually undo all changes

Two developers both modify the same file simultaneously on different branches. When they merge, Git reports a conflict. What is the correct approach?

Always accept the most recently committed version — it is the most up to date Delete both conflicting files and rewrite from scratch Manually review both sets of changes, decide which to keep or combine, then commit the resolved file Conflicts are automatic errors — wait for Git to resolve them overnight

A unit test for a payment function passes in isolation, but the payment system fails when integrated with the user-authentication module. Which level of testing would have caught this failure?

Unit testing — this is exactly what unit tests detect Acceptance testing — only end users can find integration problems Integration testing — tests that verify multiple components work correctly together Code review — reading the code would reveal the conflict immediately

Technical debt is accumulating in a codebase because developers take shortcuts to meet deadlines. Which analogy best describes the long-term consequence?

Like a clean office — clutter never compounds and can be tidied anytime without extra cost Like financial debt with interest — the longer it is left unpaid, the more effort future changes require Like physical fitness — a period of inactivity is easily recovered from with a brief effort Like a battery — it discharges slowly and can be recharged without consequence

A developer uses the 'rubber duck debugging' technique. What does this involve, and why does it work?

Running the code inside a rubber isolation environment to prevent system damage Handing the code to a junior developer who asks 'duck' (basic) questions Explaining code line-by-line to an inanimate object — verbalising often reveals the bug the developer had mentally skipped Placing rubber markers in code at every line that might be buggy

A pull request in Git is created by a developer before merging feature work into the main branch. What is its primary purpose in a professional engineering team?

To notify the team that a developer has started working on a feature To automatically deploy the new feature to all users To allow peer code review and automated testing before changes are integrated into the shared codebase To request that GitHub pull the latest version from the developer's machine

Acceptance testing is the final level of testing before software is delivered. Who typically performs it, and what does it verify?

The development team — they know the system best and can test it fastest Automated test scripts — acceptance tests must be fully automated The customer or their representative — it verifies that the software meets the agreed business requirements from the user's perspective The security team — acceptance tests focus on vulnerability scanning

A developer bisects a bug using Git's binary search capability: she tests the midpoint commit, determines the bug is not present, and then tests a commit halfway between the midpoint and the latest. What debugging strategy is she applying?

Linear search — she tests every commit from newest to oldest Binary search through code history — halving the search space each time to locate the commit that introduced the bug Random sampling — she picks commits at random hoping to find the bug quickly Stack tracing — she follows the call stack back to the origin of the crash

A software system works correctly and all tests pass, but the code is difficult to understand and modify. A developer refactors it — rewriting the internal structure without changing external behaviour. Why is this valuable?

Refactoring adds new features while keeping existing tests passing Readable, well-structured code reduces future bug introduction rate and makes the codebase easier to extend Refactoring is only valuable if the original code had bugs Refactoring is done to improve performance, not readability