Software Architecture and Design Patterns

Pipe and Filter

A component reads streams of data on its inputs and produces streams of data on its outputs. Suitable for apps that require a series of independent computations on ordered data.

Components and Connectors

Components include Filters that apply local transformations to input streams incrementally. Connectors like Pipes transmit outputs of one filter to inputs of another.

Topology Variants

1. Filters do not share state with other filters. 2. Filters do not know the identity of their upstream or downstream filters. 3. Correctness of output does not depend on the order of incremental processing.

Specializations for pipeline design/processing

1. Pipelines restrict topologies to linear sequences. 2. Batch Sequential processes all input data before output. Example: Unix Shell Scripts.

Data-Centered/Repository

Central body stores data long-term for apps requiring manipulation in various ways. Components include Central Data Structure and Computation Components.

Components and Connectors (Repository)

Central Data Structure represents system state, Computation Components operate on it. Direct Memory Accesses connect to the central data structure.

Topology Variants (Repository)

1. Blackboard variant mediates cooperation between components. 2. Repository variant is the default style.

Implicit Invocation

A component broadcasts output consumed by other components without knowing the consumers. Components include Data Generators and Consumers.

Connectors (Implicit Invocation)

Used for communication, such as Procedure Calls or Event Bus. Variants include Publish-Subscribe and Event-Based.

Topology (Implicit Invocation)

Publish-Subscribe: Game Server uses remote procedure calls for broadcasting. Event-Based: Components emit and receive events over a central event bus.

Layered Architecture

Architecture separated into ordered layers where each layer communicates with adjacent layers. Specializations allow non-adjacent layers to communicate directly.

Components and Connectors (Layered)

Layers perform calculations and communicate with adjacent layers. Pre-Determined Protocols facilitate communication between layers.

Client-Server

Suitable for distributed data and processing across components. Components include Servers that provide specific services.

Clients

Components that call on services provided by server

Connectors

Term for: A network that allows client to access remote servers

Topology

Arrangement where clients communicate with servers, not directly with each other

File Servers

Primitive form of data service for sharing files across a network

Database Servers

Servers that process SQL requests from clients and return results

Advantages of Server Architecture

Data can be on multiple servers, known data locations, platform flexibility, easy server management

Disadvantages of Server Architecture

No central register of names/services, difficult to discover available services

Process-Control Overview

Feedback control system maintaining specified properties of process outputs

Process Definition

Includes mechanisms for manipulating process variables

Control Algorithm

Decides how to manipulate process variables

Process Variables

Include Controlled Variable, Input Variable, Manipulated Variable

Set Point

Desired value for a controlled variable

Sensors

Used to obtain values of process variables

Open-Loop Control System

Variant where process variable info is not used to adjust the system

Closed-Loop Control System

System where controlled variable is measured and used to manipulate process variables

Serverless Architecture Overview (Why it’s used)

Deploying code on demand to avoid constant server running

Function/Container

Component that performs a defined task when triggered

Events

Connectors for synchronous or asynchronous communication

Microservices Architecture Overview (Why it’s used)

Focuses on building modular services with well-defined interfaces for scalability and flexibility

Self-contained services

Decomposed apps into services that are independently deployable and maintainable

Properties of a Good Service

Single responsibility, independently deployable, not overly dependent, maintains data integrity

Syncronous Communication

Communication where sender waits for response from receiver (e.g., HTTP/S)

Asyncronous Communication

Communication where sender does not wait for response (e.g., Advanced Message Queuing Protocol)

Microservices

Decompose product service and payment service with defined APIs

Microservices Architecture

A system design where services are independently deployable and self-contained, allowing for isolated updates or bug fixes to specific services without affecting the entire system.

Scalability

Scaling delivery service for increased deliveries without affecting payment

Advantages of Microservices

Independent deployment, easier CI/CD, fault isolation, team autonomy

Disadvantages of Microservices

Increased cost, complex distributed system, communication challenges

Comparison of Serverless architecture with other architectures

Differences in cost, architecture, and development ownership

MVVM Overview

Model-View-ViewModel architecture for separating UI and logic

MVVM Components

Model (data), View (UI), ViewModel (binds view and model)

MVVM Connectors

Events and method calls between view, viewmodel, and model

MVVM Examples

RSS reader app showcasing view, viewmodel, and model interactions

Design Patterns

Reusable solutions to common problems in programming

Desirable Design Properties

High cohesion, low coupling, following the YAGNI principle

Anti-Patterns

Poor solutions like code duplication, multiple-personality class, blob, data class, data clump, feature envy, tradition breaker

Structural Design Patterns are: (Overview)

Design patterns that focus on organizing and assembling objects or classes in a way that enables their efficient interaction. Examples include Adapter and Composite patterns.

What is the intent of the Solution Design Pattern?

Composing objects into tree structures representing part-whole hierarchies.

Structure

Describes how the pattern is implemented.

Example

Picture constructed by combining multiple primitives.

Participants/Components of Composite Pattern

Components of the pattern: Component, Leaf, Composite, Client.

Decorator Design pattern

Motivation: Extending an object's functionality dynamically.

What are Behavioral Patterns?

Patterns concerning the interaction between classes or objects.

Strategy

Pattern for letting clients vary implementations according to specific needs.

Observer

Pattern for maintaining consistency between related objects.

Template Method

Pattern for defining algorithm steps and deferring type-specific steps to subclasses.

Singleton

Pattern to ensure a class has only one instance.

Factory Method

Pattern for letting subclasses decide which class to instantiate.

Abstract Factory

Pattern for creating families of related or dependent objects.