8 Design Patterns EVERY Developer Should Know 

✅ In-depth OOP Design Patterns course: neetcode.io/courses/design-patterns ✅ OOP Interviews course: neetcode.io/courses/ood-interview

A cool thing happens if you learn programming by yourself: after some time you start to implement these patterns without knowing them formally. Most often they are more clumsy than the original but the spirit is there. Really cool how patterns are just a result of efficient and modular thinking.

Been putting off reading head first design patterns for a long time. This seems like an excellent intro to each concept that I can now find more references to

The facade reminds me of some subs/functions that I have in one of my libraries that are too dangerous to handle directly so I added safer wrapper subs/functions around it, which can each be used depending on the required features. It's also kinda like a factory, but not quite.

This was a good introduction! I will say, because they are the usually the most talked about, there are some things that are worth elaborating further on in regard to creational design patterns: Factories aren't just about fabricating objects. One of the big advantages is that they disconnect how an object is made from where it might be needed to be created. The best part of factories are that they can be instantiated and shared and passed between code. Otherwise, they're just a set of default constructors. They're often considered outdated because most languages have first class functional support these days. A function that takes no arguments and returns a new thing when called can usually be passed around. This is essentially the same as a factory. Builders aren't necessarily identified by their methods that can be easily chained. You can have builders that don't do this and they're still a builder. They're useful, like the factory, for when you have pass them around to other code. For example, you might have a lot of code that wants a say in how an object is created. It lets you spread the logic for how something is created over multiple places and build it once everything has had its input. It also lets the final result be immutable if you would prefer, making it mutable during creation and allowing for the resulting object to say "no more changes!" Singletons are great but hard to test. Best practice is to make a singleton extend some kind of interface class and provide the instance to the code that needs it, either as-is or via a factory. This lets you swap it out when you do testing. Otherwise, you're locked into always using that global state in your tests and it gets harder to work with!

I'm a Java developer since 2008, and I LOVE your punches towards Java 😍 they are to much fun and true

NeetCode is to coding to what The Organic Chemistry Tutor is to all school subjects, everything is clear and easy to understand when you guys teach it!!

Nice refresher. On the topic of GoF patterns, many of them may seem outdated or unnecessary for inclusion as patterns because for modern developers many of these patterns are even included at language level as basic features, however, it was much different back then when OOP was just taking off in enterprise world.

This is a really nice video, well worth subscribing to this channel for. I hope you turn this into a series and cover more patterns in the future.

This makes more sense than the semester long course I had on design patterns

Awesome explanation! This is a life-saver when it comes to quick brush before the interview! 😄Thank you so much for making this video!

Analogies are on point. Great work.

Appreciate you breaking it down so thoroughly while making it easy to understand! Remember working with a senior engineer who would talk about a few design patters he implemented but he couldn't always explain it effectively. This was very well done! Motivated to get back to learning these patters on my own now! Thanks!

These examples are easy to digest and understand, great video

Thanks man you explained it so well I am never gonna forget. Please keep posting videos like this. 👍

Hey NeetCode, thanks for the succinct breakdown of these patterns. I am an engineer, but not a dev, and don't really use these patterns, but in areas such as IaC just as an example, it's interesting to think about how I could implement concepts introduced in these patterns. Loved your analogies so I could visualize these concepts better. Thanks!

you're great at teaching thank you for letting me brush up on my knowledge of these things

Oh, we defiantly need a course on deign patterns from you

This is really great stuff, I cannot tell you how much your videos have helped in solving questions while I am hunting jobs. The way you explain concepts with such intuitive examples is something I have not seen before. Please keep posting awesome content like this.

Please never stop making videos. You have a gift for teaching. Your S-tier ability to explain topics is amazing.

What a great and simple to understand video! Thank you

I use these but never really bothered to learn the formal definitions. Seems a bit dated in today's patchwork of random NPM libraries engineering, but still fun to finally link the names to the faces!

Love the vid! Much more concise than my CS Object Oriented class

It's great that u tried to make it more like the fireship videos ✌️

As you touched on with pub/sub for Observer patterns, naming can be an issue. As a developer with decades experience it can be a challenge when these patterns are “rediscovered” and given new names. This probably wouldn’t happen if people truly understood the patterns instead of memorizing the fancy name de jour for them.

You never cease to amaze your viewers. Fantastic !!!

Awesome video using real day to day example that anyone can understand. I especially like the burger analogy.

Great video. Super clear. Got me to sub. I'll be observing what you pub.

It's amazing. I really liked how easy and fun you taught about complicated concepts. Tbh, I need more explanation to understand some patterns though. I really appreciate it you made this video. Thank you very much!

Knowing these patterns is only one side of the coin. What's more important is really understanding when (and when not!!!) To use them, especially in production code. I used to put singletons everywhere, feeling like a rockstar. And then, I learnt about SOLID and what can I say... In hindsight, singletons are a huuuuuge anti-pattern for all but the most edgy of the edge cases.

Bonjour and many thanks for the video. Crystal clear, straight to the point, fun... Nothing to say except merci!

This is the best and simple explanation I've seen for design patterns, gg

nice and simple explanations! I love that you use python examples. I finally grokked the strategy pattern.

amazing video, a neetcode class. thank you

Cool video! Jokes and examples made it more easy to understand

Insanely awesome video neetcode!

This is fantastic. Please keep making more videos.

This was great, subscribed!

Very nicely laid out. Awesome vid

It was good that you disclosed your position in relation to JS, I can't trust no one that is align the madness of it! It's an important tool to know, but you don't have to love it.

One great example od a Facade class that I insantly understood after is "gcc". You can assemble if you like with "as" or link with "ld" or "cpp" to see the macros expand, but you can just use "gcc" and get all of this done.

Thank you very much for this awesome video! Could you please do a video on dependency injection design pattern? Thank you!

best explanation of design patterns thank you

If I hadn't already subscribed, that "Please" at the end would have sold me. The content was good, too.

So helpful, thanks!

If only I could give this video more than just one like. After a whole life reading and studying these patterns, I finally understand them thanks to this video!

Very useful, thanks!

That was very nice! It remembers me some ways to do things in OOP :D I'll definitely recommand this vidéo to my students!!

ex. of adapter was so good for understanding.

This is valuable . Are there more popular Design patterns not in this list ?

this channel is gold.

Laravel has a great implementation of the facade pattern. Basically, you can use it to statically proxy methods into any object, regardless of if it's a static or instance method. Super nice and simple.

Love this! Brilliant

Having watched ArjanCodes and through years of coding experience - you could make your iterator "next" logic, @6:10, cleaner by doing an inverse check, like so: if not self.cur: raise StopIteration val = self.cur.val self.cur = self.cur.next return val

Informative and entertaining! :)

The builder pattern is so interesting to me. The only reason for its existence that I can think of is that if you're working in a language that doesn't have language based solutions that make it easy to handle classes with many many parameters in their constructor, where a lot of them are optional or have default values. It's much easier to understand how to use the class by reading an example initialization that uses a builder pattern and only sets a few fields, compared to a constructor call of 10 elements where 7 of them are null. But if the language let me call constructors in a way that requires named parameters but also allows for optional parameters, I think the builder pattern loses its value.

As someone who is going through the basics of Python, I'm pleased to see how much easier it is to play with data structures

Wow, you're an incredible teacher

Yet an another attempt was made to clear the mysterious design patterns. 😅 Good video. I was talking about this yesterday with my colleague. You forgot the most important one, the state machines. Then again, if you are not from embedded world, the state machine pattern aren’t that often used.

great video, I learned ALOT

Really nice and simple explanations. I revised the concepts I learnt before 2-3 months by watching this video

Im learning MVVP with C# wpf. That's awesome

Today I watched your video for the first time... I understood maybe 12% of it. Hopefully, next time I watch I'll retain more

Very interesting never encountered design systems before

Of course I will subscribe. What a better thing do I have to do? Thanks

Awesome content🦾 Just subscribed.

This video is so good 🙏

Ngl this explanation was incredible

Nice story linking. I guess why ppl forget the design patterns easily is due to lack of story to link them. Now it’s easier to remember Burger factory builder, or USB micro to mini adapter. And from this extract information.

Please make a video for other design patterns too like command pattern

such a damn good video. ur the best

Yes, I've made sure I subscribed just now :)

Worth noting that, in a language with singleton modules, one should usually use those instead of instantiating a class, as a singleton class is unintuitive and breaks assumptions one may have about classes

Clear. Concise.

Amazing that most programmers already implement most of these patterns without actually learning it. They just make sense! 😅

I’ve been watching videos like this for a while and a lot of it goes over my head. What should we learn first so these videos make more sense?

Not only every developer, but also everyone on the earth should know!!!

opening with the pimp my ride meme - LEGENDARY

wow you are best ! thank you!

thank you ! 💯

keep up the great work

Great talk!

Hi from a patterns newbie. How do you print or display the result from the builder pattern? This is an excellent series of explanations. Thanks

Is from abc import ABC , abstractmethod defined by neetCode or its actual library used to implement abstract classes in python?

Great video!

Amazing content!!!! 😍

thats so f*cking good, Great video!

I’ve learned more from this video than I did it my entire community college😢

You earned a subscription

If you write a class, which only can instantiate one object and raises an error if you try to instantiate a second object - is this still a singleton?

when u said plz subscribe at the end made me subscribe so ty

Can you elaborate more why you used the Builder Pattern a lot of Protocol Buffers? Thanks

2:20 I knew you could use the backslash to extend if statements more than one physical lines but I did not know you could use it in this way too.

Lmao I like this style of video. Keep it up got some real good use (and is still getting good use) out of your channel in the past year or so.

If the iterator pattern is implemented directly on the data structure like in this video, you can only iterate it once. Instead, ___iter___ should return a new ListIterator, and this ListIterator should have a ___next___ method

You’re awesome man

“**presents incompatible screw/hole metaphor**, or maybe an example that you’re more familiar with…” - Brilliant 😂 Subscribed for the funny yet educative value, keep it up 👍🏼

scrumptious!!!

Thanks brother

Is that possible create a OOP course not just for interview? Thanks