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.

A Process Model defines how software is planned, developed, tested, and maintained. It provides a step-by-step roadmap that guides the entire development lifecycle.

 It ensures that software development is done in a systematic, organized, and efficient way.

 Simple Definition

A Process Model is a structured set of activities required to build a software system.

It describes:

•  Sequence of development phases
•  Tasks in each phase
•  Entry & exit criteria
•  Deliverables produced

 In simple words:
Process Model = Method to develop software from start to finish

 Core Activities in Process Models

1. Communication

• Requirement gathering
• Understanding user needs

2. Planning

• Estimation, scheduling, resource allocation

3. Modeling

• System design (architecture, UI, database)

4. Construction

• Coding + testing

5. Deployment

• Delivery + customer feedback

 Generic Process Model Diagram

+----------------+     +----------------+     +----------------+
| Communication  | --> |   Planning     | --> |   Modeling     |
| (Requirements) |     | (Estimation)   |     |   (Design)     |
+----------------+     +----------------+     +----------------+
         |                                      |
         v                                      v
+----------------+     +----------------+
| Construction   | --> |  Deployment    |
| (Code & Test)  |     |   (Delivery)   |
+----------------+     +----------------+

 Types of Process Models

1. Waterfall Model

• Linear & sequential approach
• Each phase must complete before next starts
•  Simple but less flexible
   Best for: Small, well-defined projects

2. Incremental Model

• Development in small parts (increments)
• Each part adds functionality
   Best for: Large projects needing early delivery

3. Spiral Model

• Combines iteration + risk analysis
• Development in cycles (spirals)
   Best for: Complex, high-risk systems

4. V-Model (Verification & Validation)

• Testing runs parallel to development
   Best for: Safety-critical systems

5. Prototyping Model

• Prototype built first to understand requirements
   Best for: Unclear or changing requirements

6. Agile Model

• Iterative & flexible
• Work done in short cycles (sprints)
• Continuous customer feedback
   Best for: Rapidly changing projects

 Importance of Process Models

•  Provides structured approach
•  Reduces risks
•  Improves quality
•  Enhances team communication
•  Supports planning & scheduling
•  Ensures timely delivery

 Advantages

• Makes development systematic
• Easy monitoring & control
• Better documentation
• High quality & reliability

 Disadvantages

• Some models are rigid (e.g., Waterfall)
• Requires expertise
• Not suitable for all projects

 Real-Life Analogy

Think of building a house:

•  Requirement → What you need (rooms, design)
•  Planning → Budget & timeline
•  Designing → Blueprint
•  Construction → Building
•  Deployment → Living in it

 This step-by-step approach is exactly what a Process Model does in software development.