My name's Kyle from Web have simplified in this video.

I'm going to be talking about what design patterns are and why they're useful as a primer for my upcoming Siris on design patterns to get started with what designed patterns are I'm going to read the Wikipedia definition for design patterns because I think it encapsulates what design patterns are quite well, it reads.

Software design pattern is a general reusable solution to a commonly occurring problem within a given context.

In software designed design patterns are formalized best practices that the programmer can use to solve common problems when designing an application or system.

And I think this is a great definition for what a design pattern is because it hits the heads that it's general, in which it means that can be applied to multiple different aspects of your software design.

Whether you're designing a game, a website, a mobile application, it doesn't really matter.

These patterns could be applicable to almost any form of application you're creating, and it also mentions that they're reusable, which means that you can use them throughout your application many different times in many different scenarios and use the same pattern, which is really useful, because then you only need to learn the pattern once in order to reuse it many different places across your applications.

And then it also says that this is really a formalization of different best practices, which I think is the best way to explain design patterns because they're really just a formal written way in order to do something that is a normal best practice inside of software design.

So there's many different patterns to do many different things, and it's taken brilliant minds from tons of different people that have come together instead.

This is the best way that we have in order to do this problem in the cleanest way possible.

And that's really what design patterns air for their for making your cone code cleaner to use, read and less buggy and less error prone.

Then, if you weren't using these design patterns to begin with, and luckily, learning design patterns is a fairly straightforward, an easy thing to do.

The actual process of learning the design patterns is much easier than learning when you should use them and where you should use them.

I know the biggest problem that most people have when using design patterns is that they learn about them and they're like, Wow, this is amazing.

I want to use this all over the place is will make my coach so much cleaner and they start throwing designed patterns into areas where they don't really need to be or they don't really fit or away.

It may be overkill, and we're not using it would be better.

I know When I first learned about designed patterns, that was exactly what I did.

I was like, Wow, these are really amazing.

They made my coach so much cleaner, so much easier to write.

I'm going to throw them everywhere, and that's what I did.

Everything I wrote for a while after that was just using design patterns all over the place where I didn't really need them.

And I made my code messier than if I hadn't used these design patterns in the first place.

This is kind of a problem because that's really what the design patterns are very to solve is to make your code less messy and cleaner, So learning when to use them is really the hard thing when it comes to learning design patterns.

This problem that occurs where people end up using design patterns where they're not meant to be used or overly using design patterns where they shouldn't be, is some of the reason that design patterns kind of get a bad rep in the industry and where people say you shouldn't be using design patterns there.

Overkill most the time and they are sometimes right.

I do agree that sometimes designed patterns are overkill, but knowing these design patterns is more important because it allows you to have a holistic view of how to create cleaner, more reusable code rather than just throwing something together that works.

I kind of you designed patterns is almost like a gateway drug that leads into you creating more and more clean code.

And wantinto learn about all these different ways to architect code and more reusable and cleaner ways.

That'll make your application easier to maintain in the long run and quicker to maintain as you go forward, adding new features.

I know for me design patterns were really that thing that pushed me to want to create cleaner and more maintainable code, and so I think that by doing this I will hopefully be able to impart on to you guys that same desire for clean and architected code that I got from winning design patterns.

And I really hope that my videos can give that to you guys as well.

So my next video is going to be on the no object design pattern, which, in my opinion, is probably the easiest of all the design patterns to understand.

And one of the more useful wants to see why you would want to use this over not using it.

So I think it's a great starting point for you guys to learn about design patterns.

So you make sure you check that video out when it comes out.

Thank you guys very much for watching this quick video on what design patterns are and why they're useful.

It's really quite easy to wrap your head around what design patterns are, and it is incredibly useful.

Going forward as a developer throughout the rest of your career, toe have these design patterns in your back pocket to use one needed, and just the idea of thinking about maintainable and reusable code will be infinitely useful going forward.

So with that, I hope you guys have a good day.