In software engineering, a design pattern is a general repeatable solution to a commonly occurring problem in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations. Learn how design patterns quickly solve common classes of problems and streamline communication between developers.

1. Software
Engineering
Why Design Patterns
are Important in
proteloinc.com | 916.943.4428

2. What is a
design
pattern?
In software engineering, a design pattern is a general
repeatable solution to a commonly occurring problem
in software design. A design pattern is not a finished
design that can be transformed directly into code. It is
a description or template for how to solve a problem
that can be used in many different situations.

3. Why are design
patterns important?
For a very long time there was a serious problem in software
engineering: you hire a newcomer to a project and no matter how
well they know the programming language, it takes them months to
get up to speed with how things are done in your project before they
can be productive.
The software industry has been trying to come up with ways to
improve this. Standardization of programming languages was one
way. Standard libraries (class libraries nowadays) has been another
way; however, one of the most important ways has perhaps been
design patterns.
So, are design patterns important? VERY.

4. There are two substantial
reasons for the existence
of design patterns.
The second benefit of design patterns is that
they are off-the-shelf solution-forms for
common problem-forms.
If you know your patterns and encounter a
problem where you need to find a good way
to get information from possibly multiple
producer objects to multiple consumer objects
without introducing unnecessary coupling
between classes, you will recognize “this is
a job for an Observer!” You will immediately
know how to solve your problem.
2.1. First, the use of design patterns streamlines
communication between developers.
If you and I both understand that when I say
“Observer,” I am talking about a very specific
structure of code, that means I can very
quickly describe how a bit of code which uses
that pattern works. The alternative is to fully
describe the solution which is time-consuming
and error-prone.

5. They allow you to quickly solve certain common classes of
problems, and then when done, you can quickly communicate
how you solved the problem.
This is all associated with a caveat which should seem obvious.
Don’t try to force problems into patterns that don’t fit. If the
pattern doesn’t fit the problem, then the solution will end up
being convoluted and contrived, and you will lose the effort
reduction benefit of patterns.
These benefits reinforce each other.

6. Creational Design Patterns:
Creational design patterns provide solutions to instantiate an object in the best possible way for specific situations.
Singleton patterns:
Singleton patterns, the most popular pattern, restricts the instantiation of a class and ensures that only one instance of
the class exists in the java virtual machine.
Factory pattern:
Factory pattern is used when we have a super class with multiple sub-classes and, based on input, we need to return
one of the sub-classes. This pattern removes the responsibility of instantiation of a class from the client program to the
factory class.
Abstract Factory Pattern
Abstract Factory pattern is similar to Factory pattern and it’s factory of factories. If you are familiar with factory design
pattern in java, you will notice that we have a single Factory class that returns the different sub-classes based on the
input provided, and factory class uses if-else or switch statement to achieve this. In Abstract Factory pattern, we get rid
of the if-else block and have a factory class for each sub-class, and then an Abstract Factory class that will return the
sub-class based on the input factory class.
Java Design Patterns are
Divided Into Three Categories:
Creational, Structural, and Behavioral

7. Abstract Factory Pattern:
Abstract Factory pattern is similar to Factory pattern and it’s factory of factories. If you are familiar with factory
design pattern in java, you will notice that we have a single Factory class that returns the different sub-classes based
on the input provided, and factory class uses if-else or switch statement to achieve this. In Abstract Factory pattern,
we get rid of the if-else block and have a factory class for each sub-class, and then an Abstract Factory class that will
return the sub-class based on the input factory class.
Builder Pattern:
This pattern was introduced to solve some of the problems with Factory and Abstract Factory design patterns when
the Object contains a lot of attributes. Builder pattern solves the issue with large numbers of optional parameters
and an inconsistent state by providing a way to build the object step-by-step and provide a method that will return
the final Object.
Prototype Pattern:
Prototype pattern is used when the Object creation is a costly affair, requires a lot of time and resources, and you
have a similar object that already exists. This pattern provides a mechanism to copy the original object to a new ob-
ject, and then modify it according to your needs. This pattern uses java cloning to copy the object.
Prototype design pattern mandates that the Object which you are copying should provide the copying feature. It
should not be done by any other class; however, whether to use shallow or deep copy of the Object properties de-
pends on the requirements and is a design decision.
Since we’ve only scratched the surface on this topic, more to come…

8. Need help designing your
NetSuite system to work
better for your business?
Our consultants are on-demand, no contract and no minimums.
Let’s talk today.
proteloinc.com | 916.943.4428