Design patterns are reusable solutions to common software design.pptx

1
WEB PROGRAMMING
Introduction to design patterns

2
OUTLINE
 Introduction design pattern
 Client-Server Pattern
 Model-View-Controller
 Service-Oriented Architecture (SOA)
 Microservices Architecture

3
INTRODUCTION TO DESIGN PATTERNS
 Design patterns are reusable solutions to common software design
problems that arise during the development process.
 It represents best practices distilled from the collective experience of
software developers and architects.
 It can leverage proven solutions to recurring problems for Developers:
improving code quality, maintainability, and scalability.
 Design patterns: providing a structured approach to solving common
problems encountered in distributed environments.
 Essential to consider factors for When designing for distributed
systems: such as scalability, fault tolerance, consistency, and latency.
Here's an introduction to design patterns for building distributed
systems:

4
DESIGN PATTERNS FOR WEB
 Client-Server Pattern
 Model-View-Controller (MVC)
 Service-Oriented Architecture (SOA)
 Microservices Architecture

5
CLIENT-SERVER PATTERN
 It is fundamental patterns in distributed systems.
 It involves dividing the system into two separate entities
clients that request services, and
servers that provide those services.
 It establishes a clear separation between
the presentation or user interface logic (client) and
the application or business logic (server).
 It facilitates scalability and allows for easier management of resources
and responsibilities.

6
CLIENT-SERVER PATTERN - BRIEF
 Client
 Server
 Communication Protocol
 Statelessness
 Scalability and Load Balancing
 Security Considerations

7
 Client:
User interface or application component
It interacts with the end-user.
It initiates requests for services or resources from the server and
displays the results to the user.
Clients can vary in complexity
Ex. web browsers, mobile apps, desktop applications, or other
software components.

8
 Server:
The server is responsible for processing client requests
Executing the necessary logic and providing the requested services
or resources.
It typically hosts the application or business logic, as well as the
data and resources required to fulfill client requests.
Servers can range from simple HTTP servers serving static content
to complex application servers running dynamic business logic.

9
 Communication Protocol:
The client and server communicate with each other by using a
communication protocol.
It defines the rules and format for exchanging messages.
Common communication protocols used in client-server
architectures
Ex. HTTP, TCP/IP, WebSocket, and Remote Procedure Call (RPC).
The choice of protocol depends on factors such as performance,
scalability, security, and compatibility with existing systems.

10
 Statelessness:
In many client-server architectures
Servers are designed to be stateless: do not maintain any client-
specific state between requests.
Instead, each request from the client contains all the information
necessary for the server to process it, allowing servers to scale
more easily and handle a larger number of clients.
However, some applications may require maintaining session state
or client context, in which case additional mechanisms such as
cookies, sessions, or tokens may be used.

11
 Scalability and Load Balancing:
Client-server architectures can be scaled horizontally by adding
more servers to handle increasing client load.
Load balancing techniques: Used to distribute client requests
across multiple servers, ensuring optimal utilization of resources
and improved performance.
Load balancers can be implemented using hardware appliances or
software-based solutions.

12
 Security Considerations:
Client-server architectures require careful consideration of security
aspects such as authentication, authorization, data encryption, and
protection against common security threats.
Example: cross-site scripting (XSS), SQL injection, and cross-site
request forgery (CSRF).
Security measures are typically implemented at both the client and
server sides to protect against unauthorized access and data
breaches.

13
MVC: MODEL-VIEW-CONTROLLER
 It is a software architectural pattern commonly used in the development
of user interfaces.
 Especially it is in web applications but also in desktop and mobile
applications.
 MVC separates an application into three interconnected components:
the Model,
the View, and
the Controller.

14
MVC: MODEL-VIEW-CONTROLLER - BRIEF
 Model:
It represents the data and business logic of the application.
It encapsulates the data and provides methods to manipulate that
data.
The Model is independent of the user interface and any
presentation logic in MVC.
It simply represents the state of the application and the rules that
govern its behavior.
Examples of models include data structures, database tables, or
classes representing business entities.

15
 View:
It is responsible for presenting the data to the user in a particular
format.
It represents the user interface elements such as HTML pages, UI
widgets, or templates.
Views retrieve data from the Model and render it in a way that is
suitable for presentation to the user.
Views are passive components, meaning they should not contain
any business logic. Instead, they focus solely on displaying data
and capturing user input in MVC.

16
 Controller:
It acts as an intermediary between the Model and the View.
It receives input from the user via the View, processes that input by
interacting with the Model, and then updates the View accordingly.
Controllers contain the application's logic for handling user actions,
routing requests, and updating the Model based on user input.
Controllers facilitate the separation of concerns by isolating the
presentation logic from the business logic in MVC.

17
MVC: MODEL-VIEW-CONTROLLER - FLOW
1. The user interacts with the View, such as clicking a button or
submitting a form.
2. The View sends the user's input to the Controller.
3. The Controller processes the input, possibly interacting with the
Model to retrieve or manipulate data.
4. The Controller updates the View with any changes resulting from the
user's actions.
5. The updated View is presented to the user.

18
MVC: MODEL-VIEW-CONTROLLER - BENEFITS
 It promotes modularity, maintainability, and testability in software
applications.
 By separating the user interface, business logic, and data manipulation
into distinct components.
 It allows developers to more easily manage complexity and make
changes to one component without affecting the others.
 It makes MVC a popular choice for building scalable and maintainable
software systems.

19
MVC: MODEL-VIEW-CONTROLLER - BENEFITS
 It promotes modularity, maintainability, and testability in software
applications.
 By separating the user interface, business logic, and data manipulation
into distinct components.
 It allows developers to more easily manage complexity and make
changes to one component without affecting the others.
 It makes MVC a popular choice for building scalable and maintainable
software systems.

20
SERVICE-ORIENTED ARCHITECTURE (SOA)
 It is a software architectural style that organizes applications as a
collection of loosely coupled services.
 The services are self-contained, modular units that encapsulate a
specific business functionality and can be accessed and invoked over a
network.
 SOA promotes reusability, flexibility, and interoperability among
distributed systems.

21
 Service:
At the core of SOA are services.
It represents discrete units of functionality within an application.
A service is a self-contained, independent component that performs
a specific task or set of tasks.
Services typically expose a well-defined interface.
Services are described using standards like WSDL (Web Services
Description Language) or OpenAPI, allowing clients to discover and
interact with them.

22
 Loose Coupling:
The services are designed to be independent of each other.
It allows services to evolve independently, making it easier to
modify, replace, or update them without impacting other parts of the
system.
It is achieved by using standards-based communication protocols
like HTTP, SOAP, or REST, which abstract the underlying
implementation details.

23
 Interoperability:
SOA enables interoperability between heterogeneous systems by
defining standard interfaces and protocols for communication
between services.
It allows services built on different platforms or technologies to
seamlessly interact with each other, fostering integration and
collaboration across diverse environments.

24
 Reusability:
Services are designed to be reusable across multiple applications
and business processes.
By encapsulating specific functionalities as services, organizations
can leverage existing services to build new applications more
efficiently.
It promotes consistency, reduces duplication of effort, and improves
time-to-market for new solutions.

25
 Scalability:
SOA supports scalability by allowing services to be distributed and
deployed across multiple servers or locations.
As demand for a particular service increases, additional instances
of the service can be deployed to handle the load, ensuring optimal
performance and resource utilization.
This distributed nature of SOA also enhances fault tolerance and
resilience against failures.

26
 Service Composition:
In SOA, complex business processes are often composed by
orchestrating multiple services together.
It involves chaining together individual services to achieve higher-
level functionalities.
It can be achieved through various means, including choreography,
where services collaborate based on predefined rules, or
orchestration, where a central component (e.g., a BPEL engine)
coordinates the execution of services.

27
 Service Lifecycle Management:
SOA emphasizes the management of services throughout their
lifecycle, from design and development to deployment, monitoring,
and retirement.
This includes governance processes to ensure adherence to
architectural principles, versioning to manage changes over time,
and monitoring to track service performance and availability.

28
 Service Lifecycle Management:
SOA emphasizes the management of services throughout their
lifecycle, from design and development to deployment, monitoring,
and retirement.
This includes governance processes to ensure adherence to
architectural principles, versioning to manage changes over time,
and monitoring to track service performance and availability.
Note: SOA provides a flexible and scalable approach to building
distributed systems, enabling organizations to adapt to evolving
business requirements and integrate disparate systems in a cohesive
manner. By embracing the principles of loose coupling,
interoperability, and reusability, SOA offers a foundation for building
agile, responsive, and cost-effective IT architectures.

29
MICROSERVICES ARCHITECTURE - INTRO
 It is an architectural style that structures an application as a collection of small,
independently deployable services, each responsible for a specific business
function.
 Unlike traditional monolithic architectures, where the entire application is
developed and deployed as a single unit, microservices break down the
application into smaller, loosely coupled components that communicate with
each other over a network.

30
MICROSERVICES ARCHITECTURE - BRIEF
 Service-Based Approach:
It promotes the decomposition of large, complex applications into
smaller, more manageable services.
Each service is designed to be self-contained and focused on a
specific business capability.
Example: user authentication, payment processing, or inventory
management.

31
 Independently Deployable:
One of the key principles is the ability to independently develop,
deploy, and scale each service.
This enables teams to work on different services concurrently, using
different technologies and release cycles, without impacting other
parts of the application.
It also allows for rapid deployment of updates and enhancements to
individual services without requiring a full application deployment.

32
 Loose Coupling:
Microservices communicate with each other through well-defined
APIs using lightweight protocols such as HTTP or messaging
queues.
This loose coupling between services allows them to evolve
independently, with minimal impact on other services.
It also enables teams to choose the most appropriate technology
stack for each service, based on its specific requirements and
constraints.

33
 Resilience and Fault Isolation:
By breaking the application into smaller services, microservices
architecture enhances resilience and fault isolation.
A failure in one service does not necessarily impact the entire
application, as other services can continue to function
independently.
Additionally, services can be replicated and distributed across
multiple servers or data centers to improve availability and fault
tolerance.

34
 Scalability:
It enables horizontal scaling by allowing individual services to be
deployed and scaled independently based on demand.
This means that resources can be allocated dynamically to specific
services that require additional capacity, rather than scaling the
entire application as a monolith.

35
 DevOps and Continuous Delivery:
It aligns well with DevOps practices and continuous delivery
pipelines.
Teams can automate the build, test, and deployment processes for
each service independently, enabling rapid and frequent releases
with minimal manual intervention.
This facilitates faster time-to-market and improves the agility of
development teams.

36
 Challenges:
While microservices offer numerous benefits, they also introduce
complexity in terms of service discovery, inter-service
communication, data consistency, and monitoring.
Managing a large number of services requires robust infrastructure,
deployment automation, and monitoring tools to ensure the
reliability and performance of the application.

37
MICROSERVICES ARCHITECTURE - SUMMARY
 Microservices architecture provides a flexible and scalable approach to
building complex, distributed systems, enabling organizations to
develop and deploy software more efficiently and respond quickly to
changing business requirements.
 By breaking down applications into smaller, independent services,
microservices architecture promotes agility, resilience, and innovation in
software development.

Design patterns are reusable solutions to common software design.pptx

More Related Content

Similar to Design patterns are reusable solutions to common software design.pptx (20)

More from Manonmani40 (11)

Recently uploaded (20)

Design patterns are reusable solutions to common software design.pptx