ADVANCED SOFTWARE ENGINEERING

Software Architectural Patterns

Software architecture pattern plays a crucial role in its ability to scale and
meet users’ demands over the time. This article covers different types of
software architecture patterns, their importance, and comparative analysis to
help you choose the best one.

Imagine the artistry of designing a skyscraper—where form meets function, and

engineering brilliance touches the sky. In the world of software, architecture
patterns serve as the architect’s compass, guiding development of robust and
maintainable systems.

Software architecture patterns offer reusable designs for various situations,

offering numerous advantages such as improved efficiency, productivity, speed,
cost optimization, and better planning.

Different types of software architecture

pattern
Let’s discuss a few popular architectural patterns that have helped a lot of
software businesses to scale up their businesses:
1. Layered Architecture Pattern
You’ve probably heard of multi-layered, aka tiered architecture, or n-tier
architecture. This architecture has gained popularity amongst designers and
software architects alike for its commonalities with the conventional
arrangements of IT communications in many startups and established
enterprises. Often, a layered architecture is classified into four distinct layers:
presentation, business, persistence, and database; however, the pattern is not
confined to the specified layers and there can be an application layer or service
layer or data access layer. Popular frameworks like Java EE utilized this
architecture pattern.
Usage:

 Applications that are needed to be built quickly.

 Enterprise applications that require traditional IT departments and processes.
 Appropriate for teams with inexperienced developers and limited knowledge of
architecture patterns.
 Applications that require strict standards of maintainability and testability.
Shortcomings:

 Unorganized source codes and modules with no definite roles can become a
problem for the application.
 Skipping previous layers to create tight coupling can lead to a logical mess full
of complex interdependencies.
 Basic modifications can require a complete redeployment of the application.
 2. Event-driven Architecture Pattern
A good example that uses event-driven architecture is an e-commerce site.
The event-driven architecture enables the e-commerce website to react to
various sources at a time of high demand. Simultaneously, it avoids any crash of
the application or any over-provisioning of resources.
Usage:

 For applications where individual data blocks interact with only a few modules.
 Helps with user interfaces.
Shortcomings:

 Development of a system-wide data structure for events can become arduous

if the events have different needs.

3. Microkernel Architecture Pattern

This architecture pattern consists of two types of components – a core system
and several plug-in modules. While the core system works on minimal
functionality to keep the system operational, the plug-in modules are
independent components with specialized processing.
Usage:

 Applications that have a clear segmentation between basic routines and

higher-order rules.
 Applications that have a fixed set of core routines and dynamic set of rules
that needs frequent updates.
Shortcoming:

 The plugins must have good handshaking code so that the microkernel is
aware of the plugin installation and is ready to work.
 Changing a microkernel is almost impossible if multiple plugins depend on it.

4. Microservices Architecture Pattern

Microservices architecture pattern is seen as a viable alternative to monolithic
applications and service-oriented architectures. The components are deployed as
separate units through an effective, streamlined delivery pipeline. The pattern’s
benefits are enhanced scalability and a high degree of decoupling within the
application.
Usage:

 Businesses and web applications that require rapid development.

 Websites with small components, data centers with well-defined boundaries,
and remote teams globally.
Shortcoming:

 Designing the right level of granularity for a service component is always a

challenge.
 All applications do not include tasks that can be split into independent units.
 5. Space-Based Architecture Pattern
The concept of tuple space – the idea of distributed shared memory is the basis of
the name of this architecture. The space-based pattern comprises two primary
components – a processing unit and a virtualized middleware.
Usage:

 Applications and software systems that function with a large user base and a
constant load of requests.
 Applications that are supposed to address scalability and concurrency issues.
Shortcoming:

 It is a complex task to cache the data for speed without disturbing multiple
copies.

6. Client-Server Architecture Pattern

A client-server architecture pattern is described as a distributed application
structure having two main components – a client and a server. This architecture
facilitates the communication between the client and the server, which may or
may not be under the same network. A client requests specific resources to be
fetched from the server, which might be in the form of data, content, services,
files, etc. The server identifies the requests made and responds to the client
appropriately by sending over the requested resources.
Usage:

 Applications like emails, online banking services, the World Wide Web,
network printing, file sharing applications, gaming apps, etc.
 Applications that focus on real-time services like telecommunication apps are
built with a distributed application structure.
 An application with centralized resources and services that has to be
distributed over multiple servers.
Shortcomings:

 Incompatible server capacity can slow down, causing a performance

bottleneck.
 Servers are usually prone to a single point of failure.

7. Master-Slave Architecture Pattern

Imagine a single database receiving multiple similar requests at the same time.
Naturally, processing every single request at the same time can complicate and
slow down the application process. A solution to this problem is a master-slave
architecture pattern that functions with the master database launching multiple
slave components to process those requests quickly.
Usage:

 Development of Operating Systems that may require a multiprocessors

compatible architecture.
 Advanced applications where larger services have to be decomposed into
smaller components.
 Applications processing raw data stored in different servers over a distributed
network.
 Web browsers that follow multithreading to increase its responsiveness.
 Shortcomings:

 Failure of the master component can lead to a loss of data with no backup
over the slave components.
 Dependencies within the system can lead to a failure of the slave
components.
 There can be an increase in overhead costs due to the isolated nature of the
slave components.

8. Pipe-Filter Architecture Pattern

A pipe-filter architecture pattern processes a stream of data in a unidirectional
flow where components are referred to as filters, and pipes are those which
connect these filters. The chain of processing data takes place where the pipes
transmit data to the filters, and the result of one filter becomes the input for the
next filter. The function of this architecture is to break down significant
components/processes into independent and multiple components that can be
processed simultaneously.
Usage:

 It can be used for applications facilitating a simple, one-way data processing

and transformation.
 Applications using tools like Electronic Data Interchange and External Dynamic
List.
 Development of data compilers used for error-checking and syntax analysis.
 To perform advanced operations in Operating Systems like UNIX, where the
output and input of programs are connected in a sequence.
Shortcomings:

 There can be a loss of data in between filters if the infrastructure design is not
reliable.
 The slowest filter limits the performance and efficiency of the entire
architecture.
 During transmission between filters, the data-transformation overhead costs
might increase.
 The continuous transformational character of the architecture makes it less
user-friendly for interactional systems.

9. Broker Architecture Pattern

A broker pattern is used for structuring distributed systems with decoupled
components. By invoking remote services, components can interact with others in
broker architecture patterns. Also, the broker is responsible for all the
coordination and communication among the components.
Clients, servers, and brokers are three major components of the broker pattern.
Generally, a broker will have access to all the services and characteristics related
to a particular server. When clients request a service from the broker, the broker
redirects them to a suitable service category for further process.
Usage:

 Used in message broker softwares such as Apache ActiveMQ, Apache Kafka,

RabbitMQ, and JBoss Messaging.
 For structuring distributed systems that have decoupled components.
 Shortcomings:

 Shallow fault tolerance capacity.

 Requires standardization of service description.
 The hidden layer may decrease software performance.
 Higher latency and requires more effort in deployment.

10. Peer-to-Peer Architecture Pattern

In the peer-to-peer architectural pattern, individual components are called peers.
A peer can act as a client, a server, or both and change its role dynamically over
time. As a client, a peer can request service from other peers, and as a server, a
peer can provide services to other peers. The significant difference between peer-
to-peer and client-server architecture is that each computer on the network has
considerable authority and the absence of a centralized server. Its capacity
increases as more and more computers join the network.
Usage:

 File-sharing networks such as Gnutella and G2.

 Cryptocurrency-based products such as Bitcoin and Blockchain.
 Multimedia products such as P2PTV and PDTP.
Shortcomings:

 No guarantee of high-quality service.

 Achieving robust security is challenging.
 Performance depends on the number of nodes connected to the network.
 No way to backup files or folders.