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

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.

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.

A) Not AppropriateB) AppropriateC) Not Appropriate

For a project involving multiple architects and developers, achieving consistent and adequate documentation is crucial. Here’s how the methods listed would fare:

A) The chief architect creates the documentation: This method is not appropriate because it places the entire burden of documentation on a single individual, which can lead to bottlenecks and may not accurately reflect the contributions and insights of the entire team1.

B) Identical templates are used for the documentation: This is an appropriate method as it ensures consistency across the documentation produced by different team members. Using identical templates helps maintain a uniform structure and style, which is beneficial for readability and maintenance1.

C) All parts of the architecture documentation are automatically extracted from the source code: Relying solely on automatic extraction is not appropriate because it may not capture all the necessary details and decisions made during the architectural design process. Manual documentation is also important to provide context and rationale that cannot be automatically generated1.

These methods are in line with the iSAQB® SOFTWARE ARCHITECTURE – FOUNDATION LEVEL, which emphasizes the importance of clear, consistent, and comprehensive documentation practices1.

A) TrueB) TrueC) FalseD) TrueE) TrueF) True

A) Top-down and bottom-up design may be employed in the same project.

• Top-down and bottom-up are two approaches to the design of software architecture. In top-down, the high-level design is created first, focusing on general functionalities and structure. In contrast, bottom-up starts with detailed designs focusing on a component or module level.

Documenting the right views in software architecture is crucial for addressing different stakeholder concerns and ensuring the architecture is comprehensible and manageable.

• A: Deployment view illustrates the physical deployment of software on hardware and is essential for understanding how different parts of the system are distributed across platforms and environments.
• C: Runtime view shows how various components of the system interact at runtime, which is vital for understanding system behavior and performance under different operational conditions.
• H: Building-block view (also known as the module view) describes the static organization of the software in modules or components, including their responsibilities and relationships. This view is foundational for developers and maintainers.

References:

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) 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 white-box view of a software building block provides an in-depth perspective on the internal structure and behavior of the building block.

• A: The dependencies of the internal building blocks of 'foo' are crucial for understanding how changes in one part affect others and for managing future modifications.
• C: The algorithms of the internal building blocks of 'foo' give insight into the logic and operations performed within the block, which is essential for performance analysis and optimization.
• D: The internal building blocks of 'foo' describe the finer-grained components or modules within 'foo', detailing their responsibilities and interactions, fundamental for detailed design and implementation.

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.

The purpose of defining the system context includes:

• To illustrate the system’s interfaces with external systems (B) - True
• To clarify the area of responsibility of the software architect C - True
• To represent the external systems (D) - True
• To distinguish between infrastructure and application (E) - True
• To distinguish between the hardware and software of a solution (F) - True

Defining the system context is a crucial step in software architecture as it helps to establish the boundaries and interactions of a system within its environment. Here’s a detailed explanation of the purposes:

• To Illustrate the System’s Interfaces with External Systems (B): It is essential to understand how the system interacts with other systems, which can influence requirements and design1.
• To Clarify the Area of Responsibility of the Software Architect ©: By defining the system context, the architect’s responsibilities regarding the system’s interactions and boundaries are made clear1.
• To Represent the External Systems (D): The system context helps identify and represent all external entities that interact with the system, which is important for comprehensive design and analysis1.
• To Distinguish Between Infrastructure and Application (E): Understanding the system context allows for a clear distinction between the infrastructure (the environment in which the application operates) and the application itself1.
• To Distinguish Between the Hardware and Software of a Solution (F): The system context helps to differentiate between the hardware components and the software components of a system, which is vital for system integration and deployment1.

These aspects of the system context are fundamental for ensuring that the system is designed and developed to meet its intended goals and operate effectively within its designated environment.

References:

• Smartpedia article on System Context1.
• Visual Paradigm Blog on System Context Diagrams2.
• microTOOL article on System Context3.

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

• True:
• False:

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:
• False Statements:

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