The ISAQB Certified Professional for Software Architecture -Foundation Level (CPSA-FL)

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.

The correct statements about data structures, specifically stacks, are: A. The push operation usually places a new element onto a stack. - This is the basic operation of a stack data structure, where elements are added to the top of the stack. D. A stack usually only provides access to one element at a time. - In stack terminology, this is known as LIFO (Last In, First Out) behavior, where only the top element is accessible at any time for operations like pop or peek.

A) Correct B) Incorrect C) Correct D) Correct E) Incorrect F) 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 contexts 1 .

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 requirements 1 .

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 modules 1 .

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 changes 1 .

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 interaction 1 .

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 subclass 1 .

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 design 1 .

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 organization 1 . 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 congruent 1 .

© : 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 communicate 1 .

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 design 1 .

(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 practices 1 .

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 law 1 .

ThinkingLabs article on Shades of Conway’s Law 2 .

Dovetail article on What Is Conway’s Law

A) True B) False C) True D) 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 approaches 1 .

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 project 2 .

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 for 1 .

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 project 2 .

A) False B) False C) True D) True E) True F) 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 stakeholders 1 .

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 issues 2 .

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 documentation 2 .

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 architecture 2 .

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 stakeholders 2 .

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

The performance of a system often competes with its:

Flexibility (A) - True 1

Memory usage (B) - True 1

On-time completion of the project C - False

Adaptability (D) - True 1

Usability (E) - True 1

Security (F) - True 1

Testability (G) - True

In system design, performance trade-offs are a critical consideration. Here’s an explanation of how each listed aspect competes with system performance:

Flexibility (A) : Systems designed for high performance may be less flexible because they are optimized for specific tasks or conditions 1 .

Memory Usage (B) : High-performance systems may require more memory to store data and instructions for rapid access, which can be at odds with limited memory resources 1 .

On-time Completion of the Project © : While performance considerations can impact project timelines, they do not inherently compete with the on-time completion of a project.

Adaptability (D) : Systems that need to perform well under varying conditions may sacrifice adaptability, as they are tightly coupled with their performance optimizations 1 .

Usability (E) : Sometimes, the pursuit of performance can lead to complex user interfaces or workflows, affecting usability negatively 1 .

Security (F) : Security measures can introduce additional processing and checks, potentially slowing down system performance 1 .

Testability (G) : High-performance systems may be harder to test due to their complexity and the need for specialized testing environments or tools 1 .

These trade-offs highlight the importance of balancing different system attributes to meet the overall goals and constraints of a project.

References:

CodingDrills article on Trade-Offs in System Design 1

The aspects that are more of a domain-related nature and those that are more of a technical nature are as follows:

More technical:

Choosing a database (A)

Choosing a layout manager in a GUI (D)

The average number of methods per class (E)

More domain-related:

Modelling a banking account (B)

Legal constraints for the execution of a money transfer ©

Specification of a calculation formula (F)

In software architecture, aspects can be categorized based on their relevance to the domain (the problem space) or the technology (the solution space). Here’s an explanation of each:

More Technical :

Choosing a database (A) : This is a technical decision based on factors like data volume, concurrency, performance, and technology stack.

Choosing a layout manager in a GUI (D) : This involves technical considerations about how user interface elements are arranged and managed on the screen.

The average number of methods per class (E) : This is a technical metric used in object-oriented design to assess complexity and maintainability.

More Domain-Related :

Modelling a banking account (B) : This involves understanding the business rules and operations of banking accounts, which is domain-specific knowledge.

Legal constraints for the execution of a money transfer © : These are domain-related as they pertain to the legal and regulatory requirements of financial transactions.

Specification of a calculation formula (F) : This is typically domain-related because it involves the business logic and rules for performing calculations within the domain.

These distinctions are important for architects to consider when making design decisions, ensuring that both technical and domain-related aspects are adequately addressed.

References:

Rozanski, N., & Woods, E. (2011). Software Systems Architecture: Working With Stakeholders Using Viewpoints and Perspectives. Addison-Wesley Professional.

Fowler, M. (2002). Patterns of Enterprise Application Architecture. Addison-Wesley.

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.