CCNA Software Development and Design Questions

Event-driven architecture decouples producers from consumers via a broker, so services publish events without waiting for responses. This asynchronous, non-blocking exchange satisfies the decoupling requirement, unlike synchronous request-response patterns such as REST or gRPC that couple caller and callee.

Accessing a missing key in a dictionary raises KeyError, because Python's dict lookup requires the key to exist. The code requests 'b' from a dict containing only 'a', so the lookup fails immediately and KeyError propagates.

Tenacity is a general-purpose retrying library that provides a decorator and can be configured to retry based on exceptions, including custom conditions. It supports retrying on specific HTTP status codes when integrated with requests, and can be set to stop after a number of attempts. It is widely used in network automation for robust API interactions.

The `timeout` parameter sets a per-request maximum wait in seconds, satisfying requirement (1) for a variable timeout on each sequential call. Passing a distinct value to each `requests.get()` or `requests.post()` invocation prevents a slow endpoint from blocking the script indefinitely.

The double-asterisk prefix collects arbitrary keyword arguments into a dictionary, letting the function accept any number of named parameters. A single asterisk would instead gather positional arguments into a tuple, so **kwargs is the syntax that satisfies the variable keyword argument requirement.

ConnectionError is raised when the request cannot reach the server at all, such as DNS failure or refused connection. Catching it handles the transport-level failures the stem's HTTP request function will encounter before any response is received.

Using `response.raise_for_status()` converts 4xx and 5xx HTTP status codes into `HTTPError` exceptions, satisfying the stem's requirement to handle API errors gracefully rather than silently processing failed responses. This lets the script catch failures explicitly instead of parsing error payloads as valid JSON data.

Testing invalid input ensures that the function handles errors gracefully, such as raising appropriate exceptions or returning meaningful error messages. This is a key aspect of robust unit testing, as it validates the function's behavior under unexpected conditions and helps prevent crashes in production.

git checkout with a branch name switches HEAD to that existing branch and updates the working directory to match its committed tree, satisfying the stem's requirement to both switch branches and refresh files. git branch alone only lists or creates branches without changing the working directory.

HTTP 201 Created is returned when a POST request results in a new resource being created on the server, typically accompanied by a Location header identifying the new resource's URI. It precisely signals successful creation, unlike 200 OK, which merely indicates general success.

range(len(my_list)) yields indices 0, 1 and 2. Each iteration increments the element at that index in place via +=, transforming [1, 2, 3] into [2, 3, 4]. The list is mutated directly, so print outputs the updated values.

Microservices decompose functionality into independently deployable units that interact over network calls rather than in-process method invocation. Using lightweight protocols such as HTTP/REST lets each service expose a language-agnostic interface, satisfying the loose-coupling and independent-scalability constraint that monolithic architectures cannot meet.

429 Too Many Requests directly signals that the client has exceeded the API's rate limit, satisfying the stem's throttling constraint. Unlike 503, which indicates server unavailability, 429 specifically communicates quota exhaustion and typically accompanies a Retry-After header, letting clients back off and retry after the specified interval.

GraphQL queries declare precisely the fields required, so the server returns only those fields, eliminating the over-fetching inherent in REST's fixed resource representations. This satisfies the microservice's need to minimise payload size when calling the GraphQL API.

The signature `def fetch_devices(*endpoints, **options)` satisfies both stem constraints: `*endpoints` collects positional API endpoint arguments into a tuple, while `**options` gathers keyword arguments such as `timeout` into a dictionary. This is the only syntax Python permits for combining arbitrary positional and keyword parameters in one definition.

The code parses the JSON file into a Python dictionary, then indexes the `interfaces` list to retrieve its first element and reads that dictionary's `name` key. Given the supplied file content, this resolves to the string `GigabitEthernet0/1`, which `print` outputs without quotes.

git checkout -b <branch> creates the new branch at the current HEAD and immediately switches the working tree to it, combining creation and checkout. This single-step behaviour matches the stem's requirement, unlike git branch alone, which only creates.

HTTP 204 No Content confirms the server processed the PUT successfully but returns no body, matching the stem's update scenario. It differs from 200, which carries a response body, and from 404, which signals the resource was not found.

Feature branches isolate new work from the mainline, so unfinished or experimental changes never destabilise shared code. This satisfies the stem's collaborative best-practice requirement by enabling independent development and clean pull requests before merging into the shared branch.

json.loads parses the string into a dictionary, then ['scores'] retrieves the list and [1] indexes its second element, which is 85. Python lists are zero-indexed, so index 1 satisfies the stem's requirement of extracting the second score rather than the first.

The `*args` parameter collects the positional arguments 1, 2 and 3 into a tuple, which `sum()` totals to 6. The `**kwargs` parameter collects `offset=10` into a dictionary, and `kwargs.get('offset', 0)` retrieves 10. Adding 6 and 10 returns 16.

201 Created is returned when a POST request results in a new resource being created on the server, typically accompanied by a Location header identifying its URI. Other 2xx codes, such as 200 OK, indicate success without confirming resource creation.

This is correct because git stash saves the current working directory and index state, reverting the working directory to match the HEAD commit. It allows the developer to switch branches without committing unfinished work. Later, git stash pop or git stash apply can restore the changes. This command is specifically designed for temporarily shelving changes.

A for loop iterates directly over the hostnames list, binding each element to the loop variable in turn, which is the idiomatic structure for processing every item in a sequence. It satisfies the requirement to process each hostname without manual index management.

git rebase main replays the commits from the current feature branch on top of the latest main, resulting in a linear history without a merge commit. This is the standard way to incorporate upstream changes while keeping a clean, linear commit sequence. It rewrites the feature branch commits, which is acceptable for local branches that have not been shared.

PATCH applies a partial modification to an existing resource, sending only the changed fields. It satisfies the constraint of updating a device's configuration partially, whereas PUT would replace the entire representation and require the full payload.

json.loads() deserialises a JSON-formatted string into a Python dictionary, satisfying the stem's requirement to parse an incoming REST API string. Its counterpart json.load() reads from a file object instead, so it would not work on the raw string the developer receives.

This implementation checks the input with isinstance against list and raises TypeError when the check fails, then builds the required dictionary with a comprehension. It satisfies both stated requirements: type validation that raises TypeError and a mapping of each interface name to its character length.

unittest.mock is part of the Python standard library and provides a flexible framework for mocking objects and functions in unit tests. It allows patching requests.get with a mock object that returns a predefined response, eliminating network calls. The patch decorator or context manager can temporarily replace the function during the test. This is the standard approach for mocking in Python.

Running merge with the feature branch checked out integrates the commits from main into the current branch and leaves the feature branch history intact. Conflicts are surfaced in the working tree for the developer to resolve and commit, and the pull request then reflects the merged state. This is the standard way to incorporate upstream changes before review.

HTTP 429 signals rate limiting, and the Retry-After header specifies how long to wait before retrying. Honouring that value respects the server's throttling window, satisfying the stem's requirement to handle the error appropriately rather than retrying immediately or abandoning the request.

The asterisk before the parameter name collects all positional arguments into a tuple named interfaces. This allows the function to accept any number of interface names, including zero, and directly returns them as a tuple when referenced. This matches the scenario's requirement for arbitrary positional arguments.

requests.exceptions.ConnectionError is raised when the underlying connection cannot be established, covering DNS resolution failures and refused connections. Catching it satisfies the requirement to handle network connectivity issues, unlike HTTPError, which signals a received error response.

Git Flow uses a long-lived develop branch as the integration branch where feature branches are merged, and a main branch that holds released code. This directly matches the requirement that features be isolated and then merged into a shared integration branch before release, making it the correct branching strategy here.

Each microservice runs as a separate deployable unit, so teams can release and scale it independently without rebuilding the whole application. A monolith must be deployed and scaled as one artefact, which is the constraint this advantage directly addresses.

Pinning exact versions with == ensures that every environment installs the same package versions, preventing unexpected behavior from newer releases. This is a cornerstone of reproducible builds. When combined with a virtual environment, it guarantees that the dependencies resolved during development match those in testing and production, which is essential for collaborative projects and consistent API interactions.

The json module's load() function reads a file object and deserializes JSON data into a Python dictionary. This directly allows access to the 'username' key. It is the standard, correct approach for parsing a JSON file in Python, handling the conversion from JSON text to native Python objects seamlessly.

Twelve-factor apps store configuration in the environment, so reading the token from an environment variable lets the same artifact run in lab and production with different values. This removes secrets from source code and enables per-environment configuration without rebuilding or editing files, satisfying the stated requirement.

MVC directly satisfies the stem's three-component split: the Model handles data and business rules, the View renders the UI, and the Controller processes input and mediates between them. This separation of concerns is precisely the interconnected Model-View-Controller architecture the question describes.

HTTP 429 signals rate limiting, so retrying immediately would worsen the condition. Exponential backoff progressively increases the delay between retries, satisfying the stem's best-practice requirement by giving the server time to recover while respecting its rate limits.

Exponential backoff increases the delay between retries, reducing load on the API. Respecting the Retry-After header ensures compliance with the API's rate limit policy. This approach is standard for handling 429 errors and improves the chances of eventual success without causing further throttling. It is both polite and effective.

PATCH applies a partial modification, changing only the fields included in the request body while leaving all other resource properties untouched. This directly satisfies the stem's requirement for a partial update, unlike PUT, which replaces the entire resource representation and would overwrite unspecified fields with defaults or nulls.

This is correct because requests.get() returns a Response object, and calling .json() on it parses the JSON body into Python data structures. If the payload has a top-level key 'interfaces' containing a list of dictionaries, indexing with ['interfaces'] and iterating yields each interface dict, from which ['name'] extracts the desired field.

Mocking external HTTP requests prevents tests from depending on network availability or API rate limits. It allows you to simulate various responses, including errors, and ensures tests run quickly and deterministically. This isolation is crucial for reliable unit tests, as it removes external dependencies and focuses on the function's logic.

GitFlow defines a long-lived develop branch that accumulates merged feature branches, with release branches cut from develop for stabilisation before merging into main. This matches the stem's described structure precisely, unlike trunk-based or GitHub Flow.

A config file excluded by .gitignore is never committed, so the secret does not enter the repository history. Each environment supplies its own file, and the parsing code can be committed safely because it contains no secret values, satisfying the requirement while remaining convenient for other teams.

Rebasing a feature branch onto the main branch rewrites the feature branch's commits to apply on top of the latest main, resulting in a linear history when merged. This avoids merge commits and keeps the commit graph clean. It is a common practice in teams that prefer a linear history, though it should be used with caution on shared branches.

Reading credentials from environment variables keeps secrets out of the codebase entirely. The script can access them at runtime without any sensitive values being stored in Git. This complements .gitignore by removing the need to commit credentials at all, satisfying the team's requirement to protect sensitive information.

A range that permits newer 2.x releases while excluding 3.0 lets the consuming team install its required minor version and still blocks a breaking major upgrade. This resolves the resolver conflict without abandoning protection against incompatible changes, which is exactly the balance the scenario demands.

The --oneline flag condenses each commit to its abbreviated SHA-1 hash followed by the commit subject, printing one commit per line. This satisfies the requirement for a compact summary rather than the default multi-line format showing author, date and full message.

Patching the file read isolates the unit test from the actual filesystem, making tests fast, deterministic, and independent of external state. It allows the developer to supply controlled input strings that exercise specific parsing logic without creating real files, which is a core technique for reliable unit testing.

json.loads() raises json.JSONDecodeError for malformed input, and empty strings also trigger this exception. Catching it inside the function localizes the failure, allowing the function to return a safe default or a meaningful custom exception. This keeps the calling script stable and provides a clean contract for callers, directly meeting the graceful-handling requirement.

Pinning the base image by digest and locking dependency versions ensures every build resolves to the same layers and packages, so the image produced on a laptop matches the one built in CI. Without pinning, a silently updated base image or library can change behavior between environments, undermining reproducibility and making failures hard to trace.

The with statement opens config.json in read mode and guarantees closure via context-manager protocol, even if an exception occurs. This satisfies the stem's requirement that the file is closed after use, unlike manual open calls lacking explicit close.

The comprehension iterates x over range(11), covering 0 to 10 inclusive, and the filter x % 2 == 0 admits only even values before squaring with x**2. This satisfies both constraints in the stem: the even-number condition and the 0-to-10 bounds, producing 0, 4, 16, 36, 64, 100.

Passing json=payload serialises the dict and sets Content-Type to application/json automatically, while the headers dict supplies the Bearer token in the Authorization header. This satisfies both the JSON body and authenticated POST requirements in one call.

This command creates a new branch named feature/new-feature and immediately switches to it, giving the developer an isolated workspace. Subsequent commits land on that branch and can later be submitted as a pull request, matching the team's workflow.

The comprehension filters with `hostname.startswith('web')`, returning only matching elements while preserving the original list's order. The `if` clause sits after the iteration expression, so each hostname is tested before inclusion — satisfying the stem's requirement to produce a new list containing solely hostnames beginning with 'web'.

Environment variables keep secrets out of source control and let the same build artifact run in lab and production by injecting different values at deploy time. Python accesses them through os.environ or os.getenv, so no code change is needed between environments. This directly satisfies the goal of avoiding hard-coded credentials while keeping a single artifact.

Feature branching isolates work for a single feature or task on a dedicated branch, keeping the mainline stable until the work is merged. This is a recognised Git workflow pattern, satisfying the question's requirement for a valid branching strategy.

Using a function that contains the yield keyword makes it a generator. When called, it returns a generator object that produces values lazily, one at a time, without building the full list in memory. This is ideal for large datasets and matches the requirement to process hostnames sequentially while keeping memory usage low.

Event-driven architecture decouples producers from consumers: the discovery service publishes a device-discovered event to a broker, and inventory, monitoring and logging services subscribe independently, each reacting asynchronously without the publisher waiting. This satisfies the stem's requirement that multiple services be notified asynchronously, and lets new subscribers be added without modifying the discovery service.

GraphQL exposes one URL, usually `/graphql`, over which clients POST queries, mutations and subscriptions. This satisfies the stem's comparison with REST, where each resource maps to its own endpoint. A single endpoint lets clients request exactly the fields they need, avoiding REST's multiple round trips and over-fetching.

The factory method pattern defines an interface for creating objects, allowing subclasses to decide which concrete parser to instantiate. The client code depends only on the abstract parser interface, so new formats can be added by creating new factory subclasses without modifying existing client code, directly supporting extensibility and decoupling.

json.loads() deserializes a JSON-formatted string into Python objects, mapping JSON objects to dicts and JSON arrays to lists. That gives the function native structures it can iterate directly, which is precisely the conversion described in the scenario.

A return statement hands the parsed object back to the calling code, which can then store, transform, or assert on it. Printing only writes to standard output and leaves the caller with None, so callers cannot process the data further, which is exactly what the scenario requires.

json.load() deserialises a file object directly into Python dictionaries and lists, recursively handling nested objects. Reading with open() in text mode supplies the required stream, satisfying the stem's nested-JSON parsing requirement without manual string handling.

A `set` stores an unordered collection of unique elements, automatically discarding duplicates on insertion. This directly satisfies the stem's two constraints: no defined ordering, and uniqueness of members. Hash-based storage gives average O(1) membership testing, unlike lists or tuples, which permit duplicates and preserve insertion order.

Prefixing a parameter with an asterisk, as in *args, collects any number of extra positional arguments into a tuple named args. This is Python's defined syntax for variadic positional parameters, distinct from **kwargs, which gathers keyword arguments into a dictionary.

Splitting the monolithic function along its distinct responsibilities yields smaller units that can be unit tested in isolation and reused by other callers. This directly supports testability and reuse, which are the stated goals, without changing the external behavior of the module.

The json= parameter serialises the Python dictionary to JSON and sets the Content-Type header to application/json automatically, placing the payload in the request body. Passing data= would form-encode it instead, so json= satisfies the JSON body requirement.

201 Created signals that the POST succeeded and a new resource now exists, satisfying the stem's requirement for a creation-specific response. Unlike 200 OK, which merely confirms general success, 201 explicitly reports resource creation and typically returns a Location header pointing to the new resource's URI.

A list comprehension with a conditional filter, such as [d['hostname'] for d in devices if d['ip'].startswith('10.')], directly produces the desired list in one readable expression. It iterates over the devices, applies the condition, and collects only the matching hostnames, avoiding the need for an explicit loop and append calls.

The -b flag instructs git checkout to create the named branch before switching to it, combining branch creation and checkout in a single command. Without -b, checkout only switches to an existing branch, so this satisfies the one-step requirement in the stem.

git stash temporarily shelves changes in the working directory, allowing the developer to switch branches without committing. After fixing the bug, git stash pop or git stash apply restores the changes. This is the standard way to handle unfinished work when an urgent branch switch is needed.