CPSA-FL iSQI ISAQB Certified Professional for Software Architecture -Foundation Level Free Practice Exam Questions (2025 Updated)

Appropriate statements about crosscutting concepts in software architecture include:A. The definition of appropriate concepts ensures the conceptual integrity of the architecture. - Consistent use of concepts across an architecture ensures that the system is cohesive and maintains integrity.B. Concepts are a means to increase consistency. - By defining and following common patterns and strategies, consistency is achieved throughout the system.D. Uniform exception handling is most easily achieved when architects agree with developers upon a suitable concept prior to implementation. - Establishing a common approach to exception handling before development starts can ensure uniformity and reduce errors.G. A concept can define constraints for the implementation of many building blocks. - Concepts often set rules or guidelines that impact how multiple components or building blocks should be implemented, helping to maintain a unified approach to solving architectural problems.

These answers are derived from established principles and patterns in the field of software architecture, focusing on best practices and common methodologies.

The statements regarding the design principle ‘information hiding’ that are true and false are as follows:

True:

Adhering to the ‘information hiding’ principle increases flexibility for modifications (A).

Information hiding involves deliberately hiding information from callers or consumers of the building block (B).

In object-oriented development, information hiding is primarily relevant at class level (E).

False:

Information hiding makes it harder to distinguish between interface and implementation C.

Information hiding is a derivative of the approach of incremental refinement along the control flow (D).

The principle of ‘information hiding’ is a fundamental concept in software engineering that promotes encapsulation and abstraction. Here’s an explanation of each statement:

True Statements:

(A): Information hiding allows for changes in the implementation without affecting other parts of the system, thus increasing flexibility1.

(B): The core idea of information hiding is to keep the implementation details away from the users of the component, revealing only what is necessary2.

(E): In object-oriented programming, information hiding is typically applied at the class level, where internal data and methods are hidden from other classes3.

False Statements:

C: Information hiding does not make it harder to distinguish between interface and implementation; rather, it helps to clearly define the interface by hiding the implementation details1.

(D): Information hiding is not a derivative of incremental refinement along the control flow; it is a separate principle that focuses on hiding the internal complexities of a component4.

Information hiding is crucial for maintaining a clean and modular architecture, where components can be developed, maintained, and replaced independently.

References:

Stack Overflow discussion on Abstraction vs Information Hiding vs Encapsulation1.

Wikipedia article on Information Hiding2.

Kansas State University textbook excerpt on Information Hiding3.

Techopedia definition of Information Hiding4.

A) IncorrectB) CorrectC) IncorrectD) IncorrectE) Incorrect

In the context of building a tool chain for continuous architecture evaluation and analysis, the following statements can be assessed:

A) Tools for static code analysis do not find all dependencies in the source code. They can find many, but not necessarily all, especially if dynamic programming techniques are used1.

B) Several tools for static code analysis can be used to verify compliance with architectural rules. This is one of the primary uses of static code analysis tools1.

C) Tools for static code analysis cannot reliably measure cohesion because cohesion is a qualitative aspect of modules that depends on the context and design intent, which static analysis alone cannot fully capture1.

D) Tools for static code analysis are not typically used to optimize runtime efficiency. They are more focused on code quality, security, and compliance with coding standards1.

E) Tools for dynamic analysis, such as profilers, can be used to optimize static structures. They provide runtime information that can inform decisions about the static structure of the code1.

These assessments are based on the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL documents, which provide guidelines on the selection and use of tools for software architecture evaluation and analysis1.

The interpretations of Conway’s law that are true and false are as follows:

True:

Structures of software architecture and associated organization are congruent (B).

Software architecture is particularly important when creating compilers ©.

False:

You need four teams to build a compiler (A).

Certain types of software are not suitable for the use of software architecture (D).

Conway’s law suggests that the structure of systems designed by an organization will mimic the communication structures of that organization1. This means that the way teams are organized and communicate will influence the design of the software they are developing. Here’s an explanation of each interpretation:

True Statements:

(B): The law implies that the technical structure of a system will reflect the social boundaries of the organization that produced it, which means the architecture of the software and the organization will be congruent1.

©: When creating complex systems like compilers, the architecture is influenced by organizational structures, making it crucial to consider how teams are organized and how they communicate1.

False Statements:

(A): The number of teams does not dictate the necessity of a multi-pass compiler; it’s a metaphorical example to illustrate that organizational structure can influence technical design1.

(D): All types of software can benefit from thoughtful software architecture; the statement is a misinterpretation of Conway’s law, which does not deem any software unsuitable for architectural practices1.

Conway’s law is a valuable consideration in software engineering, reminding us that organizational decisions can have a significant impact on the design and functionality of the software.

References:

Wikipedia article on Conway’s law1.

ThinkingLabs article on Shades of Conway’s Law2.

Dovetail article on What Is Conway’s Law

For a building block, the characteristics visible only in the whitebox view are:

Code structure of the building block (D)

Algorithms used in the building block (E)

Implementation details for the security requirements of the building blocks (G)

The blackbox view suffices for:

Public interfaces of the building block (A)

Test coverage based on unit tests for sub building blocks contained in the building block (B)

Test coverage based on integration tests ©

Security requirements of the building blocks (F)

In software architecture, the whitebox view reveals the internal workings of a building block, including its code structure, algorithms, and specific implementation details1. This view is essential when the internal structure and behavior of the component need to be understood or modified.

On the other hand, the blackbox view treats the building block as an opaque entity, focusing on its exposed interfaces and observable behaviors without revealing its internal structure2. This view is sufficient for understanding what the building block does from an external perspective, such as its public interfaces and how well it performs its functions as determined by testing.

Here’s a breakdown of the characteristics:

Whitebox View:

Code Structure (D): This includes the organization of code within the building block, such as classes, interfaces, and other components.

Algorithms (E): The specific algorithms used within the building block to perform its functions.

Implementation Details for Security (G): The actual code and strategies used to fulfill the security requirements.

Blackbox View:

Public Interfaces (A): The interfaces that are exposed to other building blocks or systems.

Test Coverage for Sub Building Blocks (B): The extent to which the unit tests cover the sub-components within the building block.

Test Coverage for Integration Tests ©: The coverage of tests that verify the interactions between building blocks.

Security Requirements (F): The security objectives and criteria that the building block must meet.

References:

arc42 Documentation on Building Block View1.

Stack Overflow discussion on the difference between black box and white box in component diagrams2.

Flylib Section on Black-Box and White-Box Component Views3.

A) TrueB) FalseC) TrueD) FalseE) True

The building-block view, as per the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL, typically includes the following information:

A) Which building blocks the software is composed of: This is true. The building-block view shows the composition of software building blocks1.

B) How the building blocks interact during run time: This is false. The interaction during runtime is typically shown in the runtime view, not the building-block view1.

C) How the building blocks are hierarchically decomposed: This is true. The building-block view includes hierarchical decomposition of the software building blocks1.

D) How the building blocks are distributed in a distributed system: This is false. The distribution of building blocks in a distributed system is part of the deployment view1.

E) The dependencies between the building blocks: This is true. The building-block view should show the dependencies between the different building blocks1.

These aspects are essential for understanding the structure and organization of the software architecture and are aligned with the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL documents1.

A) BeneficialB) BeneficialC) Not BeneficialD) Not BeneficialE) Beneficial

In the context of documenting the software architecture for a large development project with multiple teams, the following measures can be considered beneficial:

A) Dividing the whole architecture documentation into sub-documents for each of the three sub-projects can be beneficial as it allows each team to focus on their specific area while maintaining a modular approach to documentation1.

B) Predefining the structure of the entire architecture documentation ensures consistency and coherence across all sub-projects. It helps in maintaining a uniform standard and facilitates easier integration of the sub-documents into the overall project documentation1.

C) Leaving the decision regarding the documentation structure to the team that first begins the documentation of its sub-project is not beneficial. This approach can lead to inconsistencies and may result in a lack of uniformity across the project’s documentation1.

D) Rejecting word processing for the documentation because it is not connected with the source code is not beneficial. While it is important to link documentation with the source code, word processing tools can still be used effectively for creating comprehensive documentation. Tools like version control can be used to maintain a connection between the documentation and the source code1.

E) Having developers document their parts of the architecture documentation using source code can be beneficial. This approach ensures that the documentation is close to the implementation and can be more easily kept up-to-date1.

These measures align with the best practices for software architecture documentation as per the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL documents, which emphasize the importance of clear, consistent, and coherent documentation in software architecture1.

The techniques best suited to illustrate the interaction of runtime building blocks are:A. Activity diagrams - Useful for showing the flow of control among various activities and decisions in the system.B. Sequence diagrams - Ideal for depicting the order of messages exchanged between components or objects in a specific scenario.C. State diagram - Shows how a component or an object changes its state in response to events, highlighting dynamic behavior.G. Depiction of screen flows (sequence of user interactions) - Useful for visualizing the sequence of user interactions with the system, which is critical for user-centric design and runtime behavior analysis.

A) FalseB) FalseC) TrueD) TrueE) TrueF) True

A) Agile approaches make written documentation unnecessary. In such cases, verbal communication can substitute for documentation.

False. Even in agile approaches, written documentation is important for maintaining a clear and consistent understanding of the architecture among team members and stakeholders1.

B) Written documentation makes verbal reiteration unnecessary.

False. Verbal communication is essential for clarifying and reinforcing the content of written documentation, especially when addressing complex or nuanced architectural issues2.

C) Despite written documentation, verbal communication of architectural interrelationships is important.

True. Verbal communication plays a crucial role in explaining the rationale behind architectural decisions and interrelationships that may not be fully captured in documentation2.

D) Documentation and communication should use identical terms and rationale.

True. Consistency in terminology and rationale between documentation and verbal communication helps prevent misunderstandings and ensures that all parties have a common understanding of the architecture2.

E) Documentation should be created primarily for project participants who either cannot or do not want to read the system’s source code.

True. Documentation serves as a guide for those who may not be directly involved in coding but need to understand the architecture, such as managers, new team members, or external stakeholders2.

F) Communication and documentation complement each other: verbal communication helps architects determine what must be recorded in writing.

True. Verbal communication often reveals what aspects of the architecture are most important or confusing to team members, guiding what should be emphasized in written documentation

When designing external interfaces, several considerations must be taken into account:A. Volatility of neighbouring systems - Changes in neighboring systems can affect the stability and compatibility of interfaces, requiring interfaces to be adaptable to changes.C. Protocols enforced by neighbouring systems - It's crucial to align with the protocols used by neighboring systems to ensure seamless communication and interoperability.D. Expected amount of parallel calls - This affects the scalability and performance requirements of the interface, as it must be designed to handle the expected load efficiently.

A) TrueB) TrueC) TrueD) TrueE) TrueF) TrueG) True

When choosing a software-architecture modeling tool, several factors can play a role:

A) Multi-user capability is important for collaborative environments where multiple architects work on the same model simultaneously1.

B) Support of UML 2.x and SysML ensures that the tool can handle widely-used modeling languages for software and systems engineering1.

C) Document generation is a key feature that allows for the automatic creation of documentation from the model1.

D) Support of model transformations in preparation of the code generation indicates the tool’s ability to convert models into other forms or even into executable code1.

E) Support of code generation can significantly speed up the development process by generating code from the models1.

F) Compliance with standards ensures that the tool adheres to industry standards, which can be crucial for interoperability and future-proofing1.

G) Purchase and licensing costs are practical considerations that affect the total cost of ownership of the tool1.

These criteria are aligned with the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL documents, which emphasize the importance of these factors in the selection of a software-architecture modeling tool1.