SOFTWARE ENGINEERING GROUP

ASSIGNMENT

GROUP NO 4: PRESENTATION ASSIGNMENT

COURSE NAME: SOFTWARE ENGINEERING
COURSE CODE: CS3101
LECTURER NAME: SIR.RODGERS
GROUP MEMBERS
NAMES REGISTRATION NUMBER
LADSLAUS NGALO BCS/25209/2201/DT
RAMADHANI CHOTA BCS/24122/2201/DT
DAUDI LAURENT BCS/25278/2201/DT
GISERA ISHENGOMA BCS/25340/2201/DT
JESCA DAUDI BCS/25928/2201/DT
SULEIMAN MOHAMMED BCS/18336/2101/DT
EMMANUEL R CHACHA BCS/25501/2201/DT
GLAORY GAMA BCS/24629/2201/DT
IRENE CLEMENCE BCS/25454/2201/DT
NASHON NSEMWA BCS/25675/2201/DT
RABIA RASHIDI BCS/25653/2201/DT
NESTA NYILAMWILA BCS/24227/2201/DT
BRIGHTON SIAME BCS/25185/2201/DT
• 1.Define architectural patterns and explain their purposes in software engineering.
• Architectural patterns are high-level, reusable solutions to common problems in software
architecture. They define the structure and organization of a software system, ensuring it meets
specific requirements and constraints. Unlike design patterns which solve detailed
implementation challenges, architectural patterns focus on the overall structure and behaviour of
a system.

• Architectural patterns provide a high-level structure for software systems. They serve as
blueprints that guide the overall organization and design of a system, ensuring it meets specific
requirements related to scalability, reliability, maintainability, and more.

• Purposes of Architectural Patterns:

• 1. Scalability:
• Explanation: These patterns help systems handle increasing loads effectively. They ensure that
as the system grows, it can manage more users, data, and transactions.
• Facilitates the development of systems capable of handling increasing loads.
• Example:
• The Micro-services pattern allows each service to be scaled independently, which makes it easier
to handle a large number of requests.
• 2. Maintainability:
• Explanation: By providing a clear structure and separation of concerns, architectural
patterns make it easier to update, extend, and debug systems.
• It encourages modularity, making systems easier to understand, modify, and extend.
• Example: The Layered Architecture pattern separates the system into years (e.g.,
presentation, business logic, data access), making it easier to modify one layer
without affecting others.
• 3. Reliability:
• Explanation: Patterns ensure that the system remains functional even in case of
failures. They provide mechanisms for fault tolerance and recovery.
• Example: The Event-Driven Architecture ensures that components are decoupled
and can handle failures gracefully through asynchronous communication.
 4. Flexibility and Adaptability:
• Explanation: Architectural patterns provide a framework that can adapt to changes and new
requirements without significant redesign.
• Example: The Service-Oriented Architecture (SOA) allows for the reuse and combination of
services, making the system flexible and adaptable to new business needs.

• 5. Performance Optimization:
• Explanation: Properly chosen patterns can enhance the system's performance by optimizing
resource use and efficient processing Example: The Client-Server pattern distributes tasks
between clients and servers, optimizing performance by leveraging the strengths of both.

• 6. Security:
• Explanation: Architectural patterns incorporate security measures into the system's structure to
protect against threats.
• Example: The Layered Architecture pattern can include a dedicated security layer to handle
authentication and authorization, ensuring secure access.
7.Standardization
• Explanation: They provide a blueprint for designing systems that adhere to
industry best practices.

• 8. Reusability
• Explanation: Allow architects to leverage proven methodologies, reducing
risk and development time.

• 9. Interoperability
• Explanation: Enhance compatibility among system components and
external systems.
• Examples of Architectural Patterns:
• Layered architecture, micro-services, client-server, and event-driven architecture.
1. Micro-services:
• Definition: Decomposes an application into small, autonomous services, each
responsible for a specific functionality.
• Purpose: Enhances scalability and flexibility by allowing independent development
and deployment of services.

2. Model-View-Controller (MVC):
• Definition: Divides an application into three interconnected components:
Model (data), View (user interface), and Controller (business logic).
• Purpose: Improves modularity and maintainability by separating
concerns .
• 3. Layered Architecture:
• Definition: Organizes the system into layers, each with a specific responsibility,
such as presentation, business logic, and data access.
• Purpose: Simplifies design and maintenance by promoting separation of concerns.
• 4. Event-Driven Architecture:
• Definition: Uses events to trigger and communicate between decoupled services.
• Purpose: Increases responsiveness and flexibility by allowing the system to react in
real-time.
• 5. Client-server
• Definition: Divides the system into two main entities: client (requests services) and
server (provides services).
• Purpose: Enables centralized control and resource sharing, optimizing
performance.

• Architectural patterns are essential in designing robust, efficient, and maintainable

software systems, ensuring that they can meet current demands and adapt to future
requirements.
• 2.How do architectural patterns differ from design patterns? Provide examples to
illustrate the distinction

• Architectural Patterns
• Architectural patterns are high-level strategies that define the overall structure and
organization of software systems. They address large-scale design concerns, such as
scalability, reliability, and maintainability, and provide a blueprint for how the system's
components should interact.
• Examples:
• 1. Micro-services:
• Definition: Decomposes an application into a series of small, independent services,
each focused on a specific business capability.
• Purpose: Enhances scalability and flexibility by allowing independent development
and deployment of services.
• 2. Layered Architecture:
• Definition: Organizes the system into layers, each with a distinct responsibility (e.g.,
presentation, business logic, data access).
• Purpose: Simplifies maintenance and promotes separation of concerns.
• Design Patterns
• Design patterns are more granular solutions that address specific problems within a
smaller scope, typically within a single component or a small part of a system. They
provide solutions to recurring design problems and can be used within the context
defined by architectural patterns.
• Examples:
• 1. Singleton:
• Definition: Ensures a class has only one instance and provides a global point of
access to that instance.
• Purpose: Useful for managing shared resources, such as configuration settings or a
connection pool.
• 2. Observer:
• Definition: Defines a one-to-many dependency between objects so that when one
object changes state, all its dependents are notified and updated automatically.
• Purpose: Ideal for implementing event handling systems, such as UI frameworks.
• Key Differences
• Scope:
• ●Architectural Patterns: Concerned with the high-level structure of the entire system
(Address the high-level structure of an entire system or macro-level).
• ●Design Patterns: Focus on solving specific design issues within a particular scope
or component (Dealing with specific problems within components or modules).
• Level of Abstraction:
• ●Architectural Patterns: Operate at a higher level of abstraction, guiding the overall
organization of the system.
• They describe large-scale, structural decisions.
• ●Design Patterns: More detailed and concrete, dealing with individual components
or classes.
• They provide detailed, low-level design solutions.
• Impact:
• ●Architectural Patterns: Have a broad impact on the system's structure and design.
• ●Design Patterns: Have a localized impact, improving specific parts of the system.
• Example to Illustrate
• ●Architectural Pattern: The overall layout of the house (e.g., multi-story, single-story ranch)
defines the structure and flow of the entire building.
• Architectural patterns (layered architecture)
• Used in web applications with layers such as presentation, business logic and data access.
• Example; a typical three-tier web application with a front-end (User Interface), Middleware
(business logic) and back-end (databases).

• ●Design Pattern: Specific design solutions within the house, like the central heating system or the
layout of the kitchen cabinets.
• Design pattern (Factory method)
• Used to create objects without specifying their exact class.
• Example; A logging library that generates logs of different formats (e.g.. JSON or XML) based on
the user’s preference.
• Understanding the distinction between these patterns helps in choosing the right approach for
different levels of design challenges, ensuring both the high-level structure and the finer details of
the system are well thought out.
• 3. Why are architectural patterns essential in the design and development of complex
software systems?
• Architectural patterns are indispensable in managing the inherent complexity of large-
scale systems. They provide a systematic approach to design and development,
ensuring robustness, efficiency and adaptability.
• They are crucial in the design and development of complex software systems for
several reasons:
• Key Reasons:
• 1.Enable Scalability:
• Explanation: Architectural patterns help systems handle increasing loads effectively.
They ensure that as the system grows, it can manage more users, data, and
transactions.
• Example: The Micro-services pattern allows each service to be scaled
independently, which makes it easier to handle a large number of requests.
• 2. Maintainability:
• Explanation: By providing a clear structure and separation of concerns, architectural
patterns make the system easier to understand, modify, and extend.
• Example: The Layered Architecture pattern separates concerns into distinct layers
(e.g., presentation, business logic, data access), allowing changes to one layer with
minimal impact on others.
• 3. Promote Reliability and Fault Tolerance:
• Explanation: Established patterns have been tested across various scenarios,
minimizing unforeseen issues.
• These patterns ensure that the system can continue functioning smoothly, even when
parts of it fail.
• Example: The Event-Driven Architecture can handle failures gracefully by decoupling
the components and using asynchronous communication.
• 4. Reusability:
• Explanation: Architectural patterns promote the reuse of components and services
across different parts of the system or even in different projects.
• Example: The Service-Oriented Architecture (SOA) allows for the creation of
reusable services that can be used in multiple applications.

• 5. Flexibility and Adaptability:

• Explanation: They support evolving requirements by making systems easier to
modify or extend.
• These patterns provide a structured approach to accommodate changes and new
requirements without significant redesign.
• Example: The Micro-services pattern enables flexibility by allowing developers to
update, replace, or redeploy individual services independently.
• 6. Performance Optimization:
• Explanation: Patterns like event-driven or micro-services enhance responsiveness
and throughput.
• Properly chosen architectural patterns can enhance the overall performance of the
system by optimizing the use of resources.
• Example: The Client-Server pattern distributes processing tasks between clients
and servers, optimizing the system's overall performance.

• 7. Security:
• Explanation: Architectural patterns can help in designing secure systems by
incorporating security measures into the structure.
• Example: The Layered Architecture pattern can include a security layer to handle
authentication and authorization, ensuring secure access to the system.
• 8. Manage complexity and encourage modularity:
• Explanation: They breakdown complex systems into manageable components.
Hence, ensure that individual components can be developed, tested, and maintained
independently.

• 9.Improve team collaboration:

• Explanation: They offer a common vocabulary and structure, facilitating
communication among stakeholders.

Real-World Example:
• In the E-Commerce domain, a micro-services architecture enables independent
scaling of components like inventory, payments, and user authentication. This
ensures that a sudden surge in user activity doesn’t compromise the system’s overall
performance.
• Overall Benefits:
• ●Consistency: Ensures a consistent approach to solving architectural problems,
leading to a more cohesive system.
• ●Best Practices: Incorporates industry best practices, reducing the risk of common
pitfalls and mistakes.
• ●Communication: Provides a common language and understanding among
developers and stakeholders, facilitating better communication and collaboration.

• Architectural patterns are like the backbone of software systems, providing the
necessary structure to handle complexity, ensure robustness, and meet the evolving
needs of the business and users. They are essential for creating systems that are not
only functional but also efficient, reliable, and scalable
• THANK YOU