During design process of the applications we meet with the same problems in different part of the designed applications. If the solutions of the suitable problems are the same in many places of the application we can name such a solution the design pattern. The design patterns describe a commonly recurring problem that occurs in a particular context and based on a set of guiding force and recommend a solution. The solution is usually a simple mechanism, a collaboration between two or more classes, objects, services, processes, threads, components, or nodes that work together to solve a general design problem within a particular context. Design patterns are built on the top of the object oriented programming. The design patterns are part of the cutting edge of object-oriented technology. The design patterns describe solutions to specify problems in object-oriented software design. The design pattern is not a ready to use solution; it is a template for how to solve a problem that can be used in many different situations. The design patterns are not algorithms because they don't solve the computational problems rather than design problems. Using the design patterns we can speed up the development process by providing tested, proven development paradigms. The design patterns can make our own designs more flexible, modular, reusable, and understandable. We can classify the design patterns based on multiple criteria, the most common of which is the basic underlying problem they solve. The design patterns can be classified into various types:

• Fundamental patterns: delegation pattern, functional design, interface pattern, proxy pattern, immutable pattern.
• Creational patterns: abstract factory pattern, anonymous subroutine objects pattern, builder pattern, factory method pattern, lazy initialization pattern, prototype pattern, singleton pattern.
• Structural patterns: adapter pattern, bridge pattern, composite pattern, container pattern, decorator pattern, extensibility pattern, façade pattern, flyweight pattern, proxy pattern, pipes and filters, private class data pattern.
• Behavioral patterns: chain of responsibility pattern, command pattern, event listener, interpreter pattern, iterator pattern, mediator pattern, memento pattern, observer pattern, state pattern, strategy pattern, template method pattern, visitor pattern, single-serving visitor pattern, hierarchical visitor pattern.
• Concurrency patterns: active object, balking pattern, double checked locking pattern, guarded suspension, leaders/followers pattern, monitor object, read write lock pattern, scheduler pattern, thread pool pattern, thread-specific storage.
• Architectural patterns: model-view-controller pattern, presentation-abstraction-control pattern, client-server pattern.

Software factories is a paradigm for automating software development that integrates component based and model driven development, software architecture, aspect oriented programming, and requirements, process and software product line engineering to increase agility, productivity and predictability across the software life cycle.