CCNA Itf Software Development Questions

Integration testing is a recognised SDLC test level: it verifies that individually tested modules interact correctly through their interfaces and data flows. This satisfies the stem's requirement for a distinct level, sitting between unit testing and system testing in the conventional hierarchy.

Breakpoint inspection pauses execution at a chosen line so the developer can read live variable values at that exact moment. This directly matches the stem's described technique, unlike logging, stepping or static code review, which do not halt and examine state.

A record or struct groups related values under one name and exposes each value through a named field, such as address.city or address.postalCode. This matches the requirement to keep the parts of an address together while accessing them by meaningful names instead of numeric positions, improving readability and reducing mistakes.

Statelessness is a key constraint of REST.

A flowchart uses standard symbols: diamonds for decisions and rectangles for processes, exactly matching the developer's requirement to map program logic before coding. Unlike pseudocode or structured English, it is a visual diagram, satisfying the stem's demand for shapes representing decisions and processes.

Exception handling allows the function to catch a division-by-zero or empty-list error and respond gracefully, such as returning zero or a message. Since the crash occurs at runtime when the list is empty, wrapping the calculation in a try-catch block directly addresses the failure and prevents the program from terminating unexpectedly, making it the appropriate concept here.

A flowchart uses standardised ANSI symbols, diamonds for decisions and rectangles for processes, mapping conditions such as membership to actions such as applying a discount. This visual notation represents branching program logic directly, unlike pseudocode or a data dictionary, which lack decision symbols.

A try-catch block lets the code attempt the file read and intercept the exception raised when the file is missing. The catch block can then display the friendly message and allow the program to continue. This is the standard structured way to handle anticipated runtime errors without crashing, directly satisfying the requirement.

An API is the defined set of rules and protocols governing how one piece of software requests data from another. Here it governs the app's HTTP requests and the JSON responses returned by the weather service, enabling their interaction.

An integer stores whole numbers and supports arithmetic operations, so it can hold an age and allow adding five years. Ages are naturally whole values, making an integer a precise and efficient choice without unnecessary decimal precision. This matches the stated requirement to perform arithmetic on the stored value.

A record or struct groups related values under one name, with each field having its own type. This lets the product name, price, and quantity travel together as a single unit while preserving type safety. It directly matches the need to treat several differently typed, related values as one logical entity.

Scrum prescribes exactly these time-boxed ceremonies: sprint planning, daily standups, sprint review and retrospective, with a product owner prioritising the backlog and a scrum master facilitating. The stem's fixed two-week sprints and defined role separation satisfy Scrum's empirical, iterative structure rather than Kanban's continuous flow.

The service exposes HTTP endpoints returning JSON and authenticates via an API key header, which is characteristic of a REST API. This satisfies the stem's description of stateless HTTP requests with header-based authentication, distinguishing it from SOAP or GraphQL services.

Breakpoints pause execution at a chosen line, letting the developer inspect variables, call stack and memory state immediately before the crash occurs. This satisfies the scenario by catching the fault at its source rather than inferring it afterwards from logs alone.

A REST API exposes endpoints over HTTP that let separate software applications exchange data and invoke functionality using standard methods, decoupling client and server. This application-to-application communication is its defining purpose, not user interfaces or hardware control.

Scrum defines three accountabilities, and the Scrum Master is one: accountable for establishing Scrum as defined in the Scrum Guide, coaching the team and removing impediments. This satisfies the stem's requirement for a defined Scrum role, unlike titles such as project manager or product owner's proxy.

Rebasing or merging main into the feature branch resolves conflicts locally and verifies the feature still builds against current code. This satisfies the pre-merge requirement that integration issues surface before acceptance, rather than after the main branch is destabilised.

Iterative development with short cycles is a defining agile characteristic, delivering working software in frequent increments rather than one big-bang release. These short iterations enable continuous feedback, letting teams adapt to changing requirements throughout the project, which directly satisfies the agile emphasis on responding to change over following a rigid plan.

Waterfall's sequential phases — requirements, design, implementation, testing, deployment — each complete before the next begins, matching the fixed, clearly defined requirements. Iterative and agile methods assume evolving scope, so they contradict the linear, phase-gated constraint stated in the stem.

Testing is a core SDLC phase because it verifies that built software meets its requirements before release, satisfying the stem's demand for a genuine life-cycle stage. It occurs after implementation and before deployment, encompassing unit, integration, system and acceptance testing to detect defects and confirm quality.

Each recursive call pushes a new frame onto the call stack, holding parameters and local state. With a large input, the number of nested calls grows until the stack space is exhausted, producing a stack overflow. The base case is correct but is only reached after many calls, so the failure is caused by depth rather than by a missing termination condition.

System testing validates the complete, integrated application against requirements, and security testing examines authentication, authorisation, encryption and vulnerability handling across that whole system. It therefore belongs within end-to-end system testing rather than unit or component-level verification.

Step execution runs one line of code at a time, pausing after each statement so the developer can inspect variable values and control flow. This matches the scenario of stepping through code line by line during debugging.

Merging integrates commits from the feature branch into the main branch, preserving both histories through a merge commit or fast-forward. This directly satisfies the stem's requirement to combine completed feature changes back into main, unlike rebasing, which rewrites commits, or cherry-picking, which copies individual commits.

Waterfall suits fixed budget, fixed scope and stable, well-understood requirements, because its sequential phases lock design before build begins. Agile's iterative re-planning assumes changing requirements, which this project explicitly lacks, so Waterfall's upfront baselining matches the stated constraints.

A branch is an independent line of development that lets a developer make changes without affecting the main branch. After the work is complete, the branch can be reviewed and then merged into main. This matches the team's requirement to isolate feature work and to review changes before they become part of the stable codebase.

A branch is an independent line of development copied from the main codebase, letting the developer commit changes in isolation. Those commits are later merged back into the main branch, which is exactly the isolation-then-integration workflow described in the scenario.

In a distributed version control system, cloning a repository copies the complete history to the developer's machine. This allows commits, branching, and history inspection to happen locally without a network connection. It is a defining characteristic of distributed systems and supports the team's need to track changes independently before sharing them.

Agile delivers work in short, fixed-length iterations (typically one to four weeks), each producing a potentially shippable increment. This iterative cadence directly satisfies the stem's agile methodology constraint, enabling frequent inspection and adaptation rather than a single sequential delivery phase.

A loop is a control structure that repeats a block of code as long as a specified condition evaluates to true. In this scenario, the developer can place the password prompt inside the loop and use a condition such as 'password does not match' to keep asking until the correct value is entered, which is exactly the behavior required.

The statement total = total + item evaluates the right side first by adding the current value of total to item, then stores the result in total. This is a common accumulator pattern in pseudocode and programming, where a running total is updated each time the loop processes a new item from a collection or input stream.

New requirements are placed in the product backlog and addressed in future sprints.

Version control enables branching, so each developer can work on a separate feature branch and later merge changes. This isolates work and prevents one person's edits from overwriting another's, which is critical for parallel development. In a team setting, this collaborative capability is a primary reason to adopt version control.

Agile is an iterative approach that delivers working software in short cycles called iterations or sprints, with frequent customer feedback and adaptation to change. This aligns exactly with Model Y's description of short iterations and continuous feedback, making Agile the correct identification in this comparison.

Merge integrates the feature branch's commits into the main branch, combining divergent histories while preserving both lines of development. This is the operation that reunites the completed feature work with the mainline, satisfying the stem's requirement to combine changes.

This accurately describes a variable: a name that references a memory location whose contents can be read and updated as the program runs. For example, a variable can hold a running total that increases with each loop iteration. This definition matches the instructor's explanation that a variable stores a value under a name for later use.

A variable is a named storage location whose value can change during program execution. The hourly rate, hours worked, and gross pay can each be stored in a variable, and the gross pay variable can be updated after the multiplication. This directly matches the need for named locations that hold and update values during the calculation.

A dictionary stores data as unique keys mapped to values, giving direct lookup by key rather than by numeric index. This satisfies the stem's requirement for unique key-value pairs, unlike lists or arrays, which hold ordered elements accessed positionally and permit duplicate entries.

Stepping executes code one statement at a time, letting the developer follow the precise path taken toward the crash. This is a standard debugging technique because it exposes branching decisions and loops that static reading of the source cannot reliably reveal.

The Product Owner owns the product backlog, ordering items by business value so the team always delivers the highest-priority features first. This directly satisfies the stem's requirement for backlog prioritisation and value sequencing, a duty the Scrum Guide assigns solely to that accountability.

Branching creates a separate line of development from a point in the repository's history, allowing a developer to make changes without altering the main branch. This directly supports working on a feature in isolation and merging it back after review. It is the core version control mechanism for the isolation the team wants.

Waterfall matches the stem's fixed sequential phases, where each stage completes before the next begins and requirements freeze once design starts. Its linear, document-driven structure makes late requirement changes costly, satisfying the constraint that changes are difficult after a phase completes. Iterative and Agile approaches would instead accommodate evolving requirements.

A dictionary stores key-value pairs, mapping each student name directly to a grade. Hash-based lookup gives average constant-time access by name, satisfying the quick retrieval requirement that a list or array would only meet through linear searching.

Unit testing verifies individual functions or methods in isolation, typically by the developer, before integration. This matches the stem's scenario of checking single functions within a module independently, distinguishing it from integration testing, which exercises interactions between combined components.

Planning covers requirements gathering, scope definition and project plan creation, which the stem describes as the current work. Detailed requirements analysis belongs to the subsequent analysis phase, so the team has not yet entered it. This matches the SDLC sequence where planning precedes analysis.

A flowchart uses standardised symbols — diamonds for yes/no decisions and rectangles for processes — to visually map program logic and branching paths. This directly satisfies the stem's requirement to represent decisions and processes, unlike plain pseudocode or a written algorithm, which describe logic textually without symbolic visual structure.

API key authentication issues each third-party service a distinct key transmitted with every API request, letting the application validate the caller's identity before granting access. This directly satisfies the stem's requirement for a unique per-service credential included in each request, unlike token-based or certificate schemes.

Unit testing exercises individual functions in isolation, so writing those tests before implementation — test-driven development — forces developers to define expected behaviour up front. That early verification catches defects at the function level during the sprint, directly addressing the stem's constraint of bugs being discovered late in the development cycle.

Pseudocode expresses an algorithm's logic in structured plain English, free of any language's syntax rules, so it can be read and verified by anyone. This directly satisfies the stem's constraint: a step-by-step solution description written without language-specific syntax.

Regression testing re-runs previously passing test cases to confirm the bug fix has not broken existing functionality. It directly targets the stem's constraint of detecting newly introduced defects in features that worked before the change.

The pseudocode is a finite, ordered set of steps that compares each element against a running maximum and outputs the result, which is the definition of an algorithm: a step-by-step procedure solving a specific problem.

Validating each divisor before the division prevents the invalid operation while allowing the loop to continue processing the remaining values. Skipping or specially handling zeros keeps the running total meaningful for all non-zero entries. This directly satisfies both goals: no crash and correct results for valid data.

This correctly captures the difference. A syntax error breaks the rules of the language, such as a missing semicolon, and usually stops compilation or interpretation. A logic error means the code is grammatically valid and executes, but the algorithm or expression is wrong, producing an incorrect total. The scenario states the program runs but gives a wrong total, matching a logic error.

A stack removes the most recently pushed item first, so function calls unwind in reverse order of invocation. This LIFO behaviour satisfies the stem's requirement: the latest call must return before its caller resumes, which is exactly how nested function execution and recursion are managed.

A dictionary maps each unique student ID key directly to its value, giving average O(1) constant-time lookup by ID. It enforces key uniqueness automatically, satisfying the "unique student IDs" constraint, and imposes no ordering requirement, matching the stem's explicit statement that no particular order is needed.

Polymorphism allows different object types to be accessed through a shared interface or base type, with each type supplying its own implementation of the same method. This precisely matches the need for unrelated objects to respond to start and stop in their own ways while being handled uniformly by the calling code.

Object-oriented programming support lets developers model data and behavior together using classes, objects, inheritance, and encapsulation. The team explicitly wants strong built-in OOP support, so a language with first-class constructs for classes and objects is required. This characteristic is one of the two stated priorities in the scenario.

Scrum matches because it prescribes fixed-length sprints, a prioritised backlog, team estimation, daily standups and a sprint review demonstrating working software. These ceremonies and artefacts are Scrum's defining structure, satisfying the stem's two-week iteration, daily progress meetings and stakeholder demonstration constraints.

User acceptance testing is performed by end users, here accounting staff, to confirm the payroll system meets business requirements and is usable before go-live. This matches the stem's pre-deployment validation by the intended user group.

A finite, ordered set of steps that transforms input into output defines an algorithm. The described compare-swap-repeat procedure is precisely such a sequence, satisfying the stem's requirement for the term naming a step-by-step sorting procedure. Data structures, programs and pseudocode denote other concepts.

Agile delivers work in short iterations, releasing a minimal feature set early and adapting subsequent increments to user feedback. This directly satisfies the stem's requirement to ship quickly then evolve features, unlike waterfall's sequential, feedback-poor structure.

Regression testing re-executes existing test cases after code changes to confirm previously working functionality still behaves correctly. It directly targets the stem's goal of detecting unintended breakage introduced by the new website version, rather than validating new features or performance.

An API key is a unique identifier issued by the third-party service, embedded in the HTTP header to authenticate each request and track usage per consumer. It satisfies the stem's requirement for an identifier that both authenticates requests and monitors consumption, unlike OAuth tokens, which delegate scoped access rather than simply identifying the calling application.

A flowchart uses standardised symbols to depict decisions and loops as branching and repeating paths, making control flow visually explicit. This directly satisfies the need to represent program logic containing both conditional decisions and iterative loops.

A queue enforces first-in-first-out ordering: elements are appended at the rear and removed from the front, exactly matching the stem's requirement to add names at the end and remove them from the front. A stack would reverse this, removing the most recently added item instead.

Planning is the SDLC phase where business requirements are gathered, scope defined and the project plan produced, all before design or coding starts. It directly satisfies the stem's constraint that this work precedes any design or development activity, distinguishing it from analysis, design and implementation phases.

An integer stores whole numbers without decimal places, which perfectly matches an age value between 0 and 120. It supports arithmetic and comparison operations needed for validation, and it prevents fractional values that would be meaningless for age. This makes integer the most natural and appropriate data type for the described variable.

Unit testing exercises individual functions in isolation, verifying that each returns correct results for given inputs. This directly matches the stem's constraints: tests target single functions within a module and remain isolated from other system components, confirming correctness at the smallest testable unit before integration.

Encapsulation groups related logic behind a well-defined interface, so the tax calculation can change internally without affecting callers. The payroll code depends only on the module's inputs and outputs. This isolation means future rule changes require edits in one place, which directly supports the team's goal of minimizing ripple effects.

A dictionary stores key-value pairs and provides fast lookups by key, satisfying the second scenario's requirement. Unlike index-based structures, it maps unique keys directly to values, giving average constant-time retrieval. This makes it the appropriate choice for the key-value lookup requirement, while a list handles the ordered, index-accessed scenario.

Waterfall is sequential: requirements are fixed up front and each phase (requirements, design, development, testing, deployment) must finish before the next begins. This matches the fixed requirements and strict deadline described, unlike iterative or incremental approaches.

Automated builds on every commit are central to continuous integration. They verify that the newly committed code compiles and integrates with the rest of the codebase, catching integration errors while they are still small and easy to fix. This practice directly supports the goal of keeping the main branch healthy and releasable.

User acceptance testing has actual payroll employees validate the system against real business processes before deployment. This satisfies the stem's constraint that end users, not developers or QA staff, confirm the payroll system meets their needs and processes payroll correctly.

An algorithm is a finite, ordered set of steps that solves a problem. The developer's numbered plain-English list of getting hours, getting the rate, multiplying, and displaying the result describes exactly how the pay is computed. Writing this before code clarifies logic and is a fundamental software development concept tested on the exam.

A copyleft license such as the GNU General Public License allows anyone to view, modify, and redistribute the source code, but requires that derivative works be distributed under the same license terms. This matches the company's requirement that modifications remain open, making it the appropriate choice for an online store project with those sharing conditions.