iSQI CPSA-FL ISAQB Certified Professional for Software Architecture -Foundation Level Exam Practice Test

The most accurate statements about quality characteristics are:B. Increased flexibility improves robustness - Flexibility in design allows the system to handle and recover from errors and unexpected inputs more robustly.C. Simplicity increases comprehensibility - A simpler design is easier to understand, maintain, and less prone to errors, directly impacting the comprehensibility of the software.

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:
• Blackbox View:

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) 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.

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

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.

In the context of software architecture, certain elements serve as building blocks to structure and organize software systems effectively.

• A: An algorithm is a sequence of steps designed to perform a specific task and can be a critical part of system logic and functionality.
• B: A component is a modular part of a system that encapsulates its contents and whose deployment and versioning can be managed independently.
• D: A class in object-oriented programming encapsulates data for the object and operations that manipulate that data, serving as a blueprint within the architecture.
• H: A package helps organize classes and interfaces that are related functionally, promoting a cleaner and more manageable architecture structure.

A) TrueB) FalseC) TrueD) True

A) The project plan from management is influenced by architectural decisions.

• True. Architectural decisions often have significant implications on the project plan, including timelines, resource allocation, and technical approaches1.

B) Cost estimates are primarily the responsibility of the architect.

• False. While architects may contribute to cost estimates, especially regarding design-related expenses, it is typically the management’s responsibility to oversee and finalize cost estimates for the entire project2.

C) Architects advise project management on the definition of work packages.

• True. Architects play a crucial role in defining work packages, particularly in ensuring that the technical aspects of the project are accurately captured and planned for1.

D) Management and architects cooperate on handling of technical risks.

• True. Both management and architects need to work closely to identify, assess, and manage technical risks throughout the project2.

To demonstrate the suitability of building blocks for implementing a use-case scenario effectively, UML (Unified Modeling Language) diagrams are instrumental. Among the options:

• B: Sequence diagram is the most suitable choice because it shows how objects interact in a particular scenario of a use case, detailing the sequence of messages exchanged between objects to accomplish the functionality described in the use case. This makes it ideal for demonstrating the dynamic behavior of the system components in the scenario.

References:

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 Architecture Tradeoff Analysis Method (ATAM) helps evaluate architecture decisions with respect to quality attributes by producing several key artifacts:

• B: The concrete quality tree illustrates and organizes the quality attributes specific to the architecture being evaluated, showing how generic quality attributes are refined into measurable scenarios.
• C: Description of quality scenarios specifies and documents the scenarios under which the architecture's responses are tested against the desired quality attributes.
• G: List of the architectural risks identifies potential risks in the architecture that may threaten the system’s ability to meet its quality goals, aiding in proactive risk management.

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.

The term 'coupling' in software architecture refers to the degree of direct knowledge that one component has about another. This can be reflected in:A. A building block uses an interface of another building block. - This represents a form of coupling where components interact through well-defined interfaces, influencing the level of dependency between them.D. A building block uses internal data structures of another building block. - This indicates a higher degree of coupling, as it involves direct knowledge of another component’s internal workings, which is generally discouraged to maintain modularity and ease of maintenance.

These answers are based on fundamental software architecture and design principles widely recognized in the field.