SOA and Monolith Architecture

Software Architecture Overview

Software architecture refers to the structures of a software system and the discipline involved in creating these structures. Each structure is composed of the following:

• Software Elements: Fundamental components of the system.
• Relations Among Elements: How these components interact or depend on each other.
• Properties of Elements: Characteristics or features of the software components.
• Properties of Relations: Attributes of the interactions or dependencies among elements.

Blueprint for Development

Acts as a blueprint for the system and the development project. Outlines the tasks required for design teams, ensuring organized and efficient execution.

Definition of Software Architecture

The software architecture of a program or computing system is:

• The structure(s) of the system.
• Comprising software elements, their externally visible properties, and the relationships among them.

Monolithic Architecture

• The term "monolith" originates from the ancient word for a large single block of stone.
• In software engineering, monolithic architecture refers to a single, indivisible unit.
• It follows a traditional approach where the entire application is developed as a single, self-contained unit.

Key Characteristics

• Unified Structure:

  • All components of the software are combined into a single program running on a single platform.
  • Functions and processes are managed in one place.

• Composition of a Monolithic Application:

  • Database: Centralized data storage for the application.
  • Client-side User Interface: The front-end or interface users interact with.
  • Server-side Application: The back-end logic and processes.

• Concept:

  • The application combines different components into a single program.
  • All parts (UI, logic, database) work as a unified system.

Advantages and Disadvantages of Monolithic Architecture

• Advantages:
  • Simpler to develop and deploy initially.
  • Easier to test as it is a single unified application.
• Disadvantages:
  • Scalability issues: Difficult to scale specific components independently.
  • Maintenance challenges: As the application grows, updating or debugging becomes harder.
  • Tight coupling: Changes in one part may require changes in the entire system.

Service Oriented Architecture (SOA)

Service-Oriented Architecture (SOA) is a set of principles and methodologies for designing and developing software as interoperable services.

• Services are well-defined business functionalities, built as reusable software components.
• Key Benefit: Reusability for different purposes.

Anatomy of a Service:

• New Service: Built from scratch.
• Wrapped Legacy: Existing functionality repurposed as a service.
• Composite Service: Combines multiple services into one

Components of Service-Oriented Architecture

Figure 1

• Service:
  • Fundamental building blocks of SOA.
  • Types:
    • Private Services: Available only within an organization.
    • Public Services: Accessible over the internet.
  • Features of a Service:
    • Service Implementation: Code logic for specific functions (e.g., user authentication, bill calculation).
    • Service Contract: Defines service terms, prerequisites, cost, and quality.
    • Service Interface: Provides a communication mechanism for invoking services. Reduces dependencies between services and consumers.
• Service Provider:
  • Creates, maintains, and offers services.
  • Can be internal or third-party.
• Service Consumer:
  • Requests services from providers.
  • Can be systems, applications, or other services.
  • Interaction is governed by the service contract.
• Service Registry / Broker / Repository:
  • Network-accessible directory storing service descriptions.
  • Functions:
    • Service providers publish descriptions here.
    • Service consumers use it to discover required services.

Key Benefits of SOA

• Interoperability: Services work across different platforms and languages.
• Reusability: Services can be reused in multiple applications.
• Scalability: Components can scale independently.
• Flexibility: Easy to update or replace individual services without affecting the entire system.