8 Design Patterns EVERY Developer Should Know

Summary

This video delves into eight essential design patterns every developer should know, as outlined in the seminal book 'Design Patterns' by the Gang of Four. It covers creational patterns like Factory and Singleton, structural patterns such as Adapter and Facade, and behavioral patterns including Observer and Strategy. The script uses relatable examples, like ordering a burger or YouTube notifications, to explain these patterns, aiming to simplify complex programming concepts for better software design.

Takeaways

• 📚 The video discusses eight essential design patterns from the book 'Design Patterns: Elements of Reusable Object-Oriented Software' by the 'Gang of Four'.
• 🍔 The Factory pattern is likened to ordering a burger at a restaurant, where a factory class instantiates objects without exposing the instantiation logic to the client.
• 🏗️ The Builder pattern provides a step-by-step approach to object creation, allowing for more control over the construction process.
• 🔒 The Singleton pattern ensures a class has only one instance and provides a global point of access to it, useful for maintaining a single copy of application state.
• 📢 The Observer pattern, also known as the pub-sub pattern, allows multiple objects to listen for and respond to events, as exemplified by YouTube notifying subscribers of new uploads.
• 🔄 The Iterator pattern simplifies the way we traverse through elements of a collection without exposing its underlying representation.
• 🛠️ The Strategy pattern enables the dynamic selection of an algorithm from a family of algorithms, allowing behavior to be selected at runtime without modifying the class.
• 🔌 The Adapter pattern allows objects with incompatible interfaces to collaborate by converting the interface of one class into an interface expected by the clients.
• 🎭 The Facade pattern provides a simplified interface to a complex subsystem, hiding the complexities behind a single, unified interface.
• 📈 The video emphasizes the importance of design patterns in software development, highlighting their relevance even in the rapidly changing landscape of JavaScript frameworks.
• 📘 The presenter mentions a new course on object-oriented design patterns, including video lessons, written articles, and code examples in four programming languages.

Q & A

What are the three categories of design patterns introduced by the 'Gang of Four'?

The three categories of design patterns are creational patterns, structural patterns, and behavioral patterns.

What is the purpose of the Factory design pattern?

The Factory design pattern is used to create objects without exposing the instantiation logic to the client and refers to the newly created object using a common interface.

Can you explain the concept of the Builder pattern in the context of making a burger?

The Builder pattern allows for the construction of complex objects step by step. It provides a way to create a complex object by adding one part at a time, which can be useful when the construction process is complex and requires setting a lot of parameters.

What is a Singleton pattern and how is it used in an application?

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. It is used for maintaining a single copy of an application state, such as tracking whether a user is logged in.

How does the Observer pattern, also known as the pub-sub pattern, work in the context of YouTube?

The Observer pattern allows multiple observers to listen for and respond to events. In the context of YouTube, the channel acts as the subject (publisher), and subscribers are the observers. When a new video is uploaded (event), all subscribers receive a notification.

What is the role of the Iterator pattern in programming?

The Iterator pattern provides a way to access the elements of an object sequentially without exposing its underlying representation. It is used to traverse complex data structures in a simple and consistent manner.

Can you describe the Strategy pattern and its benefits?

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the behavior of an object to be changed at runtime, following the open-closed principle, which states that software entities should be open for extension but closed for modification.

What is the Adapter pattern and how does it solve compatibility issues?

The Adapter pattern is a structural pattern that allows objects with incompatible interfaces to work together by wrapping their own interface around that of an existing class. It can be used to make a micro USB cable compatible with a standard USB port by using an adapter.

What does the Facade pattern conceal and why is it used?

The Facade pattern conceals the complex reality of a system's internal workings. It provides a simplified interface to a more complex subsystem, making the system easier to use and understand.

What is the significance of the book 'Design Patterns: Elements of Reusable Object-Oriented Software'?

The book, authored by the 'Gang of Four,' is significant as it introduced 23 fundamental object-oriented design patterns, which are still widely discussed and used in software development, demonstrating their enduring value.

How does the script relate the design patterns to everyday life examples, such as ordering a burger?

The script uses the example of ordering a burger to illustrate the Factory pattern, where you can order different types of burgers without worrying about the ingredients and assembly process, just like you would at a restaurant.

Outlines

00:00

🔧 Design Patterns in Programming

This paragraph introduces the concept of design patterns, a fundamental topic in software development. It references the seminal work by the 'Gang of Four' from 1994, which introduced 23 object-oriented design patterns categorized into creational, structural, and behavioral patterns. The speaker humorously relates the longevity of this book to the rapidly changing landscape of JavaScript frameworks. The paragraph sets the stage for an exploration of eight design patterns, starting with the factory pattern, which is likened to ordering a burger without worrying about the ingredients. It also mentions the builder pattern for more control over object creation and the singleton pattern for ensuring a single instance of a class, using the example of application state in an app. The paragraph concludes with the observer pattern, which is compared to a publisher-subscriber model, using YouTube as an example to illustrate how subscribers receive notifications about new content.

05:02

🔄 Iterator and Behavioral Patterns

The second paragraph delves into the iterator pattern, which defines a way to iterate over elements of an object without exposing its underlying structure. It contrasts simple iteration in Python with the need for a custom iterator for complex data structures like linked lists. The strategy pattern is then introduced, allowing for the dynamic alteration of an algorithm's behavior at runtime, exemplified by different filtering strategies for an array. The adapter pattern is described as a structural pattern that makes incompatible interfaces compatible, using the analogy of physical adapters like a USB to micro-USB converter. Finally, the facade pattern is introduced, which provides a simplified interface to a complex system, hiding the intricate details from the user. The paragraph ends with a plug for the speaker's object-oriented design interview course, which covers these patterns in more depth.

Keywords

💡Factory

The factory pattern is a creational design pattern that provides an interface for creating objects without specifying their concrete classes. In the video, it is compared to ordering a burger, where the factory creates the burger for us based on the desired type, such as a cheeseburger or a vegan burger.

💡Builder

The builder pattern is another creational design pattern that allows for constructing complex objects step by step. It provides more control over the construction process compared to the factory pattern. In the video, it's likened to assembling a burger by adding ingredients one at a time using a builder, which allows chaining methods for each ingredient and finally building the complete burger.

💡Singleton

The singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is useful for managing shared resources or application state. The video illustrates this with an application state that tracks whether a user is logged in, ensuring that only one instance of this state exists at any time.

💡Observer

The observer pattern, also known as the pub-sub (publisher-subscriber) pattern, is a behavioral design pattern where an object (the subject) maintains a list of dependents (observers) and notifies them of any state changes. The video uses the example of YouTube, where subscribers receive notifications when a new video is uploaded by a channel they follow.

💡Iterator

The iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. The video explains this with an example of iterating through a linked list in Python, where a custom iterator helps traverse the list's elements easily.

💡Strategy

The strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This allows the algorithm to vary independently from clients that use it. In the video, it is exemplified by filtering an array using different strategies to remove either positive values or odd values.

💡Adapter

The adapter pattern allows incompatible interfaces to work together by converting the interface of a class into another interface expected by the clients. The video gives the example of using a micro USB to USB adapter to connect a micro USB cable to a USB port, demonstrating how the adapter facilitates compatibility.

💡Facade

The facade pattern provides a simplified interface to a complex subsystem, making it easier to use. The video describes it as a wrapper class that abstracts away lower-level details. An example is HTTP clients that hide the complexity of network operations, allowing programmers to use simpler interfaces.

💡Creational Patterns

Creational patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The video mentions the factory, builder, and singleton patterns as examples of creational patterns that help manage the process of object creation in different ways.

💡Behavioral Patterns

Behavioral patterns are design patterns that deal with object collaboration and delegation of responsibilities. They focus on how objects communicate and interact. The video discusses the observer and strategy patterns as examples of behavioral patterns that help manage object interactions and behavior.

💡Structural Patterns

Structural patterns are design patterns that ease the design by identifying a simple way to realize relationships between entities. These patterns focus on how classes and objects are composed to form larger structures. The video highlights the adapter and facade patterns as examples of structural patterns that help organize and simplify complex systems.

Highlights

Introduction to eight essential design patterns for developers.

The enduring relevance of the 'Design Patterns' book by the Gang of Four, even in the fast-paced JavaScript ecosystem.

Explanation of the Factory Pattern for object instantiation, akin to ordering a burger at a restaurant.

The Builder Pattern for constructing complex objects step by step, like adding ingredients to a burger.

The Singleton Pattern ensures a class has only one instance, useful for maintaining application state.

Observer Pattern, also known as pub-sub, for real-time updates across components, using YouTube as an example.

Iterator Pattern simplifies the iteration process over complex data structures like linked lists.

Strategy Pattern allows for dynamic behavior modification of a class through runtime strategy selection.

Adapter Pattern as a structural solution to interface incompatibilities, using USB cables as an analogy.

Facade Pattern hides complex system details behind a simple interface, making programming more manageable.

Practical implementation of the Observer Pattern with a YouTube channel and subscribers example.

Chaining methods in the Builder Pattern for fluent interface construction of objects.

Singleton Pattern's role in maintaining a single copy of application state with getAppState method.

The use of abstract classes or interfaces in the Observer Pattern to define subscriber behavior.

Strategy Pattern's adherence to the open-closed principle for extensible class behavior modification.

Adapter Pattern's practical use in making incompatible interfaces compatible, like micro-USB to USB.

Facade Pattern's concealment of complex realities, providing a simplified interface for programmers.

Introduction of an Object-Oriented Design Interview Course for further learning on design patterns.

Transcripts

I heard you liked factories so I made

you a factory inside a factory which

inherits from an abstract Factory so it

can create new factories but enough

about programming in Java

in this video we will learn about eight

design patterns every developer should

know in 1994 the gang of four released

the holy book design patterns

introducing 23 object-oriented design

patterns falling into one of three

buckets creational patterns structural

patterns and behavioral patterns while

some argue that it stated the fact that

a 30 year old book is still being

discussed definitely means something

especially in a world where JavaScript

Frameworks are going out of style faster

than you can say JavaScript was a

mistake anyways let's start with our

first creational pattern the factory

imagine that you want a burger but you

don't want to have to worry about

getting all the ingredients and putting

them together so instead you just order

a burger well we can do the same thing

with code if it takes a list of

ingredients to create a burger we can

instead use a factory which will

instantiate the burger for us and return

it to us whether it's a cheeseburger a

deluxe cheeseburger or even a vegan

burger all we have to do is tell the

factory what kind of burger we want just

like you would do at a restaurant but be

careful because this way you'll never

know what's inside the Special Sauce we

added a secret ingredient

now alternatively if you want a little

more control over how the sausage is

made you can go with the builder pattern

the idea is that if we want to make a

burger we don't immediately have to pass

in all the parameters we can use a

burger Builder instead we'll have an

individual method for adding each

ingredient whether it's a bun Patty or

cheese each one will return a reference

to the Builder and finally we'll have a

build method which will return the final

product then we can instantiate a burger

Builder add the Buns that we want the

Patty that we want and the cheese that

we want and we can chain these methods

because remember each one will return a

reference to the Builder finally we can

build it and we have the exact burger

that we want I've used this pattern a

lot at Google with protocol buffers next

we have the Singleton pattern and I'm

not talking about my dating life a

Singleton is just a class that can only

have a single instance of it that's

instantiated it has many use cases for

example maintaining a single copy of our

application stay we would start by

having a static instance variable let's

say in our app we want to know if a user

is logged in or not but we won't use the

Constructor to actually instantiate the

application State we'll use a static

method called get app stay which will

first check if there's already an

existing instance of our application

stay if not we'll instantiate one if

there already is though we'll just

return the existing instance we'll never

create more than one so now if we get

our app State for the first time the

logged in value will initially be false

but if we get the app State again this

will actually still be the first

instance so if we modify the first

instance and then print the logged in

value for both of them they will both

now be true this pattern can be useful

so that multiple components in your app

will have a a shared source of truth but

how can all the components listen for

updates in real time well that's where

the Observer comes in our first

behavioral pattern I prefer to call it

the pub sub pattern it's widely used

Beyond just object-oriented programming

including in distributed systems let's

take YouTube for example every time I

upload a video all of my subscribers get

a notification including you because

you're subscribed right but in this case

the YouTube channel is the subject AKA

publisher which will be the source of

events such as a new video being

uploaded we might want multiple

observers AKA subscribers to all be

notified when these events happen in

real time one way to implement this

pattern is to have a YouTube channel

class which maintains a list of its

subscribers when a new user subscribes

we add them to the list of subscribers

when an event occurs we go through that

list of subscribers and send the event

data to each of them with a notification

but we also have to define the

subscriber interface which you can do

with an abstract class or an interface

different subscribers might implement

this interface differently but for a

YouTube user let's say that we just want

to print the notification that was

received so then we can create a YouTube

channel add a few subscribers and we

only have to call notify once and all of

the subscribers will receive the

notification this is also extensible

enough that a subscriber could be

subscribed to multiple channels an

iterator is a pretty simple pattern that

defines how the values in an object can

be iterated through in Python just

defining an array and then iterating

through it with the in keyword uses the

built-in list iterator this way we don't

even have to index the array now for

more complex objects like binary search

trees or linked lists we can Define our

own we can take a list node which just

has a value and a next pointer and then

a linked list which has a head pointer

and a current pointer we can first

Define the iterator with the inner

function which will just set the current

pointer to the head and then return a

reference to the linked list to get the

next value in the sequence we defined

the next function if our current pointer

is non-null we can get the value and

then return it and also shift the

current pointer but if we reach the end

of the linked list we can send a signal

that we're going to stop iterating to

test it out we can just initialize the

linked list and iterate through it with

the in keyword this is a much more

simple interface than having to actually

update pointers ourselves now if you

want to modify or extend the behavior of

a class without directly changing it you

can go with the strategy pattern for

example we can filter an array by

removing positive values or we could

filter it by removing all odd values

these are two strategies but maybe in

the future we want to add more and we

want to follow the open closed principle

well we can define a filter strategy

create an implementation which will

remove all negative values and an

implementation which will remove all odd

values and then at run time we can pass

this strategy into our values object and

to test it out all we have to do is pass

in the strategy into our filter method

and we'll get our desired result this

way we can add additional strategies

without modifying our values class next

we have the adapter our first structural

pattern it's analogous to the real world

where we have a screw that's too small

to fit into a hole so instead we use an

adapter which makes this screw

compatible with the hole

or maybe an example that you're more

familiar with we have a USB cable and a

USB port we can plug in the USB cable

which will directly fit into the port

but instead if we have a micro USB cable

it's not compatible so instead we need a

micro to USB adapter which extends from

the USB clasp but is composed of a micro

USB cable which will be plugged into the

adapter we can override the plug USB

method from our parent class if needed

but it's not in this case and then we

can plug our micro USB cable into the

adapter and then plug it into the port

and it works just like a regular USB

cable and our last pattern is the facade

according to the dictionary a facade is

an outward appearance that is maintained

to conceal a Less Pleasant or credible

reality in the program programming world

the outward appearance is the class or

interface we interact with as

programmers and the Less Pleasant

reality is hopefully the complexity that

is hidden from us so a facade is simply

a rapper class that can be used to

abstract lower level details that we

don't want to have to worry about I'm

surprised it even qualifies as a design

pattern but some common examples might

include HTTP clients that abstract away

low-level Network details or even arrays

yes a dynamic array like vectors in C

plus plus or arraylists in Java are

constantly being resized under the hood

thankfully as programmers we rarely have

to think about memory allocation though

if you're interested to learn more check

out my newly released object-oriented

design interview course we tackle some

popular interview questions I've

included video less since written

articles and code for four languages and

I'll be sure to add additional lessons

in the future thanks for watching and

make sure to subscribe please