DESIGN PATTERNS 2.

Summary

1. The Singleton Pattern ensures only one instance of

Key Insights a class exists and provides global access to it. It is
useful for scenarios like database connections
where only one instance is needed.
• Design patterns offer a systematic
approach to solving common
programming problems, based on the Key Insights
experiences and best practices of expert
developers. They provide a structured way • The Singleton Pattern is useful in scenarios
of thinking and help in designing robust where only one instance of a class should
and maintainable software. exist and be globally accessible. It provides
• One of the key benefits of design patterns a centralized way to manage and access
is their ability to make code more flexible the object.
and extensible. By following the templates • By encapsulating the object’s attributes in
provided by design patterns, developers a Singleton class, we can ensure that all
can create code that is closed for parts of the application use the same
modification but open for extension, instance and avoid duplication.
reducing the need for frequent code • Using a Singleton for resources like
changes. database connections can improve
• The Gang of Four book, published in the performance by reusing the same instance
mid-90s, introduced 23 design patterns instead of creating a new one every time.
that have become widely recognized and • Synchronization is necessary in a multi-
used in the software development threaded environment to prevent multiple
industry. These patterns are grouped into threads from creating different instances
three categories: Creational, Structural, simultaneously. This ensures thread safety
and Behavioral patterns. and consistency.
• Creational patterns focus on object • The double-checked locking idiom
creation and provide flexible ways to optimizes synchronization by checking if
instantiate objects, allowing developers to the instance is null before acquiring the
avoid creating multiple overloaded lock. This avoids unnecessary
constructors or passing null values for synchronization in common cases.
unused attributes. • The use of the volatile keyword ensures
• Structural patterns guide the design of that the Singleton instance is correctly
classes and their relationships, enabling handled by multiple threads, preventing
developers to create code that is modular, issues like partial object construction and
reusable, and efficient. Patterns like the application crashes.
Flyweight pattern help minimize memory • Storing the Singleton instance in a local
usage by sharing common data between variable can further improve performance
similar objects. by reducing direct reads from memory,
• Behavioral patterns address how objects resulting in faster access and better
communicate and collaborate at runtime. efficiency.
Patterns like the Strategy pattern provide
different algorithms or strategies that can 3.Summary
be dynamically selected based on the
situation, enhancing flexibility and code The video explains the Factory Method pattern and
reusability. its implementation in Java. It discusses the
• By understanding and applying design limitations of a simple factory and introduces the
patterns, developers can improve their Factory Method pattern to address those
problem-solving skills and create more limitations. The pattern allows for the creation of
efficient and maintainable software objects without specifying their exact types and
systems. Regular practice and learning promotes code extensibility and adherence to
from experienced developers can enhance design principles.
the utilization of design patterns in real-
world scenarios. Key Insights
•
 • The Factory Method pattern allows for the their usage. This improves code
creation of objects without specifying their organization and maintainability.
exact types, promoting code extensibility. • The pattern allows for easy scalability, as
• By separating the creation code from the new concrete factories can be added to
code that uses the product, the Factory handle the creation of additional products
Method pattern adheres to the single without impacting existing code.
responsibility principle. • The Abstract Factory Pattern is a powerful
• The Factory Method pattern helps in tool for managing complex object creation
adhering to the open-closed principle by scenarios, especially when dealing with
allowing the addition of new types of families of related products. It provides a
products without modifying existing client structured and flexible approach to handle
code. diverse product requirements.
• The structure of the Factory Method • By using interfaces and abstract classes,
pattern consists of a product interface, the pattern enables loose coupling
concrete products, a creator class with a between the client code and the concrete
factory method, and concrete creators. classes, making the code more modular
• The Factory Method pattern is useful and easier to maintain.
when the exact types and dependencies of • The Abstract Factory Pattern helps in
objects are unknown beforehand, allowing achieving code reusability and separation
for easy extension of the product of concerns. It allows for the creation of
construction code. different product families, ensuring that
• The need for the Abstract Factory pattern the client code is not tightly coupled to
arises when variations like the Italian specific product implementations.
option need to be added, as the Factory
Method pattern alone may lead to code 5.Summary
modification.
• The Factory Method pattern is a powerful The Builder Pattern is a creational design pattern
creational design pattern that promotes that allows for step-by-step creation of complex
code flexibility and maintainability. objects. It solves the problem of initializing multiple
fields in a constructor and provides flexibility in
object creation.

4.Summary Key Insights

The video explains the Abstract Factory Pattern, a • The Builder Pattern solves the problem of
creational design pattern that allows the initializing complex objects with multiple
production of families of related objects without fields by providing a step-by-step
specifying their concrete classes. construction process. This avoids the need
for a monstrous constructor or scattered
Key Insights code.
• The Director class in the Builder Pattern
• The Abstract Factory Pattern is useful allows for the encapsulation of
when code needs to work with different construction routines and the reusability
families of related products without of construction steps across different parts
depending on specific concrete classes. of an application.
This promotes flexibility and allows for • The flexibility of the Director class in
easier customization. handling different builder
• The pattern helps follow the open-closed implementations allows for the creation of
principle by centralizing the product different types and representations of
creation code in one place. This makes it objects using the same construction
easier to add or modify products without process.
modifying existing code. • By creating a common builder interface,
• The Abstract Factory Pattern promotes the the Builder Pattern enables the use of the
single responsibility principle by same step-by-step construction process
separating the creation of products from for different types of objects. This
 promotes code reuse and consistency in the pattern avoids the need to recreate
construction processes. objects from scratch, improving
• The class diagram of the Builder Pattern performance and efficiency.
includes the builder interface, concrete
builders, and product classes. This helps 7.Summary
visualize the structure and relationships
between the components of the pattern. The Chain of Responsibility Pattern is a behavioral
design pattern that allows a request to pass through
6.Summary a chain of handlers, with each handler having the
option to process the request or pass it to the next
The Prototype pattern is a creational design handler.
pattern that allows for the creation of exact copies
of objects without coupling them to their concrete Key Insights
classes. It provides a solution for cloning objects
and can be useful in scenarios where object fields • The Chain of Responsibility Pattern is
are private or when dealing with third-party based on the real-life analogy of
applications or dependencies. transferring a request from one operator
to another until it can be resolved. This
Key Insights pattern allows for flexible and dynamic
handling of requests.
• The Prototype pattern solves the problem • The pattern consists of concrete handlers,
of creating exact copies of objects without which contain the code for processing
relying on their concrete classes. It requests, and a base handler that stores a
provides a way to clone objects that have reference to the next handler in the chain.
private fields or unknown concrete The client composes the chain of handlers
classes. and can trigger any handler in the chain.
• By using a common interface with a clone • The chain of handlers can be modified at
method, the Prototype pattern decouples runtime, allowing for flexibility in adding,
the creation of objects from their classes. removing, or reordering handlers. This
This allows for more flexibility and reduces makes the pattern suitable for scenarios
dependencies on specific classes. where the order or composition of
• Cloning objects using the Prototype handlers may vary.
pattern is more efficient than manually • The Chain of Responsibility Pattern can be
copying fields. It avoids the need to know particularly useful in scenarios where
the internal structure of an object and there are multiple steps or checks involved
handles the cloning process automatically. in processing a request, and each step can
• The Prototype pattern is particularly useful be handled by a separate handler. It
when dealing with private fields that promotes loose coupling between
cannot be accessed directly, or when handlers and enhances code reusability.
working with third-party applications or • The example of a credit card suspension
dependencies that provide concrete and the interaction with multiple
objects without exposing their classes. operators demonstrates how the Chain of
• The Prototype pattern introduces a Responsibility Pattern works in a real-life
common interface with a clone method, scenario, where a request is passed along
allowing clients to produce copies of a chain until it can be resolved.
objects that implement this interface.
These objects are called Prototypes. 8.Summary
• The Prototype Registry is a centralized
place to store frequently accessed The Command Pattern is a behavioral design
prototypes. It can be implemented as a pattern that encapsulates requests or behaviors
map, where clients can search for a into standalone objects, allowing for flexibility and
specific prototype based on a search reuse in an application.
criterion and clone it.
• The Prototype pattern saves resources and
time, especially when object creation is a
heavy process. By cloning existing objects,
Key Insights • In the context of game loading screens, the
Template Method Pattern enables
• The Command Pattern solves the problem efficient development of loading screens
of having an enormous number of for different games with shared steps and
subclasses and the risk of breaking code varying implementations.
when modifying the logic in the base class. • The pattern helps in eliminating code
• By moving the light switching logic from duplication and improving code
the Room and FloorLamp classes to the maintainability by separating common
Light class, the Command Pattern steps from game-specific steps.
encapsulates the logic and allows for easy • The Template Method Pattern provides a
modification across the application. flexible and scalable solution for managing
• Extracting request details into a separate complex algorithms in a structured
class with a single method allows for manner.
better adherence to the single
responsibility principle and improves 10. Summary
flexibility in the program.
• The Command Pattern allows for runtime The Mediator Pattern is a behavioral design pattern
decisions, assignments, and configuration that reduces dependencies between objects by
of objects by the client, providing more introducing a mediator object. It encapsulates how
flexibility in how objects are used. a set of objects interact with one another, enabling
• One of the main benefits of the Command indirect communication and facilitating reuse of
Pattern is its ability to queue, schedule, components.
log, or send commands over a network,
thanks to the serialization of command Key Insights
objects.
• The Command Pattern provides a clean • The Mediator Pattern is inspired by the
and maintainable solution for handling role of an air traffic controller, illustrating
requests and behaviors in an application. the need for coordinated communication
• The example of a smart home automation between objects in a system.
app demonstrates how the Command • By reducing direct dependencies, the
Pattern can be applied to control the lights Mediator Pattern promotes loose coupling
in different rooms and objects within the and improves the maintainability and
house. flexibility of the codebase.
• The pattern can be applied to UI
9. Summary components, enabling generic and
reusable elements that can be easily
The video explains the Template Method Pattern in integrated into different parts of an
Java, focusing on game loading screens and the application.
benefits of code reuse and structure. • The mediator class acts as a centralized
communication hub, defining the methods
Key Insights and protocols for interaction between
components.
• The Template Method Pattern is a • Concrete mediators manage the
behavioral design pattern that defines the relationships between components,
skeleton of an algorithm in a superclass. maintaining references and potentially
• By breaking down the algorithm into steps managing their lifecycles.
and providing a template method, the • The Mediator Pattern allows for the reuse
pattern allows for code reuse and of components in different applications by
customization. simply providing them with a new
• Subclasses can override specific steps to mediator class.
provide their own implementations while • Introducing a new mediator class opens up
maintaining the overall structure. possibilities for new communication
• The pattern is beneficial in scenarios patterns and behaviors between
where an algorithm has a defined components, enhancing their capabilities.
structure but requires customizable steps.
11. Summary
The Memento Pattern is a Behavioral Design • The Observer Pattern provides a
Pattern that allows objects to save and restore their subscription mechanism where customers
previous state without exposing implementation can choose when and what they want to
details. It delegates the creation of state snapshots be notified about, avoiding unnecessary
to the object itself, ensuring data safety and trips to the store or receiving unwanted
security. notifications.
• Implementing the Observer Pattern allows
Key Insights for the easy addition of new types of
listeners, enabling the system to adapt to
• The Memento Pattern solves different notification preferences, such as
encapsulation issues by allowing objects to email or push notifications.
create snapshots of their own state, • Transforming the list of subscribers into a
eliminating the need for other objects to map based on events provides a more
invade private spaces. organized and efficient way to handle
• By delegating the creation of snapshots to notifications for different events, ensuring
the object itself, the Memento Pattern that the right subscribers are notified for
ensures that the original object’s data each event.
remains secure and inaccessible to other • The Observer Pattern promotes loose
objects. coupling between publishers and
• The Memento Pattern structure consists subscribers, as the publisher is not directly
of the Originator, Memento, and dependent on the concrete subscriber
Caretaker classes. The Originator produces classes. This enhances flexibility and
snapshots, the Memento acts as a value maintainability of the codebase.
object, and the Caretaker manages the • Understanding the Observer Pattern and
history of snapshots. its class diagram helps developers visualize
• The Memento Pattern provides a reliable and design systems that require event-
undo feature by storing snapshots in a based communication between objects,
history, allowing objects to restore improving code structure and modularity.
previous states when needed.
• Using the Memento Pattern enhances 13. Summary
code maintainability by separating the
responsibility of creating and managing The video explains and implements the State
snapshots from other objects, improving Pattern in Java, using the example of a
overall code organization and readability. smartphone’s different states and buttons.
• The Memento Pattern is a powerful tool
for implementing undo functionality in Key Insights
applications, meeting the expectation of
users who have come to rely on this • The State Pattern is a powerful tool for
feature in modern apps. modeling systems with different states
• The Memento Pattern is a flexible and and behaviors. It allows for clean and
adaptable solution that can be applied to organized code by encapsulating state-
various scenarios where state specific logic in separate classes.
preservation and restoration are required. • By using the State Pattern, the behavior of
an object can be easily modified and
12. Summary extended without the need for extensive
code changes. This promotes code
The video script explains the Observer Pattern, reusability and maintainability.
which is a behavioral design pattern used to notify • The State Pattern is particularly useful in
multiple objects about events. It demonstrates how scenarios where an object’s behavior
to implement the pattern in Java for a store- changes dynamically based on internal
customer scenario. states. It provides a flexible and scalable
solution for managing complex state
Key Insights transitions.
• The State Pattern promotes loose coupling
between objects, as the context object
interacts with state objects through a
 common interface. This enhances code • Implementing the Strategy pattern can
flexibility and promotes separation of improve code readability, maintainability,
concerns. and extensibility in complex systems.
• The State Pattern is also well-suited for • The Strategy pattern can be applicable in
scenarios where the number of states and various scenarios, beyond just payment
state transitions is expected to change systems, where interchangeable behaviors
frequently. It provides a modular and are required.
scalable approach to handle such dynamic
scenarios. 15. Summary
• By applying the State Pattern, developers
can adhere to important software design The Iterator Pattern is a behavioral design pattern
principles such as single responsibility and that allows traversal of a collection without
open-closed. This leads to cleaner code, exposing its underlying implementation. It
easier maintenance, and improved overall encapsulates traversal details and enables multiple
software quality. independent iterators to traverse the collection
• Understanding the differences between simultaneously.
the State Pattern and the Strategy Pattern
is crucial. While both patterns involve Key Insights
behavior delegation, the State Pattern
allows for dynamic state changes and
• The Iterator Pattern is similar to hiring a
state-dependent actions, whereas the
local guide in a new city. Just like the guide
Strategy Pattern focuses on
tailors the tour to your liking, the iterator
interchangeable algorithms with fixed
visits elements of the collection according
outcomes.
to the chosen algorithm.
• The iterator object encapsulates traversal
14. Summary
details, such as the current position and
the number of elements remaining,
The video explains the Strategy Design Pattern in ensuring independent traversal by
Java and its implementation in a payment system multiple iterators.
for a food delivery app. It demonstrates how the • The iterator interface provides operations
pattern allows for interchangeable and easily for traversing the collection, while
maintainable payment methods. concrete iterators implement specific
traversal algorithms.
Key Insights • Collections and iterators are accessed
through interfaces, allowing clients to
• The Strategy Design Pattern helps avoid work with different collection types and
code duplication and allows for the easy iterators without coupling to specific
addition of new behaviors without classes.
modifying existing code. • By applying the Iterator Pattern, code
• By isolating each payment method in its duplication is reduced, and the single
own class, the pattern ensures that the responsibility and open-closed principles
code follows the single responsibility are followed.
principle. • The pattern is applicable in a variety of
• The Strategy pattern provides flexibility scenarios, including graph traversal, tree
and maintainability by allowing strategies traversal, and iterating over database
to be easily replaced or interchanged at query results.
runtime. • The Iterator Pattern improves code
• The State pattern, although similar to the maintainability and flexibility by
Strategy pattern, focuses on behavior separating traversal logic from the
variations based on different states, rather collection implementation.
than interchangeable behaviors.
• The Strategy pattern promotes the use of 16. Summary
composition and polymorphism to achieve
flexibility and modularity in code design. The video explains the Visitor design pattern in
Java, using an example of implementing an ad-
messaging functionality for an insurance company. systems. It provides a way to bridge the
The pattern helps separate algorithms or behaviors gap between incompatible interfaces and
from the objects they operate on, promoting single allows for seamless collaboration between
responsibility and open-closed principles. different components.
• The use of inheritance and composition in
Key Insights the Adapter Pattern provides flexibility in
adapting different interfaces. Inheritance
• The Visitor pattern promotes separation of allows the adapter class to extend the
concerns by isolating behaviors from interface of the client code, while
objects, improving the maintainability and composition allows it to wrap the
flexibility of the codebase. incompatible service object.
• By using Double-Dispatch, the Visitor • The Adapter Pattern is particularly useful
pattern allows dynamic method dispatch when dealing with third-party libraries
based on the type of the visitor and the that have specific data format
concrete element, enabling proper requirements. It allows developers to
method execution. transform their existing data into the
• The Visitor pattern follows the open- required format without having to modify
closed principle by allowing the the library or access its source code.
introduction of new behaviors without • By separating the adapting behavior into
modifying existing ones, promoting code its own class, the Adapter Pattern adheres
extensibility. to the single responsibility principle. This
• The Visitor pattern can be useful in promotes modularity and maintainability
scenarios where complex operations need in the codebase, as each class is
to be performed on a collection of objects responsible for a specific task.
without modifying their structure. • The Adapter Pattern also follows the open-
• Although the Visitor pattern adds closed principle, as it allows for the
complexity to the code by introducing introduction of new adapters without
additional classes and methods, it provides modifying the existing client code. This
a clean and modular solution for promotes code reusability and
separating behaviors. extensibility, as new adapters can be easily
• The Visitor pattern can be combined with added to handle different data formats or
other design patterns, such as the integrate with new services.
Composite pattern, to further enhance the • The adapter class acts as a middle layer
flexibility and functionality of the between the client code and the service,
codebase. translating the client’s calls into something
• Applying the Visitor pattern in the that the service can understand and use.
insurance example allows the software This decoupling of the client and service
developer to easily add new messaging allows for easier maintenance and updates
behaviors without modifying the client in the future.
classes, ensuring future scalability and • The Adapter Pattern simplifies the usage
maintainability. of third-party libraries by treating them as
if they were part of the original codebase.
Developers can seamlessly integrate new
17. Summary
functionalities and components without
worrying about breaking existing
The Adapter Pattern is a structural design pattern functionality or dealing with incompatible
that allows objects with incompatible interfaces to interfaces.
collaborate with each other. It can be used to
transform data from one format to another,
18. Summary
enabling the use of third-party libraries.

The Bridge Design Pattern allows for the

Key Insights
organization of a class with multiple variants into
two separate hierarchies, providing flexibility and
• The Adapter Pattern is commonly used in ease of switching between implementations at
software development when integrating runtime.
legacy or third-party code with existing
Key Insights the need for complex and repetitive code,
as the calculation is handled recursively.
• The problem with using class inheritance is • The tree structure of the Composite
that it leads to an exponentially growing Pattern makes it intuitive to work with and
hierarchy when extending multiple understand. The hierarchy of objects
dimensions. resembles a real-life tree, with branches
• The Bridge Design Pattern solves this representing composite objects and leaves
problem by using composition and representing simple objects.
separating the class hierarchy into • The Component interface defines the
abstraction and implementation. common operations that can be
• The abstraction layer delegates the work performed on both simple and complex
to the implementation layer, providing a objects. This abstraction allows the client
high-level control interface. to interact with objects using a uniform
• Concrete implementations contain specific approach, regardless of their complexity.
behaviors for each implementation logic, • The Composite Pattern aligns with the
allowing for variation. open-closed principle by allowing new
• The client code works with the abstraction elements to be added to the system
layer, unaware of the implementation without modifying existing code. This
details. promotes code extensibility and
• The Bridge Design Pattern follows the maintainability.
principles of single responsibility and • The Composite Pattern provides a solution
open-closed, allowing for easy to the limitations of a generic approach by
introduction of new abstractions and offering a structured and scalable way to
implementations. handle hierarchical systems. It simplifies
• The Bridge Design Pattern provides the code and enhances its flexibility,
flexibility and modularity, making it easier making it an effective design pattern for
to switch between implementations at various scenarios.
runtime.
20. Summary
19. Summary
The video covers the Decorator Design Pattern,
The video explains the Composite Design Pattern which is a structural design pattern that allows
and its implementation in Java. It demonstrates adding new behaviors to an object by wrapping
how the pattern can be used to calculate the total it in a special decorator object. It demonstrates
price of products in a hierarchical structure. this pattern through an example of a
notification service for a food delivery app,
where different decorators can be added to a
Key Insights
base notifier to enable notifications via email,
WhatsApp, Facebook, etc. The video explains
• The Composite Design Pattern is useful the structure and advantages of the Decorator
when working with hierarchical structures, pattern, such as adhering to the Single
as it allows objects to be organized in a Responsibility and Open-Closed principles, and
tree-like manner. This can be particularly enabling runtime composition of behaviors.
helpful in scenarios such as the Amazon
delivery system, where boxes can contain
21. Facade pattern - is a structural design
products and smaller boxes.
pattern that provides a simplified interface to a
• By implementing the Composite Pattern,
complex system, library, or framework. By
the code becomes more flexible and
centralizing and managing the interactions
scalable. It becomes easier to add new
with the underlying subsystems, it improves
types of products or boxes without
readability, usability, and maintainability of the
modifying existing code, thanks to the use
code. The Facade Pattern reduces code
of a common interface.
duplication, adheres to the single responsibility
• The Composite Pattern simplifies the
principle, and decouples the client from the
calculation of total prices by allowing the
intricate details of the subsystem, making the
objects themselves to pass the request
system easier to understand and modify.
down the tree structure. This eliminates
22. Flyweight Pattern - is a structural design - Service Interface: Defines the interface for
pattern that optimizes memory usage by the service, e.g., `Internet` or
sharing common parts of the state between `VideoDownloader`.
multiple objects. This pattern helps manage
large numbers of similar objects by separating - Real Service: The actual implementation,
the object's state into intrinsic (shared, e.g., `RealInternet` or `RealVideoDownloader`.
immutable) and extrinsic (unique, mutable)
parts. It involves: - Proxy Class: Implements the service
interface and adds extra functionality. It has a
1. Flyweight Class: Stores the intrinsic state reference to the real service object.
that can be shared among objects.
- Client: Works with both the real service and
2. Context Class: Contains the extrinsic state, proxy via the same interface, allowing seamless
unique to each object. substitution.

3. Flyweight Factory: Manages and reuses 4. Benefits:

flyweight objects to avoid redundant creation.
- Controlled Access: Manage access to the
4. Client: Interacts with flyweight objects as if object.
they were regular objects.
- Performance Optimization: Use caching to
The Flyweight Pattern is useful when dealing avoid redundant operations.
with a massive number of similar objects that
consume significant memory. It should be - Lifecycle Management: Handle the creation
applied only when memory optimization is and destruction of service objects.
necessary.
- Open-Closed Principle: Introduce new
23. Proxy Pattern is a structural design pattern proxies without changing existing services or
that provides a substitute or placeholder for clients.
another object, controlling access to it. Here's
a breakdown:

1.Functionality: Proxies can act as

INTER-SYSTEM COMMUNCATIONS
intermediaries to perform actions before or
after requests reach the actual object. They can
restrict access, cache results, or manage object • Is the communications between a set of
lifecycle. heterogeneous systems that are
integrated together.
• These integrated systems which put
2. Use Cases:
together many heterogenous set of
subsystems and the produced objects are
- Access Control: In our example, an `Internet` extremely different, yet should contribute
class allows connection to websites. A to the same process.
`ProxyInternet` class checks against a list of
• Software integration includes one or more
banned websites and restricts access
of the following:
accordingly.
1. System Integration – Given two or more
systems, subsystems or components, each
-Caching: A `VideoDownloader` class of which function properly
downloads videos from YouTube. A • The problem is to integrate them into one
`ProxyVideoDownloader` caches previously larger system satisfying the combined
downloaded videos, preventing redundant requirements within the newly formed
downloads. environment
2. Technology Integration – This may have
3. Class Diagram: been functioning properly in the field for a
significant period
 • The problem is to integrate a new function
or a new technology within the system.
• Should provide the new functionality or
use the new technology, while preserving
the original system dunctionality.
3. Incremental Engineering
• A software can be developed and
delivered using available technologies and
with less functionality than it is intended
finally provide.
• The problem us to design the system with
such future integration in mind
4. Modification – sometimes an existing and
properly functioning software system
must be decomposed and integrated to
carry out modification.
5. The Need for Integration – Most of
organization consists of more than one
department, running department specific • Allows the integration of new software
applications and those applications through the existing presentations of the
interact with each other. legacy software. This is typically used to
• Applications originally intended to operate create a new user interface but may be
separately, later on are required to used to integrate with other applications.
interoperate with others.
• Some of the reasons for integration are the
following:
• Technology change affects all layers;
legacy does not go away so easily.
• The architecture of the organization
information system depends on
constraints related to the technology but
also to the organization.
• Integration assists in formation of Zero
Latency organization - when all functions
within the organization work with the
same up-to-date information, latency
between applications is eliminated/
reduced.

INTEGRATION MODELS

• Integration model defines how

applications will be integrated by defining
the nature of and mechanismsfor
integration.

These models include;

• Presentation Integration
• Data Integration
• Function Integration