Free CPSA-F sample questions

Correct answer: True

This statement is true. A core advantage of the Pipes and Filters pattern is the decoupling of individual processing steps (filters). Because each filter only depends on the input data format and produces an output in the agreed-upon format, they can be developed, deployed, and tested independently, which enhances modularity and maintainability.

Correct answer: Open/Closed Principle (OCP)

The Open/Closed Principle states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This directly addresses the requirement to add new functionality without changing the existing, core code, thus avoiding complex conditional logic. Patterns like Strategy or Decorator are common implementations of OCP.

Correct answer: Dependency Inversion Principle (DIP)

The Dependency Inversion Principle states that high-level modules should not depend on low-level modules; both should depend on abstractions. By changing `UserService` (high-level) to depend on `ILogger` (abstraction) instead of `PostgreSQL_Logger` (low-level), the architect is directly applying DIP. This decouples the services from the concrete logging implementation, making the system more flexible and easier to test.

Correct answer: Context View

The Context View is specifically designed to show the system as a 'black box' within its environment. It focuses on defining the system's scope and its relationships with external actors and systems, making it the ideal view for providing a high-level overview to a broad audience without delving into internal implementation details.

Correct answers: The context explaining the problem or forces driving the decision.; The consequences of the decision, both positive and negative.

A well-formed ADR must capture the 'why' behind a decision. This includes the 'Context' (the problem, constraints, and requirements) and the 'Consequences' (the resulting trade-offs, benefits, and drawbacks). This information is crucial for future architects and developers to understand the rationale and avoid re-litigating past decisions. Implementation code and developer names are not core components of an ADR's purpose.

Correct answer: A set of quality scenarios describing potential future changes to the system.

Qualitative analysis, especially for a quality like modifiability, relies on structured reasoning rather than purely quantitative metrics. Quality scenarios provide concrete, hypothetical changes (e.g., 'A change to the tax calculation algorithm should be deployable within one day and affect only one component'). Analyzing the architecture's ability to handle these scenarios is a primary method for assessing modifiability. Server logs relate to performance, and support tickets relate more to usability or reliability.

Correct answer: Architectural goals often have a longer-term focus, while project goals are typically tied to more immediate constraints like time and budget, creating potential for conflict and requiring negotiation.

Architectural goals (the 'ilities' like scalability, maintainability) focus on the long-term health and viability of the system. Project goals (time, scope, budget) are often short-term and tactical. A key responsibility of an architect is to manage the tension between these two. For instance, achieving high scalability might require more time, directly conflicting with an aggressive launch date. This necessitates trade-offs and clear communication with stakeholders.

Correct answer: Pipes and Filters

The Pipes and Filters pattern is ideal for processing streams of data where the processing can be broken down into a series of sequential, independent steps (filters). The data flows through channels (pipes). This pattern provides excellent decoupling between the steps, meeting the architect's requirement to reorder or replace them easily. MVC is for UI, Broker is for distributed component communication, and Layered is for separation of concerns in a more general application structure.

Correct answer: To create a stable contract that allows the implementation of a block to change without affecting its consumers.

An interface serves as a formal contract between a service provider (the building block) and its consumers. By programming to this stable contract, consumers are decoupled from the provider's internal implementation. This allows the implementation to be modified, fixed, or even completely replaced as long as it continues to honor the interface contract, which is a cornerstone of maintainability and loose coupling.

Correct answer: Content/Pathological coupling; any change to the `Orders` database schema will likely break the `Reporting` module.

This is a form of very tight coupling, often called content coupling or pathological coupling, where one module depends on the internal implementation details (the database schema) of another. This breaks the principle of encapsulation. The primary drawback is that the `Orders` team cannot refactor or change its database schema without coordinating with and potentially breaking the `Reporting` module, which severely hinders independent evolution and maintainability.