Behavioral pattern - Revision history

imported>Stevebroshar: No need for disambiguation clause at the start and 'software engineering' is hardly accurate anyway; and less bullets

2025-12-15T15:48:59Z

No need for disambiguation clause at the start and 'software engineering' is hardly accurate anyway; and less bullets

← Previous revision		Revision as of 15:48, 15 December 2025
Line 1:		Line 1:
	{{short description\|Type of software design pattern}}		{{short description\|Type of software design pattern}}
	~~In [[software engineering]],~~ '''behavioral ~~design patterns~~''' ~~are~~ [[design pattern (computer science)\|~~design pattern~~]]~~s that identify common communication patterns among objects. By doing so, these patterns increase flexibility in carrying out communication~~.		A '''behavioral pattern''' is a [[software design pattern]] for collaboration between [[object (computer science)\|objects]].

	== ~~Design patterns~~ ==		== Examples ==
	Examples ~~of this type of design pattern~~ include:		Examples include:

	;[[Blackboard design pattern]]		; [[Blackboard design pattern]]: Provides a computational framework for the design and implementation of systems that integrate large and diverse specialized modules, and implement complex, non-deterministic control strategies.
	: Provides a computational framework for the design and implementation of systems that integrate large and diverse specialized modules, and implement complex, non-deterministic control strategies		; [[Chain-of-responsibility pattern]]: Command objects are handled or passed on to other objects by logic-containing processing objects.
	;[[Chain-of-responsibility pattern]]		; [[Command pattern]]: Command objects encapsulate an action and its parameters.
	: Command objects are handled or passed on to other objects by logic-containing processing objects		; Externalize the stack: Turn a [[Recursion (computer science)\|recursive function]] into an [[iterative function]] that uses a [[call stack\|stack]]<ref>{{cite web
	;[[Command pattern]]
	: Command objects encapsulate an action and its parameters
	;"Externalize the stack"
	: Turn a [[Recursion (computer science)\|recursive function]] into an [[iterative function]] that uses a [[call stack\|stack]]<ref>{{cite web
	\|url = http://c2.com/		\|url = http://c2.com/
	\|title = Externalize The Stack		\|title = Externalize The Stack
Line 22:		Line 18:
	\|url-status = bot: unknown		\|url-status = bot: unknown
	}}</ref>		}}</ref>
	;[[Interpreter pattern]]		; [[Interpreter pattern]]: Implement a specialized computer language to rapidly solve a specific set of problems.
	: Implement a specialized computer language to rapidly solve a specific set of problems		; [[Iterator pattern]]: [[Iterator]]s are used to access the elements of an aggregate object sequentially without exposing its underlying representation.
	;[[Iterator pattern]]		; [[Mediator pattern]]: Provides a unified interface to a set of interfaces in a subsystem.
	: [[Iterator]]s are used to access the elements of an aggregate object sequentially without exposing its underlying representation		; [[Memento pattern]]: Provides the ability to restore an object to its previous state (rollback).
	;[[Mediator pattern]]		; [[Null object pattern]]: Acts as a default value of an object.
	: Provides a unified interface to a set of interfaces in a subsystem		; [[Observer pattern]]: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. The variant '''weak reference pattern''' decouples an observer from an observable to avoid memory leaks in environments without automatic weak references.<ref>{{cite web \|last=Nakashian \|first=Ashod \|date=2004-04-11 \|title=Weak Reference Pattern \|url=http://c2.com/ \|url-status=bot: unknown \|archive-url=https://web.archive.org/web/20110303085751/http://c2.com/ \|archive-date=2011-03-03 \|access-date=2012-05-21 \|publisher=c2.com}}</ref>
	;[[Memento pattern]]		; [[Protocol stack]]: Communications are handled by multiple layers, which form an encapsulation hierarchy<ref>{{cite web
	: Provides the ability to restore an object to its previous state (rollback)
	;[[Null object pattern]]
	: ~~Designed to act~~ as a default value of an object
	~~<dl>~~
	~~<dt>~~[[Observer pattern]]~~</dt>~~
	~~<dd>~~Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. The variant '''weak reference pattern''' decouples an observer from an observable to avoid memory leaks in environments without automatic weak references.<ref>{{cite web \|last=Nakashian \|first=Ashod \|date=2004-04-11 \|title=Weak Reference Pattern \|url=http://c2.com/ \|url-status=bot: unknown \|archive-url=https://web.archive.org/web/20110303085751/http://c2.com/ \|archive-date=2011-03-03 \|access-date=2012-05-21 \|publisher=c2.com}}</ref~~></dd></dl~~>
	;[[Protocol stack]]
	: Communications are handled by multiple layers, which form an encapsulation hierarchy<ref>{{cite web
	\|url = http://c2.com/		\|url = http://c2.com/
	\|title = Protocol Stack		\|title = Protocol Stack
Line 46:		Line 34:
	\|url-status = bot: unknown		\|url-status = bot: unknown
	}}</ref>		}}</ref>
	;[[Publish–subscribe pattern]]<dd>A messaging pattern where senders (publishers) and receivers (subscribers) are decoupled via message topics and brokers. Commonly used in distributed systems, this pattern supports asynchronous, many-to-many communication.</dd>		; [[Publish–subscribe pattern]]<dd>A messaging pattern where senders (publishers) and receivers (subscribers) are decoupled via message topics and brokers. Commonly used in distributed systems, this pattern supports asynchronous, many-to-many communication.</dd>
	;[[Scheduled-task pattern]]		; [[Scheduled-task pattern]]: A task is scheduled to be performed at a particular interval or clock time (used in [[real-time computing]]).
	: A task is scheduled to be performed at a particular interval or clock time (used in [[real-time computing]])		; [[Single-serving visitor pattern]]: Optimise the implementation of a visitor that is allocated, used only once, and then deleted.
	;[[Single-serving visitor pattern]]		; [[Specification pattern]]: Recombinable [[business logic]] in a [[boolean algebra\|boolean]] fashion.
	: Optimise the implementation of a visitor that is allocated, used only once, and then deleted		; [[State pattern]]: A clean way for an object to partially change its type at runtime.
	;[[Specification pattern]]		; [[Strategy pattern]]: Algorithms can be selected on the fly, using composition.
	: Recombinable [[business logic]] in a [[boolean algebra\|boolean]] fashion		; [[Template method pattern]]: Describes the [[program skeleton\|skeleton]] of a program; algorithms can be selected on the fly, using [[Inheritance (object-oriented programming)\|inheritance]].
	;[[State pattern]]		; [[Visitor pattern]]: A way to separate an algorithm from an object.
	: A clean way for an object to partially change its type at runtime
	;[[Strategy pattern]]
	: Algorithms can be selected on the fly, using composition
	;[[Template method pattern]]
	: Describes the [[program skeleton\|skeleton]] of a program; algorithms can be selected on the fly, using [[Inheritance (object-oriented programming)\|inheritance]]
	;[[Visitor pattern]]
	: A way to separate an algorithm from an object

	==See also==		==See also==

imported>7804j: Split Publish–subscribe pattern and Observer pattern -- they are distinct

2025-06-08T20:17:16Z

Split Publish–subscribe pattern and Observer pattern -- they are distinct

@@ Line 33: / Line 33: @@
 : Designed to act as a default value of an object
 <dl>
-<dt>[[Observer pattern]]</dt>
+ <dt>[[Observer pattern]]</dt>
-<dd>a.k.a. Publish/Subscribe or Event Listener. Objects register to observe an event that may be raised by another object
+ <dd>Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. The variant '''weak reference pattern''' decouples an observer from an observable to avoid memory leaks in environments without automatic weak references.<ref>{{cite web |last=Nakashian |first=Ashod |date=2004-04-11 |title=Weak Reference Pattern |url=http://c2.com/ |url-status=bot: unknown |archive-url=https://web.archive.org/web/20110303085751/http://c2.com/ |archive-date=2011-03-03 |access-date=2012-05-21 |publisher=c2.com}}</ref></dd></dl>
 ;[[Protocol stack]]
 : Communications are handled by multiple layers, which form an encapsulation hierarchy<ref>{{cite web
@@ Line 64: / Line 46: @@
   |url-status   = bot: unknown
 }}</ref>
 ;[[Scheduled-task pattern]]
 : A task is scheduled to be performed at a particular interval or clock time (used in [[real-time computing]])

imported>Frap: /* Design patterns */

2024-02-21T13:05:13Z

Design patterns

New page

{{short description|Type of software design pattern}}
In [[software engineering]], '''behavioral design patterns''' are [[design pattern (computer science)|design pattern]]s that identify common communication patterns among objects. By doing so, these patterns increase flexibility in carrying out communication.

== Design patterns ==
Examples of this type of design pattern include:

;[[Blackboard design pattern]]
: Provides a computational framework for the design and implementation of systems that integrate large and diverse specialized modules, and implement complex, non-deterministic control strategies
;[[Chain-of-responsibility pattern]]
: Command objects are handled or passed on to other objects by logic-containing processing objects
;[[Command pattern]]
: Command objects encapsulate an action and its parameters
;"Externalize the stack"
: Turn a [[Recursion (computer science)|recursive function]] into an [[iterative function]] that uses a [[call stack|stack]]<ref>{{cite web
|url = http://c2.com/
|title = Externalize The Stack
|date = 2010-01-19
|publisher = c2.com
|archive-url = https://web.archive.org/web/20110303085751/http://c2.com/
|archive-date = 2011-03-03
|access-date = 2012-05-21
|url-status = bot: unknown
}}</ref>
;[[Interpreter pattern]]
: Implement a specialized computer language to rapidly solve a specific set of problems
;[[Iterator pattern]]
: [[Iterator]]s are used to access the elements of an aggregate object sequentially without exposing its underlying representation
;[[Mediator pattern]]
: Provides a unified interface to a set of interfaces in a subsystem
;[[Memento pattern]]
: Provides the ability to restore an object to its previous state (rollback)
;[[Null object pattern]]
: Designed to act as a default value of an object
<dl>
<dt>[[Observer pattern]]</dt>
<dd>a.k.a. Publish/Subscribe or Event Listener. Objects register to observe an event that may be raised by another object
<dl>
<dt>Weak reference pattern</dt>
<dd>De-couple an observer from an observable<ref>{{cite web
|first = Ashod
|last = Nakashian
|url = http://c2.com/
|title = Weak Reference Pattern
|date = 2004-04-11
|publisher = c2.com
|archive-url = https://web.archive.org/web/20110303085751/http://c2.com/
|archive-date = 2011-03-03
|access-date = 2012-05-21
|url-status = bot: unknown
}}</ref>
</dd>
</dl>
</dd>
</dl>
;[[Protocol stack]]
: Communications are handled by multiple layers, which form an encapsulation hierarchy<ref>{{cite web
|url = http://c2.com/
|title = Protocol Stack
|date = 2006-09-05
|publisher = c2.com
|archive-url = https://web.archive.org/web/20110303085751/http://c2.com/
|archive-date = 2011-03-03
|access-date = 2012-05-21
|url-status = bot: unknown
}}</ref>
;[[Scheduled-task pattern]]
: A task is scheduled to be performed at a particular interval or clock time (used in [[real-time computing]])
;[[Single-serving visitor pattern]]
: Optimise the implementation of a visitor that is allocated, used only once, and then deleted
;[[Specification pattern]]
: Recombinable [[business logic]] in a [[boolean algebra|boolean]] fashion
;[[State pattern]]
: A clean way for an object to partially change its type at runtime
;[[Strategy pattern]]
: Algorithms can be selected on the fly, using composition
;[[Template method pattern]]
: Describes the [[program skeleton|skeleton]] of a program; algorithms can be selected on the fly, using [[Inheritance (object-oriented programming)|inheritance]]
;[[Visitor pattern]]
: A way to separate an algorithm from an object

==See also==
* [[Concurrency pattern]]
* [[Creational pattern]]
* [[Structural pattern]]

==References==
{{Reflist}}

{{Design Patterns patterns}}

[[Category:Software design patterns]]