Software Architecture Notes

A Software Architecture Model is the high-level blueprint of a software system. It defines how the system is structured, how its major components interact, and the guiding principles behind its design and evolution.

Think of it as the foundation that shapes how software behaves internally—long before coding begins.

 It also acts as a common language between developers, designers, stakeholders, and clients, ensuring everyone shares the same vision.

 Definition

A Software Architecture Model is a conceptual framework that describes:

•  System components
•  Relationships between components
•  Flow of data and control
•  Technology stack
•  Non-functional requirements (performance, security, scalability, reliability)

 Why is Software Architecture Important?

1. Clear Structure & Vision

Provides a complete overview of the system, making development organized and efficient.

2. Better Communication

Ensures all stakeholders understand the system design in the same way.

3. Scalability Support

A well-designed architecture makes it easier to grow the system in the future.

4. Easy Maintenance

Structured systems are simpler to update, debug, and enhance.

5. Quality Assurance

Directly impacts performance, security, and reliability.

6. Risk Reduction

Helps identify and minimize risks early in development.

 Key Elements of Software Architecture

 Components

Independent building blocks like modules, services, or layers.

 Connectors

Mechanisms that allow components to communicate
(e.g., APIs, protocols, messaging systems).

 Configuration

The arrangement and interaction of components and connectors.

 Constraints

Rules and limitations such as:

• Technology choices
• Security policies
• Hardware limitations

 Architectural Styles

Standard patterns used to design systems (e.g., MVC, Microservices).

 Popular Software Architecture Models

1. Layered Architecture

• Divides system into layers (Presentation, Business, Data)
•  Simple & maintainable
•  Common in enterprise applications

2. Client–Server Architecture

• Client sends requests; server processes them
•  Used in web applications, email systems

3. MVC (Model–View–Controller)

• Model → Data & logic
• View → User interface
• Controller → Handles input
•  Widely used in modern web frameworks

4. Microservices Architecture

• Breaks system into small independent services
•  Highly scalable & flexible

5. Event-Driven Architecture

• Components communicate via events
•  Ideal for real-time systems (IoT, streaming apps)

6. Service-Oriented Architecture (SOA)

• System built as a collection of services
• Similar to microservices but more complex and heavyweight

 Benefits of a Good Architecture

• Modularity – Easy to manage and divide system
• Performance – Optimized structure improves speed
• Reusability – Components can be reused
• Security – Strong boundaries protect system
• Scalability – Handles growth efficiently
• Flexibility – Easy to add new features

 Challenges in Software Architecture

• Choosing the right architecture
• Balancing functional & non-functional requirements
• Adapting to new technologies
• Maintaining long-term system quality

 Real-Life Analogy

Software architecture is like designing a building blueprint:

•  Rooms → Components
•  Doors & pathways → Connectors
•  Rules & materials → Constraints
•  Expansion plans → Scalability

 Without a proper architecture, both buildings and software systems can fail.

The Structure Model represents the static blueprint of a software system. It explains how the system is organized, what components it contains, and how those components are connected.

 Unlike dynamic models, it does not show runtime behavior—instead, it focuses on how everything is arranged internally.

 What Does It Focus On?

•  Components (modules, classes, subsystems)
•  Relationships (dependencies & communication links)
•  Data organization
•  System layers

 Purpose of Structure Model

• Provide a high-level system overview
• Help developers understand component responsibilities
• Explain data flow & interactions
• Improve maintainability & scalability
• Identify reusable components

 Key Elements of Structure Model

 Components

Independent functional units such as UI module, backend module, or database.

 Connectors

Communication links between components (e.g., APIs, method calls).

 Layers

Logical divisions of the system based on responsibilities.

 Interfaces

Interaction points where components communicate.

 Data Stores

Storage systems like databases or file systems.

 Structure Model Diagram (Layered View)

+---------------------------+
|   Presentation Layer      |
|   (UI / User Interface)   |
+---------------------------+
            ↓
+---------------------------+
|     Business Layer        |
|   (Logic & Processing)    |
+---------------------------+
            ↓
+---------------------------+
|   Data Access Layer       |
|   (CRUD Operations)       |
+---------------------------+
            ↓
+---------------------------+
|     Database Layer        |
|   (Data Storage)          |
+---------------------------+

Detailed Layer Explanation

1. Presentation Layer

Handles interaction between user and system.

Responsibilities:

• Render UI (web/mobile screens)
• Capture user input
• Send requests to business layer

2. Business Layer

The core brain of the system.

Responsibilities:

• Apply business rules
• Process data
• Communicate with data layer

3. Data Access Layer

Acts as a bridge between business logic and database.

Responsibilities:

• Perform CRUD operations
• Protect direct DB access
• Convert data formats

4. Database Layer

Responsible for data storage and management.

Responsibilities:

• Store structured data
• Maintain data integrity
• Execute queries

 Advantages of Structure Model

•  Clear system organization
•  Easy maintenance
•  High reusability
•  Better scalability
•  Improved team communication
•  Supports modular development

 Real-Life Analogy

Think of it like building a house:

•  Rooms → Components
•  Doors → Connectors
•  Floors → Layers
•  Blueprint → Structure Model

 Without a proper structure, everything becomes messy and hard to manage.

A Framework Model is a structured foundation used to build software applications efficiently. It provides a ready-made skeleton that developers can use to create systems faster and in a more organized way.

 Instead of starting from scratch, developers use prebuilt structures, tools, and rules.

 Simple Definition

A Framework Model is a combination of guidelines, tools, reusable components, and processes that help in building software applications.

It includes:

•  Predefined components
•  Design patterns
•  Development rules
•  Libraries
•  Reusable modules

 In simple words:
Framework Model = Ready-made structure for fast and systematic development

 Key Features

• Reusability – Build once, use multiple times
• Standardization – Consistent coding practices
• Modularity – Divides system into independent parts
• High Productivity – Faster development
• Quality Improvement – Fewer errors, better reliability

 Framework Model Diagram

+---------------------------+
|   Application Layer       |
|---------------------------|
|   UI, Business Logic      |
+---------------------------+
            ▲
            |
+---------------------------+
|   Framework Layer         |
|---------------------------|
|   Libraries               |
|   Components              |
|   Patterns                |
|   Tools                   |
+---------------------------+
            ▲
            |
+---------------------------+
|   System Layer            |
|---------------------------|
|   OS, Hardware, Drivers   |
|   Network, Database       |
+---------------------------+

 Layer-wise Explanation

1. Application Layer

This is where developers build the actual application.

Includes:

• User Interface (UI)
• Business logic
• Controllers & services

 Uses ready-made features from the framework.

2. Framework Layer (Core Layer)

The heart of the model—provides reusable tools and modules.

Includes:

• Authentication modules
• Database handling
• Routing systems
• Validation tools
• Error handling

Examples:

• Django ORM
• Laravel Blade
• Spring Boot Beans

3. System Layer

The base layer that supports everything.

Includes:

• Operating System
• Hardware
• File system
• Database servers

 The framework runs on top of this layer.

 Types of Framework Models

1. Application Frameworks

Examples: Django, Laravel, Spring

2. Web Frameworks

Examples: React, Angular, Vue

3. Mobile Frameworks

Examples: Flutter, React Native

4. Enterprise Frameworks

Examples: .NET Framework, J2EE

5. Testing Frameworks

Examples: Selenium, JUnit

 Advantages

•  Faster development
•  Reduced errors
•  Improved security
•  Easy maintenance
•  Simplified debugging
•  Consistent design
•  Code reusability

 Disadvantages

•  Steep learning curve
•  Limited flexibility
•  Updates may break code
•  Dependency on framework

 Real-Life Analogy

A framework is like a furniture assembly kit:

•  Pre-cut parts → Components
•  Tools → Libraries
•  Instructions → Guidelines

 You just assemble everything instead of building from scratch.

The Dynamic Model represents the behavior of a software system over time. It shows how the system acts, reacts, and interacts during execution.

 While the Structure Model shows what the system is made of,
the Dynamic Model shows how the system actually works at runtime.

 Simple Definition

A Dynamic Model describes how objects interact, data flows, and states change during system operation.

It explains:

•  How processes start and stop
•  How data moves
•  How components communicate
•  How system states change

 In simple words:
Dynamic Model = Behavior + Interaction + State Changes

 Purpose of Dynamic Model

• Understand system workflow
• Represent runtime behavior
• Show sequence of operations
• Model events and responses
• Detect communication & synchronization issues
• Help in testing and debugging

 Key Components

 Events

Triggers that initiate actions
(e.g., button click, API request)

 States

Different conditions of a system
(e.g., Idle, Processing, Completed)

 Transitions

Movement from one state to another

 Activities & Actions

Tasks performed within a state

 Messages

Communication between components/objects

Dynamic Model Diagram (State Transition)

   +-----------+
   |   Idle    |
   +-----------+
         |
         | Start Event
         v
   +-------------+
   | Processing  |
   +-------------+
   | Validate    |
   | Compute     |
         |
   ------+------
   |           |
Success       Error
   |           |
   v           v
+------------+   +-------------+
| Completed  |   | Error State |
+------------+   +-------------+
         ^
         |
      Retry / Back

 Diagram Explanation

 State 1: Idle

• System waits for user input or event

Transition: Start Event

• User triggers an action (e.g., form submit)

 State 2: Processing

• System performs tasks like:
  • Validation
  • Calculation
  • Data fetching

 Transition: Success

• All operations complete successfully

 State 3: Completed

• Final result/output is delivered

 Transition: Error

• If validation fails or issue occurs

 State 4: Error State

• System handles error
• Can retry or return to idle

 Types of Dynamic Models

1. State Machine Model

• Focus on states & transitions
• Used in embedded systems

2. Sequence Model

• Shows interaction between objects step-by-step

3.Activity Model

• Represents workflows and processes

4. Data Flow Model

• Shows movement of data across system

 Advantages

•  Clear understanding of system behavior
•  Helpful in testing & simulation
•  Detects logical errors early
•  Useful for real-time systems
•  Shows interactions clearly

 Disadvantages

•  Complex for large systems
•  Time-consuming to design
•  Hard to maintain with frequent changes
•  Requires deep understanding

 Real-Life Example

Think of an ATM machine:

• Idle → Card Inserted → PIN Validation → Transaction → Completed → Idle

 These step-by-step runtime changes represent the Dynamic Model.