You get a bonus - 1 coin for daily activity. Now you have 1 coin

Design Pattern

Lecture



A design pattern or pattern in software design is a repeatable architectural design that represents the solution to a design problem within a context that often arises.

Typically, a pattern is not a complete pattern that can be directly converted to code; This is just an example of solving a problem that can be used in various situations. Object-oriented patterns show relationships and interactions between classes or objects, without determining which end classes or application objects will be used.

"Low-level" patterns that take into account the specifics of a particular programming language are called idioms. These are good design solutions, specific to a particular language or software platform, and therefore not universal.

At the highest level, there are architectural patterns , they cover the architecture of the entire software system.

Algorithms are inherently also templates, not calculations, but calculations, since they solve computational problems.

Story

In the 1970s, architect Christopher Alexander created a set of design patterns. In the field of architecture, this idea did not receive such a development as later in the field of software development.

In 1987, Kent Beck and Ward Cunningham took Alexander's ideas and developed templates for developing software for developing graphical shells in the Smalltalk language.

In 1988, Erich Gamma began writing a doctoral thesis at the University of Zurich on the general portability of this methodology for program development.

In 1989-1991, James Coplin (James Coplien) worked on the development of idioms for programming in C ++ and published in 1991 the book Advanced C ++ Idioms.

In the same year, Erich Gamma finished his doctoral thesis and moved to the USA, where in collaboration with Richard Helm, Ralph Johnson and John Vlissides publishes the book Design Patterns - Elements of Reusable Object-Oriented Software. This book describes 23 design patterns. Also, the team of authors of this book is known to the public under the name "Gang of Four" (English Gang of Four , often reduced to GoF ). This book was the reason for the growing popularity of design patterns.

Benefit

In comparison with fully independent design, templates have several advantages. The main advantage of using templates is to reduce the complexity of the development at the expense of ready-made abstractions to solve a whole class of problems. The template gives the solution its name, which facilitates communication between developers, allowing you to refer to known templates. Thus, at the expense of templates, unification of the details of the solutions is made: modules, project elements - the number of errors is reduced. The use of templates is conceptually similar to using ready-made code libraries. Properly formulated design pattern allows finding a successful solution, use it again and again. A set of templates helps the developer to choose the most suitable design option. [1]

Criticism

Although a slight change in the code for a known pattern can simplify the understanding of the code, according to Steve McConnell, two difficulties can be associated with the use of patterns. First, blindly following a certain pattern can lead to complication of the program. Secondly, the developer may be tempted to try some pattern in the case without any particular reason. [2]

Many design patterns in object-oriented design can be viewed as idiomatic reproduction of elements of functional languages ​​[3]. Peter Norvig claims that 16 of the 23 templates described in the book “Gangs of Four” are much easier to implement in Lisp or Dylan than in C ++, or they are invisible [4]. Paul Graham considers the idea of ​​design patterns itself to be an anti-pattern, a signal that the system does not have a sufficient level of abstraction, and it needs careful processing [5]. It is easy to see that the definition of the template itself as “a ready-made solution, but not a direct access to the library ” in essence means a refusal to reuse in favor of duplication. This, obviously, can be inevitable for complex systems when using languages ​​that do not support combinators and type polymorphism, and this can in principle be excluded in languages ​​that have the property of [en] (although not necessarily efficiently), since any pattern can be implemented as executable code [6].

Types of design patterns

Main

Title original name Description Described in Design Patterns
Basic Patterns (Fundamental)
Delegation Template Delegation pattern The object outwardly expresses some behavior, but in reality transfers responsibility for the execution of this behavior to the related object. N / A
Functional Design Template Functional design Ensures that each module of a computer program has only one duty and performs it with a minimum of side effects to other parts of the program. N / A
Immutable interface Immmtable interface Creating an immutable object. N / A
Interface Interface A common method for structuring computer programs to make them easier to understand. N / A
Interface marker Marker interface As an attribute (as an entity tag), the presence or absence of a marker interface implementation is applied. In modern programming languages, attributes or annotations may be used instead. N / A
Property Container Property container Allows you to add additional properties for a class to a container (inside a class), instead of extending the class with new properties. N / A
Event channel Event channel Extends the Publish / Subscribe template by creating a centralized channel for events. Uses the proxy for the subscription and the proxy for posting a channel event. The representative exists separately from the actual publisher or subscriber. A subscriber can receive published events from more than one object, even if it is registered on only one channel. N / A
Creational patterns are design patterns that abstract the instantiation process. They allow you to make the system independent of the way you create, compose and present objects. The template that generates the classes uses inheritance to change the class to be instantiated, and the template that generates the objects delegates the instantiation to another object.
Abstract Factory Abstract factory A class that provides an interface for creating system components. Yes
Builder Builder A class that represents an interface for creating a complex object. Yes
Factory Method Factory method Defines an interface for creating an object, but leaves the subclasses a decision on which class to instantiate. Yes
Delayed initialization Lazy initialization An object that was initialized during the first call to it. Not
Pool singles Multiton Ensures that the class has named object instances and provides a global access point to them. Not
Object pool Object pool A class that represents an interface for working with a set of objects initialized and ready to use. Not
Prototype Prototype Defines an interface for creating an object through cloning another object instead of creating through a constructor. Yes
Getting a resource is initializing Resource acquisition is initialization (RAII) Getting some resource is combined with initialization, and the release - with the destruction of the object. Not
Single mother Singleton A class that can only have one instance. Yes
Structural patterns (Structural) define various complex structures that modify the interface of already existing objects or its implementation, making it easier to develop and optimize the program.
Adapter Adapter / Wrapper An object that provides interaction between two other objects, one of which uses and the other provides an interface incompatible with the first. Yes
Bridge Bridge A structure that allows you to change the call interface and the class implementation interface independently. Yes
Linker Composite An object that combines objects like itself. Yes
Decorator or Wrapper / Wrapper Decorator A class that extends the functionality of another class without using inheritance. Yes
Facade Facade An object that abstracts work with several classes, combining them into a coherent whole. Yes
Single entry point Front controller Provides a unified interface for interfaces in a subsystem. Front Controller defines a high-level interface that simplifies the use of the subsystem. Not
Adapted Flyweight This is an object that represents itself as a unique instance in different places of the program, but in fact is not one. Yes
Deputy Proxy An object that is an intermediary between two other objects, and which implements / restricts access to the object that is accessed through it. Yes
Behavioral patterns (Behavioral) define the interaction between objects, thus increasing its flexibility.
Chain of responsibility Chain of responsibility Designed to organize in the system of levels of responsibility. Yes
Team, Action, Transaction Command Represents an action. The command object contains the action itself and its parameters. Yes
Interpreter Interpreter Solves a frequently occurring, but subject to change, task. Yes
Iterator, Cursor Iterator It is an object that allows to get sequential access to the elements of an aggregate object without using descriptions of each of the objects that make up the aggregation. Yes
Mediator Mediator Ensures the interaction of multiple objects, while forming a weak connection and eliminating the objects from having to explicitly refer to each other. Yes
Keeper, token Memento It allows not fixing the encapsulation and fixing and preserving the internal state of the object so that it can be restored later in this state. Yes
Null object Null object Prevents null pointers by providing a “default” object. Not
Observer, Dependents, Publish-Subscribe, Listener Observer or Publish / subscribe Defines a one-to-many dependency between objects in such a way that when a state of a single object changes, all dependent dependencies are notified of this event. Yes
Servant Servant Used to provide general functionality to a class group. Not
Specification Specification Serves to bind business logic. Not
State, Objects for States State It is used in cases when, during the execution of a program, an object must change its behavior depending on its state. Yes
Strategy Strategy Designed to define a family of algorithms, encapsulate each of them, and ensure their interchangeability. Yes
Template Method Template method It determines the basis of the algorithm and allows the heirs to override certain steps of the algorithm, without changing its structure as a whole. Yes
Visitor Visitor Describes an operation that is performed on objects of other classes. When changing the class Visitor there is no need to change the classes served. Yes
Simple policy Simple policy Not
Event listener Not
One time visitor Single-serving visitor Optimizes the implementation of the template visitor, which is initialized, once used, and then deleted. Not
Hierarchical visitor Hierarchical visitor Provides a way to bypass all the vertices of a hierarchical data structure (for example, a tree). Not

Concurrency - Concurrency

Private [edit | ]

Concurrency patterns [edit | ]

Used for more efficient writing of multi-threaded programs, and provides ready-made solutions to synchronization problems.

Title original name Description
Active Object Active object Serves to separate the thread of the method from the thread in which it was called. Uses templates asynchronous method call and scheduler.
Talking Talking Serves to perform an action on an object only when it is in the correct state.
Binding properties Combines several observers to ensure the synchronization of properties in various objects [7]
Message exchange Messaging design pattern (MDP) Allows components and applications to exchange information (messages).
Double check lock Double-checked locking Designed to reduce the overhead associated with obtaining a lock.
Event-based asynchronous Address problems with the Asynchronous pattern that occur in programs with multiple threads. [8]
Secure suspension Guarded suspension It is used to block the execution of an action on an object only when it is in the correct state.
Half-Sync / Half-Async
Leaders / followers
Lock One thread locks a resource to prevent access or alter it by other threads. [9]
Monitor Monitor object An object intended for safe use by more than one stream.
Reactor Reactor Designed for simultaneous transmission of requests to the service from one or more sources.
Read write lock Read-write lock Allows multiple threads to simultaneously read information from a shared repository, but allowing only one thread to change it at the current time.
Scheduler Scheduler Provides a mechanism for implementing a planning policy, but not dependent on any particular policy.
Thread pool Thread pool Provides a pool of threads for processing jobs, usually represented as a queue.
Thread-Specific Storage Thread-specific storage Serves to provide different global variables for different threads.
Single threaded execution Single thread execution Interferes with the competitive challenge of the method, thereby prohibiting the parallel execution of this method.
Cooperative pattern Cooperative pattern Provides a mechanism to safely stop execution threads using a common flag to signal the termination of a thread's operation.

MVC

  • Model-View-Controller (MVC) Model-view-controller.
  • Model-View-Presenter
  • Model-View-View Model
  • Presentation-Abstraction-Control

Enterprise t]

  • Active Record is a way to access data in relational databases in object-oriented programming.
  • Business Delegate
  • Composite Entity
  • Composite view
  • DAO (Data Access Object) Data Access Object
  • Dispatcher View
  • Front controller
  • Intercepting Filter
  • Registry
  • Service Activator
  • Service Locator / Service Locator
  • Service to Worker
  • Session Facade / Session Session
  • Transfer Object Assembler
  • Transfer Object
  • Value List Handler / Value List Handler
  • View helper
  • Unit of work

Other

  • Repository / Storage

Other types of patterns

Also today there are a number of other templates:

  • Carrier Rider Mapper describe the provision of access to stored information
  • Analytical templates describe the basic approach for creating requirements for software (requirement analysis) before the very beginning of the software development process.
  • Communication templates describe the process of communication between individual participants / employees of the organization.
  • Organizational templates describe the organizational hierarchy of an enterprise / firm.
  • Anti-patterns (Anti-Design-Patterns) describe how not to proceed when developing programs, showing characteristic errors in design and implementation

Comments


To leave a comment
If you have any suggestion, idea, thanks or comment, feel free to write. We really value feedback and are glad to hear your opinion.
To reply

Object oriented programming

Terms: Object oriented programming