Software Architecture Design

• Architectural design focuses on the organization and structure of a software system.
• It bridges the gap between design and requirements engineering by defining structural components and their relationships.
• The result of architectural design is an architectural model that illustrates the system's components and their communication methods.

Agility and Architecture

• Agile processes typically involve designing a system architecture early on.
• Modifying the system architecture can be costly due to its widespread impact on system components.

Architectural Abstraction

• Architecture in the small deals with the structure of individual programs, focusing on component decomposition.
• Architecture in the large involves complex enterprise systems across different computers and organizations.

Advantages of Explicit Architecture

• Facilitates communication among stakeholders by providing a discussion framework.
• Allows for analysis of the system's ability to meet non-functional requirements.
• Enables large-scale reuse of architecture across various systems and product lines.

Architectural Representations

• Simple block diagrams are commonly used to document software architectures, but lack detailed semantics.
• The need for model semantics depends on how the architectural models will be used.

Box and Line Diagrams

• They are abstract and do not detail component relationships or sub-system properties.
• Useful for stakeholder communication and project planning.

Use of Architectural Models

• They facilitate discussion about system design by providing a high-level overview for stakeholders.
• They document designed architecture by illustrating system components, interfaces, and connections.

Architectural Design Decisions

• The architectural design process is creative and depends on the specific system being developed.
• Common decisions impact the system's non-functional characteristics.

Architecture Reuse

• Systems in similar domains often share architectural similarities reflecting domain concepts.
• Product lines contain core architecture that satisfies customer needs.
• System architecture may be based on architectural patterns which are reusable in different ways.

Architecture and System Characteristics

• Performance is improved by localizing critical operations and minimizing communications, using large components.
• Security involves layered architecture with critical assets in inner layers.
• Safety is enhanced by localizing safety-critical features in a small number of subsystems.
• Availability includes redundant components and fault tolerance mechanisms.
• Maintainability utilizes fine-grain, replaceable components.

Architectural Views

• They provide different perspectives for designing and documenting a system's architecture.
• Multiple views are needed for both design and documentation to show system decomposition, run-time processes, and component distribution.

4 + 1 View Model of Software Architecture

• Logical view shows key abstractions as objects or classes.
• Process view illustrates run-time composition of interacting processes.
• Development view shows software decomposition for development.
• Physical view represents system hardware and software component distribution.
• Use cases or scenarios relate these views (+1).

Representing Architectural Views

• UML is sometimes appropriate for describing system architectures.
• Architectural description languages (ADLs) were developed but aren't broadly used.

Architectural Patterns

• They represent, share, and reuse design knowledge.
• Patterns describe good design practices that have been proven in various environments.
• Patterns should specify their usefulness and limitations.
• Tabular and graphical descriptions can represent patterns.

Model-View-Controller (MVC) Pattern

• Separates presentation and interaction from data, structuring the system into Model, View, and Controller components.
• Model manages data and operations, View manages data presentation, and Controller manages user interactions.
• Suitable when multiple ways to view and interact with data are required or when future interaction and presentation needs are unknown.
• MVC allows independent data changes and representation, supporting multiple data presentations, but can add complexity when data models and interactions are simple.

Layered Architecture

• It models sub-system interfacing by organizing the system into layers that provide services.
• It supports incremental sub-system development where only adjacent layers are affected by interface changes.
• Structuring systems can be artificial.

Layered Architecture Pattern

• It organizes systems into layers that provide services to the layer above, with lowest-level layers representing core services.
• Used when building on existing systems, development is spread across teams, or there's multi-level security needs.
• The pattern allows entire layer replacements if the interface is maintained and it increases system dependability through redundancy.
• Clean separation between layers can be difficult, and performance can suffer due to multiple service request interpretations.

Repository Architecture

• Shared data is held in a central repository accessed by all sub-systems.
• Each sub-system maintains its own database and passes data to others.
• The repository model is efficient for sharing large amounts of data.

Repository Pattern

• Manages all data in a central repository accessible to all components where components interact only through the repository.
• Suitable for systems generating large information volumes that need storing and data-driven systems where data triggers actions.
• It allows component independence, propagates changes, and manages data consistently, but the repository is a single point of failure and can cause communication inefficiencies.

Client-Server Architecture

• A distributed system model where data and processing are distributed across components, and can be implemented on a single computer.
• It has stand-alone servers providing services.
• Clients call on these services through a network.

Client-Server Pattern

• System functionality is organized into services delivered from separate servers, which clients make use of.
• Suitable when shared database data needs access from several locations and when the system load is variable.
• Servers can be distributed and general functionality is available without being implemented by all services.
• Each service is a single point of failure and performance depends on the network, and management issues may arise with different server ownership.

Pipe and Filter Architecture

• Functional transformations process inputs to produce outputs.
• Transformations that are sequential form a batch sequential model commonly used in data processing systems, but isn't suitable for interactive systems.

Pipe and Filter Pattern

• Data processing is organized so each filter carries out one type of data transformation and data flows between components for processing.
• Used in data processing applications where inputs are processed to generate outputs.
• Easily understood, supports transformation reuse, matches business processes, and can be implemented sequentially or concurrently.
• Data transfer formats must be agreed upon, increasing system overhead and potentially preventing the reuse of incompatible transformations.

Application Architectures

• They meet organizational needs.
• Application systems share common architectures mirroring application requirements.
• Generic application architecture can be adapted to meet specific requirements.

Use of Application Architectures

• They act as a starting point for architectural design.
• They serve as a design checklist.
• They organize development team work.
• They help assess components for reuse.
• They provide a common vocabulary for application types.

Examples of Application Types

• Data processing applications process data in batches without user intervention.
• Transaction processing applications process user requests and update system databases.
• Event processing systems perform actions based on interpreting environmental events.
• Language processing systems process and interpret user intentions specified in a formal language.

Application Type Examples

• Transaction processing systems (e-commerce and reservation systems) and language processing systems (compilers and command interpreters).

Transaction Processing Systems

• They process user requests for information or updates to a database.
• Any sequence of operations that satisfies a goal from a user perspective.
• Users make asynchronous service requests which are processed by a transaction manager.

Information Systems Architecture

• It consists of user layer, communications, information retrieval and system database.
• These are transaction-based systems.

Web-Based Information Systems

• Information and resource management systems are commonly web-based, using web browsers for user interfaces.
• E-commerce systems manage resources, accept electronic orders, and arrange delivery.
• E-commerce systems use "shopping carts" where users place items in separate transactions and pay together.

Server Implementation

• Web server handles user communications with a web browser interface.
• Application server implements application-specific logic and manages information storage and retrieval.
• Database server moves information and handles transaction management.

Language Processing Systems

• They accept natural or artificial languages as input and generate another representation, potentially including an interpreter.
• Useful for describing algorithms or system data to solve problems.
• Meta-case tools process descriptions and rules to generate tools.

Compiler Components

• Lexical analyzer converts input tokens to an internal form.
• Symbol table holds names of entities.
• Syntax analyzer checks language syntax.
• Syntax tree is an internal structure representing the program.
• Semantic analyzer checks the semantic correctness using the syntax tree and symbol table.
• Code generator generates abstract machine code by walking the syntax tree.

Key Points

• Software architecture describes how a software system is organized.
• Architectural design decisions involve application type, system distribution, and architectural styles.
• Architectures are documented through conceptual, logical, process, and development views.
• Architectural patterns reuse knowledge about system architectures, explaining their uses, advantages, and disadvantages.
• Application system architecture models aid in understanding, comparing, validating designs, and assessing component reuse, such as language and transaction processing systems.