All programmers need to be aware of common design patterns. What leads me to this all inclusive conclusion? Because using design patterns buys you many things when writing code and will help to prevent it from showing up on sites like this.
It is so easy when starting a new project to spend little to no time on the design phase and go straight into coding. This is the fast track to sending your code to the fan. Take your time and choose your design carefully. You'll thank yourself later.
What is a design pattern?
Design patterns help us to write code that is reusable, extensible, and maintainable. It helps programmers to think about code in terms of objects. While design patterns are not code, they are general solutions that can be applied in many cases. They can help to save time by giving an approach to common problems.
Reusability
Thinking in terms of a designing a car, it is determined that it needs a wheel. Therefor a wheel is invented and attached the car. But low and behold it is decided that a car needs more than just one wheel, so do we reinvent the wheel each time we need one? No, because that would be a waste of time. We only need to design the wheel once, and create 4 instances of it to put on the car. But it is important to note that the wheel doesn't, and shouldn't, do everything. It serves it purpose (in terms of transportation) to facilitate movement on the ground. But water, air, or space travel do not always make use of wheels for movement. While it may be possible in some cases to shoe-horn a wheel into a vehicle's design to make it traverse these other mediums, it is not the most efficient, practical, time saving, or easy thing to do.
Extensibility
There is only one constant in any project, and that is change. Requirements change, members come and go, technical roadblocks can come out of nowhere, etc. Design patterns may help your code to be extensible so when the customer asks, "Can it do this?" it will be easier to add in that extra functionality. It is good to think about extensibility when designing, but it can be easy to fall into the trap where you try to make everything and its brother extensible. When working on this aspect of the design, you need to stop and ask, does this need to be extendible or how easy would be to make it extendible down the road? Otherwise you may end up creating an entire computer just to use it as a simple calculator.
Maintainability
Last but not least (by far). Ever inherited a project full of spaghetti code or written code that you have no idea what it does a week later? I have on occasion, and let me tell you, it is a nightmare. Using established design patterns makes it easier to fix bugs, add functionality, or take functionality out. They provide inherent organization and make code easier to understand and follow.
Good Resources
