CEN 4065 - Lecture 1: Introduction

Flashcards covering key vocabulary from the 'Introduction to Software Architecture and Design' lecture, including definitions of core concepts, architectural structures, and design principles.

Software Architecture

The set of structures needed to reason about a system, comprising software elements, relations among them, and properties of both.

Software Design

One of the most critical activities in software development, translating user requirements into a blueprint for building software, leading to understandable, modifiable, reliable, and reusable systems.

Structure (Software Architecture)

A set of elements held together by a relation; software systems are composed of many such structures.

View (Software Architecture)

A representation of a coherent set of architectural elements, documenting a structure as written by and read by system stakeholders.

Architectural Structures (Categories)

The three main categories are Module structures, Component-and-Connector structures, and Allocation structures.

Module Structures

Architectural structures that partition systems into implementation units (modules) assigned specific computational responsibilities, forming the basis of work assignments.

Component-and-Connector (C&C) Structures

Architectural structures focusing on how runtime entities (components) interact with each other (via connectors) to carry out system functions.

Component (C&C Structures)

A runtime entity in C&C structures, such as services, peers, clients, or servers.

Connector (Software Architecture)

An intermediary in C&C structures that facilitates communication and coordination between different software components or systems.

Allocation Structures

Architectural structures that describe the mapping from software structures to the system’s environments (organizational, developmental, installation, execution).

Architectural Pattern

A documented, reoccurring solution to a composition problem of architectural elements, delineating element types and their interaction forms to provide packaged strategies.

Good Architecture (Definition)

Architectures are not inherently good or bad; they are more or less fit for some specific purpose and can be evaluated only in the context of stated goals.

UML 2.5.1

Unified Modeling Language documentation available on Canvas, an information-dense subject for software design.

Decomposition Structure

A module structure showing how modules are recursively broken down into smaller ones, related by the 'is-a-submodule-of' relation, determining system modifiability.

Uses Structure

A module structure where units are related by the 'uses' relation (a specialized dependency), used for engineering systems that can be extended or from which functional subsets can be extracted.

Layer Structure

A module structure where elements are layers (abstract virtual machines) providing cohesive services through managed interfaces, often strictly allowing use of only adjacent layers, improving portability.

Class (Generalization) Structure

A module structure where units are classes, related by 'inherits from' or 'is an instance of,' supporting reasoning about reuse and incremental functionality addition in object-oriented design.

Data Model

A module structure describing the static information structure in terms of data entities and their relationships (e.g., Account, Customer, Loan).

Service Structure (C&C)

A component-and-connector structure where units are services interoperating via coordination mechanisms, used for systems with independently developed components.

Concurrency Structure (C&C)

A component-and-connector structure where units are components arranged into logical threads with their communication mechanisms, used to identify parallelism opportunities and resource contention.

Deployment Structure

An allocation structure showing how software elements are assigned to hardware processing and communication elements, used for reasoning about performance, data integrity, security, and availability in distributed/parallel systems.

Implementation Structure

An allocation structure that maps software elements to the file structure in development, integration, or configuration control environments, critical for managing development and build processes.

Work Assignment Structure

An allocation structure that assigns responsibility for implementing and integrating modules to development teams, clarifying architectural implications related to expertise and communication pathways.