Pattern-Based

Design
Romel Raphael Nofuente | BSCS 3A
Design Patterns

Design patterns are proven solutions to common software design

problems. They represent reusable templates that developers can apply to
resolve issues encountered during software development. By incorporating
design patterns into their projects, developers can create more efficient,
maintainable, and scalable software solutions.
 Singleton Pattern
Ensures that a class has only one instance
and provides a global point of access to it.

Factory Pattern
Defines an interface for creating objects
but allows subclasses to alter the type of
objects that will be created.

Common Design Strategy Pattern

Patterns Defines a family of algorithms,
encapsulates each one, and makes them
interchangeable.
 Benefits of Design Patterns

Code Reusability Scalability Maintainability

Design patterns promote reuse By following established Design patterns improve code
of proven solutions, reducing design patterns, software readability and organization,
redundant code and systems can scale more making it easier to maintain
development time. effectively to accommodate and debug.
changing requirements.
Number of projects
using individual
patterns
In the figure, it shows the number of projects
in which each individual pattern is identified.
The pattern mentioned most in the analyzed
projects is the Singleton pattern. The reason
for this is that the Singleton pattern is very
simple and is easy to implement in Java.
This leads us to the conclusion that for Java
the application of the pattern Singleton
seems to provide important design
advantages at little implementation effort.
Pattern-Based Software
Design

Pattern-based software design involves the systematic application of design

patterns to create well-structured and maintainable software systems. By
leveraging established patterns, developers can address common design
challenges and ensure the quality and robustness of their software solutions.
 Pattern Selection Pattern
Developers must identify
Implementation

Key suitable design patterns

based on the specific
Once selected, design
patterns are implemented

Components requirements and within the software

architecture to address
constraints of their project.
of Pattern- specific design challenges.

Based
Software Pattern Pattern Evolution
Design Documentation Software systems evolve
Proper documentation of over time, and pattern-
applied design patterns based design
ensures clarity and accommodates changes
understanding for future by allowing for the
maintenance and addition or modification of
enhancements. design patterns as
needed.
Architectural Patterns

Architectural patterns provide high-level structure and guidance for organizing

the components and interactions within a software system. These patterns
define the overall layout and relationships between various elements,
facilitating the development of scalable, maintainable, and robust software
architectures.
 MVC (Model-View-Controller)
Separates an application into three
interconnected components: Model (data
representation), View (user interface), and
Controller (logic and flow control).

Microservices
Decomposes a large application into
smaller, independent services that
communicate through lightweight
protocols like HTTP or messaging queues.
Common
Architectural Layered Architecture

Patterns
Organizes components into horizontal
layers, such as presentation, business logic,
and data access, to promote separation of
concerns and modularity.
Flow diagram of
the Model View
Controller
The Model
The model contains all the data-related
logic that the user works with, like the
schemas and interfaces of a project, the
databases, and their fields.

The View
The view contains the UI and the
presentation of an application.

The Controller
And finally, the controller contains all the
business-related logic and handles
incoming requests. It is the interface
between the Model and the View.
Component-Level Design
Patterns

Component-level design patterns focus on the structure and interactions

between individual software components within a system. These patterns
provide solutions to common design problems encountered at the component
level, enhancing modularity, flexibility, and reusability of software components.
 Adapter Pattern
Allows incompatible interfaces to work
together by providing a bridge between
them.

Decorator Pattern
Dynamically adds responsibilities to
objects without altering their structure.

Common
Component- Proxy Pattern
Level Design Controls access to an object by acting as

Patterns an intermediary, providing additional

functionality such as lazy initialization or
access control.
Anti-Patterns

Anti-patterns are common design practices that result in inefficient, error-

prone, or difficult-to-maintain software systems. Recognizing and avoiding
anti-patterns is crucial for ensuring the quality and long-term viability of
software projects.
 God Object
A single object that knows or does too
much, violating the principle of separation
of concerns.

Spaghetti Code
Unstructured, tangled code that is difficult
to understand, maintain, or modify.

Common Anti- Tight Coupling

Patterns Excessive dependencies between
components, making the system less
flexible and harder to refactor or extend.
User Interface Design
Patterns

User Interface (UI) design patterns provide standardized solutions to common

usability and interaction challenges encountered in software applications. By
leveraging established UI patterns, designers can create intuitive, consistent,
and user-friendly interfaces that enhance the overall user experience.
 Modal Windows
Organizes content into separate, visually
distinct cards for easy scanning and
navigation.

Card Layouts
Organizes content into separate, visually
distinct cards for easy scanning and
navigation.

Common User
Interface Navigation Patterns

Design Patterns
Defines the structure and layout of
navigation elements such as menus,
tabs, and breadcrumbs to facilitate
intuitive navigation.
Information
Architecture
Information architecture dictates how you
structure and present content to the user. It
concerns everything you have in your
product, and how all of that can be
organized so that it makes sense and can
be easily found during use.

Consider Medium - a platform that has a

vast amount of content that just keeps
increasing everyday. The designers behind
Medium needed to consider not just how to
present categories to users but also how
this content would grow over time.

Your website wireframe design needs to

include things such as navigation flow and
content placement – both of which are
closely related to the information
architecture in your product
Conclusion

Pattern-based design is a powerful approach for creating high-quality software

systems. By leveraging design patterns, developers can:
Enhance code reusability, scalability, and maintainability.
Improve software architecture by applying architectural patterns.
Enhance component-level design with reusable solutions.
Avoid common pitfalls and inefficiencies by recognizing and addressing anti-
patterns.
Create intuitive and user-friendly interfaces using established UI design patterns.
Conclusion

30.2
By incorporating pattern-based design principles into their projects, developers
can streamline development processes, reduce errors, and deliver software
solutions that meet user expectations and industry standards.

Pattern-based design is not a one-size-fits-all solution, and it's essential to

adapt patterns to the specific needs and requirements of each project.
Continuously learning and experimenting with new patterns and best practices
is key to staying ahead in the ever-evolving field of software development.
References

30.2
Hahsler, M. (2004). A Quantitative Study of the Adoption of Design Patterns by Open Source
Software Developers. Department of Information Business.
[Link]

Kumar, N. (2021). How the Model View Controller Architecture Works – MVC Explained.
FreeCodeCamp. [Link]

Costa, R. (2019). The complete guide to website wireframe design. Justinmind.

[Link]
Thank you!