iSQI CPSA-FL Practice Test Questions Answers

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.

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