Introduction

Design patterns are a relatively new concept in software engineering, and have their origins in civil engineering. Essentially they are a blueprint for solving a specific problem, allowing the benefits of an optimal solution to be carried forward to new implementations.

In the design mode of application software engineering for the first time officially in the book "Design Patterns: Elements of Reusable Object-Oriented Software by Eric Gamma, Richard Helm, Ralph Johnson, John Vlissides," 1995 Nian. Selected in this book as a core understanding of the problem-solving methods of software engineering model 23 model.

Although many of the principles set up, this book, it does not generally use the template pattern to a wider audience. Subsequently, the application mode has not itself become a model to promote the work. Engineers to decide how best to use in different application mode.

Structure of Design Patterns

What is clear is that there needs to be structure into which patterns can be formulated; this allows for them to be largely self-documenting. Indeed, one of the principles of using design patterns is that they should be structured, allowing each one to be created from a template.

At the very least, a template should contain:

? Pattern name : short, but descriptive;

? Intent : the goal of the pattern;

? Motivation : example of a problem, and how this pattern will solve it;

? Applicability : uses for this pattern;

? Structure : diagrams of the patterns classes;

? Participants : the responsibilities of the classes in the pattern;

? Collaborations : interfaces between the participants;

? Consequences : any trade-offs and forces that exist within the pattern.

This list is adapted from that provided by the Design Patterns authors, and can be used as rigidly or as loosely as is required. Some aspects will prove not to add any useful value to the template, but are provided here in the interest of completeness.

We have also refrained from using the term ‘classes and objects’, as is common in discussions of design patterns, preferring to only use the term ‘classes’. The reason for this is one of object oriented design preference – if a pattern needs to be defined in terms of objects, then a certain implementation decision has been made and forced upon future adopters of the specific pattern.

Application of Design Patterns in Software Engineering

One of the key benefits in using design patterns in software engineering is as a way to improve communication between designers, and, to a certain extent, between non-programmers and programmers. In other words, as a communication tool, patterns can prove invaluable.

In addition, the abstract universal solution to the problem of software engineering, design patterns, you can use it repeatedly. Because of their design standards used by each authentication solution, re-use is very high. This has increased the results beyond that which will only be achieved using object-oriented technology to achieve quality.

The application of design patterns in the real world must necessarily be carried out with reference to other principles already deployed. In other words, while they offer solutions to common software engineering problems, there is no added value in creating patterns for every part of a system under development.

Instead, in the example, the implementation of the results (design), you will need to use if you are likely to use in future projects. In essence, the best way to use software engineering design patterns that provide a standard of behavior between classes of highly specialized software. Technique itself is designed in a way that no other paradigm is.

Summary
The use of design patterns is essentially parallel to the use of any object-oriented reasons. Encourage the reuse of design patterns, there is no limit to achieve a particular platform or language, design and promote the effective use of time. They can be seen as a modular design of equal or object-oriented programming.

Their own strengths, and weaknesses can be considered their own. Implementation is, the programmer, in fact, the code is interpreted as any errors that require the source code is converted to the final. In other words, another programmer, and different implementations of the same pattern may end up with a variety of possible actions.

When working with design patterns, it is therefore important to remember that they should be precise enough that there are no possible misinterpretations. Using a suitable high level definition language that can be shown to be correct will help to ensure this.