CPSA-FL ISAQB Certified Professional for Software Architecture -Foundation Level Questions and Answers

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

As an architect, you can specify the following characteristics of a black-box building block:

• Compliance with functional requirements (A)
• Compliance with non-functional requirements (B)
• Purpose and/or responsibility (D)
• Method signature of public interfaces (E)
• Data formats of public interfaces (F)

In software architecture, a black-box building block is a component whose internal structure is not exposed to or understood by other components. It is defined only by its provided functionality and the services it offers. Here’s a detailed explanation of each characteristic:

• Compliance with Functional Requirements (A): This refers to the ability of the building block to perform the functions it was designed to do, which are often captured in a functional specification document.
• Compliance with Non-functional Requirements (B): These are criteria that can be used to judge the operation of a system, rather than specific behaviors. This includes requirements related to scalability, performance, security, and reliability.
• Purpose and/or Responsibility (D): This defines the role the building block plays in the overall system architecture, including its responsibilities and the services it provides.
• Method Signature of Public Interfaces (E): The method signature defines the interface that other components can use to interact with the building block. It includes the method name, parameters, and return type.
• Data Formats of Public Interfaces (F): This specifies the format and structure of the data that is accepted or returned by the building block’s public interfaces.

These characteristics are essential for ensuring that the building block can be effectively integrated into a larger system and interact with other components as expected.

References:

• Bass, L., Clements, P., & Kazman, R. (2012). Software Architecture in Practice (3rd ed.). Addison-Wesley Professional.
• Martin, R. C. (2003). Agile Software Development: Principles, Patterns, and Practices. Prentice Hall.
• Fowler, M. (2002). Patterns of Enterprise Application Architecture. Addison-Wesley.

To evaluate the reliability of a software system effectively, two methods stand out:B. Measurement of ‘Mean-Time-between-Failure’ (MTBF) - This is a standard measure of system reliability and is crucial for determining the average time between failures, helping to predict system reliability over time.E. Conducting an ATAM evaluation - Architecture Tradeoff Analysis Method (ATAM) provides a structured approach for evaluating decisions involving high-stake tradeoffs in software architectures, particularly affecting reliability among other quality attributes.

Considering that the requirements are still being determined, designing components with specific attributes can ensure adaptability and maintainability of the architecture.

• B: Weak coupling makes individual components less dependent on each other, enhancing the flexibility and scalability of the system.
• C: Strong cohesion ensures that components are designed with a clear purpose and functionality, improving the system's integrity and ease of maintenance.
• D: Making components open for extension but closed for modification supports the adaptability of the system to changing requirements without disrupting existing functionality.

A) CorrectB) IncorrectC) CorrectD) CorrectE) IncorrectF) Incorrect

The concept of coupling between building blocks is crucial in software architecture, and the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL provides guidance on this topic. Here’s an analysis of the statements based on the curriculum:

A) A high degree of coupling of a building block reduces its reusability: This is correct. High coupling means that a building block is heavily dependent on other components, which can limit its ability to be reused in different contexts1.

B) Low coupling of a building block improves the ability to meet functional requirements: This statement is incorrect. While low coupling can contribute to a more maintainable and flexible architecture, it does not directly improve the ability to meet functional requirements1.

C) Low cohesion often leads to high coupling: This is correct. Cohesion refers to how closely related the responsibilities of a module are. Low cohesion can result in modules that perform a wide range of actions, which often leads to higher coupling with many other modules1.

D) Loose coupling often leads to less effort for making changes: This is correct. Loose coupling allows for easier modification of a system with minimal impact on other components, thus reducing the effort required for changes1.

E) For call dependencies, the degree of coupling is independent of the direction of the call: This statement is incorrect. The degree of coupling can be affected by the direction of the call, as it determines which module controls the interaction1.

F) In object-oriented programming languages, inheritance reduces coupling: This statement is incorrect. Inheritance can actually increase coupling because it creates a direct dependency between the superclass and the subclass1.

These insights are aligned with the principles outlined in the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL curriculum, which emphasizes the importance of understanding and managing coupling for effective software architecture design1.

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.

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.

Designing effective interfaces is critical in software architecture, ensuring that they are both usable and robust. The characteristics that generally make interfaces more desirable include:

• A: Easy to extend - An interface should be designed such that it can be extended without breaking existing implementations. This characteristic is important for maintaining backward compatibility while allowing for future growth and changes in requirements.
• C: Clear descriptions of assertions and prerequisites - Interfaces should clearly specify what is required of the caller (prerequisites) and what the interface guarantees in return (assertions). This clarity is vital for ensuring that the interface is used correctly.
• G: Hard to misuse - An interface should be designed in such a way that there is little room for incorrect usage by the client. This involves making the interface intuitive and minimizing the potential for errors, which improves the robustness and reliability of the software system.

These characteristics help in creating interfaces that are not only functional but also robust, maintainable, and adaptable to future needs, aligning with best practices in software architecture.

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.