Software design pattern, the Glossary
In software engineering, a design pattern describes a relatively small, well-defined aspect (i.e. functionality) of a computer program in terms of how to write the code.[1]
Table of Contents
154 relations: Abstract factory pattern, Abstraction principle (computer programming), Active object, Adapter pattern, Addison-Wesley, Aggregate pattern, Algorithm, Algorithmic skeleton, Anti-pattern, Architectural pattern, Artifact (software development), Artificial intelligence, Aspect-oriented programming, Asynchronous method invocation, Balking pattern, Behavioral pattern, Best practice, Binding properties pattern, Blackboard (design pattern), Blackboard system, Boolean algebra, Bridge pattern, Builder pattern, Business logic, C Sharp (programming language), C++, Canonical protocol pattern, Chain-of-responsibility pattern, Christopher Alexander, Class (computer programming), Code Complete, Code refactoring, Code reuse, Codebase, Command pattern, Component-based software engineering, Composite pattern, Compute kernel, Computer (magazine), Computer program, Computer programming, Computer science, Concept, Connection pool, Convolutional neural network, Copy-on-write, Creational pattern, Data and information visualization, Debugging pattern, Decorator pattern, ... Expand index (104 more) »
Abstract factory pattern
The abstract factory pattern in software engineering is a design pattern that provides a way to create families of related objects without imposing their concrete classes, by encapsulating a group of individual factories that have a common theme without specifying their concrete classes. Software design pattern and abstract factory pattern are software design patterns.
See Software design pattern and Abstract factory pattern
Abstraction principle (computer programming)
In software engineering and programming language theory, the abstraction principle (or the principle of abstraction) is a basic dictum that aims to reduce duplication of information in a program (usually with emphasis on code duplication) whenever practical by making use of abstractions provided by the programming language or software libraries.
See Software design pattern and Abstraction principle (computer programming)
Active object
The active object design pattern decouples method execution from method invocation for objects that each reside in their own thread of control. Software design pattern and active object are software design patterns.
See Software design pattern and Active object
Adapter pattern
In software engineering, the adapter pattern is a software design pattern (also known as wrapper, an alternative naming shared with the decorator pattern) that allows the interface of an existing class to be used as another interface. Software design pattern and adapter pattern are software design patterns.
See Software design pattern and Adapter pattern
Addison-Wesley
Addison–Wesley is an American publisher of textbooks and computer literature.
See Software design pattern and Addison-Wesley
Aggregate pattern
An Aggregate pattern can refer to concepts in either statistics or computer programming. Software design pattern and Aggregate pattern are software design patterns.
See Software design pattern and Aggregate pattern
Algorithm
In mathematics and computer science, an algorithm is a finite sequence of mathematically rigorous instructions, typically used to solve a class of specific problems or to perform a computation.
See Software design pattern and Algorithm
Algorithmic skeleton
In computing, algorithmic skeletons, or parallelism patterns, are a high-level parallel programming model for parallel and distributed computing.
See Software design pattern and Algorithmic skeleton
Anti-pattern
An anti-pattern in software engineering, project management, and business processes is a common response to a recurring problem that is usually ineffective and risks being highly counterproductive.
See Software design pattern and Anti-pattern
Architectural pattern
An architectural pattern is a general, reusable resolution to a commonly occurring problem in software architecture within a given context. Software design pattern and architectural pattern are software design patterns.
See Software design pattern and Architectural pattern
Artifact (software development)
An artifact is one of many kinds of tangible by-products produced during the development of software. Software design pattern and artifact (software development) are software development.
See Software design pattern and Artifact (software development)
Artificial intelligence
Artificial intelligence (AI), in its broadest sense, is intelligence exhibited by machines, particularly computer systems.
See Software design pattern and Artificial intelligence
Aspect-oriented programming
In computing, aspect-oriented programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns.
See Software design pattern and Aspect-oriented programming
Asynchronous method invocation
In multithreaded computer programming, asynchronous method invocation (AMI), also known as asynchronous method calls or the asynchronous pattern is a design pattern in which the call site is not blocked while waiting for the called code to finish. Software design pattern and asynchronous method invocation are software design patterns.
See Software design pattern and Asynchronous method invocation
Balking pattern
The balking pattern is a software design pattern that only executes an action on an object when the object is in a particular state. Software design pattern and balking pattern are software design patterns.
See Software design pattern and Balking pattern
Behavioral pattern
In software engineering, behavioral design patterns are design patterns that identify common communication patterns among objects. Software design pattern and behavioral pattern are software design patterns.
See Software design pattern and Behavioral pattern
Best practice
A best practice is a method or technique that has been generally accepted as superior to alternatives because it tends to produce superior results.
See Software design pattern and Best practice
Binding properties pattern
The binding properties pattern is combining multiple observers to force properties in different objects to be synchronized or coordinated in some way. Software design pattern and binding properties pattern are software design patterns.
See Software design pattern and Binding properties pattern
Blackboard (design pattern)
In software engineering, the blackboard pattern is a behavioral design pattern that 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. Software design pattern and blackboard (design pattern) are software design patterns.
See Software design pattern and Blackboard (design pattern)
Blackboard system
A blackboard system is an artificial intelligence approach based on the blackboard architectural model, where a common knowledge base, the "blackboard", is iteratively updated by a diverse group of specialist knowledge sources, starting with a problem specification and ending with a solution.
See Software design pattern and Blackboard system
Boolean algebra
In mathematics and mathematical logic, Boolean algebra is a branch of algebra.
See Software design pattern and Boolean algebra
Bridge pattern
The bridge pattern is a design pattern used in software engineering that is meant to "decouple an abstraction from its implementation so that the two can vary independently", introduced by the Gang of Four. Software design pattern and bridge pattern are software design patterns.
See Software design pattern and Bridge pattern
Builder pattern
The builder pattern is a design pattern that provides a flexible solution to various object creation problems in object-oriented programming. Software design pattern and builder pattern are software design patterns.
See Software design pattern and Builder pattern
Business logic
In computer software, business logic or domain logic is the part of the program that encodes the real-world business rules that determine how data can be created, stored, and changed.
See Software design pattern and Business logic
C Sharp (programming language)
C# is a general-purpose high-level programming language supporting multiple paradigms.
See Software design pattern and C Sharp (programming language)
C++
C++ (pronounced "C plus plus" and sometimes abbreviated as CPP) is a high-level, general-purpose programming language created by Danish computer scientist Bjarne Stroustrup.
See Software design pattern and C++
Canonical protocol pattern
Canonical Protocol is a design pattern, applied within the service-orientation design paradigm, which attempts to make services, within a service inventory, interoperable with each other by standardizing the communication protocols used by the services.
See Software design pattern and Canonical protocol pattern
Chain-of-responsibility pattern
In object-oriented design, the chain-of-responsibility pattern is a behavioral design pattern consisting of a source of command objects and a series of processing objects. Software design pattern and chain-of-responsibility pattern are software design patterns.
See Software design pattern and Chain-of-responsibility pattern
Christopher Alexander
Christopher Wolfgang John Alexander (4 October 1936 – 17 March 2022) was an Austrian-born British-American architect and design theorist.
See Software design pattern and Christopher Alexander
Class (computer programming)
In object-oriented programming, a class defines the shared aspects of objects created from the class.
See Software design pattern and Class (computer programming)
Code Complete
Code Complete is a software development book, written by Steve McConnell and published in 1993 by Microsoft Press, encouraging developers to continue past code-and-fix programming and the big design up front and waterfall models.
See Software design pattern and Code Complete
Code refactoring
In computer programming and software design, code refactoring is the process of restructuring existing source code—changing the factoring—without changing its external behavior.
See Software design pattern and Code refactoring
Code reuse
In software development (and computer programming in general), code reuse, also called software reuse, is the use of existing software, or software knowledge, to build new software, following the reusability principles.
See Software design pattern and Code reuse
Codebase
In software development, a codebase (or code base) is a collection of source code used to build a particular software system, application, or software component.
See Software design pattern and Codebase
Command pattern
In object-oriented programming, the command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time. Software design pattern and command pattern are software design patterns.
See Software design pattern and Command pattern
Component-based software engineering
Component-based software engineering (CBSE), also called component-based development (CBD), is a style of software engineering that aims to construct a software system from components that are loosely-coupled and reusable.
See Software design pattern and Component-based software engineering
Composite pattern
In software engineering, the composite pattern is a partitioning design pattern. Software design pattern and composite pattern are software design patterns.
See Software design pattern and Composite pattern
Compute kernel
In computing, a compute kernel is a routine compiled for high throughput accelerators (such as graphics processing units (GPUs), digital signal processors (DSPs) or field-programmable gate arrays (FPGAs)), separate from but used by a main program (typically running on a central processing unit).
See Software design pattern and Compute kernel
Computer (magazine)
Computer is an IEEE Computer Society practitioner-oriented magazine issued to all members of the society.
See Software design pattern and Computer (magazine)
Computer program
A computer program is a sequence or set of instructions in a programming language for a computer to execute.
See Software design pattern and Computer program
Computer programming
Computer programming or coding is the composition of sequences of instructions, called programs, that computers can follow to perform tasks. Software design pattern and computer programming are software development.
See Software design pattern and Computer programming
Computer science
Computer science is the study of computation, information, and automation.
See Software design pattern and Computer science
Concept
A concept is defined as an abstract idea.
See Software design pattern and Concept
Connection pool
In software engineering, a connection pool is a cache of database connections maintained so that the connections can be reused when future requests to the database are required.
See Software design pattern and Connection pool
Convolutional neural network
A convolutional neural network (CNN) is a regularized type of feed-forward neural network that learns features by itself via filter (or kernel) optimization.
See Software design pattern and Convolutional neural network
Copy-on-write
Copy-on-write (COW), sometimes referred to as implicit sharing or shadowing, is a resource-management technique used in computer programming to efficiently implement a "duplicate" or "copy" operation on modifiable resources (most commonly memory pages, storage sectors, files, and data structures).
See Software design pattern and Copy-on-write
Creational pattern
In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. Software design pattern and creational pattern are software design patterns.
See Software design pattern and Creational pattern
Data and information visualization
Data and information visualization (data viz/vis or info viz/vis) is the practice of designing and creating easy-to-communicate and easy-to-understand graphic or visual representations of a large amount of complex quantitative and qualitative data and information with the help of static, dynamic or interactive visual items.
See Software design pattern and Data and information visualization
Debugging pattern
A debugging pattern describes a generic set of steps to rectify or correct a bug within a software system. Software design pattern and debugging pattern are software design patterns.
See Software design pattern and Debugging pattern
Decorator pattern
In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, dynamically, without affecting the behavior of other instances of the same class. Software design pattern and decorator pattern are software design patterns.
See Software design pattern and Decorator pattern
Delegation pattern
In software engineering, the delegation pattern is an object-oriented design pattern that allows object composition to achieve the same code reuse as inheritance. Software design pattern and delegation pattern are software design patterns.
See Software design pattern and Delegation pattern
Dependency injection
In software engineering, dependency injection is a programming technique in which an object or function receives other objects or functions that it requires, as opposed to creating them internally. Software design pattern and dependency injection are software design patterns.
See Software design pattern and Dependency injection
Design pattern
A design pattern is the re-usable form of a solution to a design problem.
See Software design pattern and Design pattern
Design Patterns
Design Patterns: Elements of Reusable Object-Oriented Software (1994) is a software engineering book describing software design patterns. Software design pattern and design Patterns are software design patterns.
See Software design pattern and Design Patterns
Distributed design patterns
In software engineering, a distributed design pattern is a design pattern focused on distributed computing problems. Software design pattern and distributed design patterns are software design patterns.
See Software design pattern and Distributed design patterns
Documentation
Documentation is any communicable material that is used to describe, explain or instruct regarding some attributes of an object, system or procedure, such as its parts, assembly, installation, maintenance, and use.
See Software design pattern and Documentation
Double-chance function
In software engineering, a double-chance function is a software design pattern with a strong application in cross-platform and scalable development. Software design pattern and double-chance function are software design patterns.
See Software design pattern and Double-chance function
Double-checked locking
In software engineering, double-checked locking (also known as "double-checked locking optimization") is a software design pattern used to reduce the overhead of acquiring a lock by testing the locking criterion (the "lock hint") before acquiring the lock. Software design pattern and double-checked locking are software design patterns.
See Software design pattern and Double-checked locking
Dylan (programming language)
Dylan is a multi-paradigm programming language that includes support for functional and object-oriented programming (OOP), and is dynamic and reflective while providing a programming model designed to support generating efficient machine code, including fine-grained control over dynamic and static behaviors.
See Software design pattern and Dylan (programming language)
Enterprise architecture framework
An enterprise architecture framework (EA framework) defines how to create and use an enterprise architecture.
See Software design pattern and Enterprise architecture framework
Erich Gamma
Erich Gamma is a Swiss computer scientist and one of the four co-authors (referred to as "Gang of Four") of the software engineering textbook, Design Patterns: Elements of Reusable Object-Oriented Software.
See Software design pattern and Erich Gamma
Execution (computing)
Execution in computer and software engineering is the process by which a computer or virtual machine interprets and acts on the instructions of a computer program.
See Software design pattern and Execution (computing)
Facade pattern
The facade pattern (also spelled façade) is a software design pattern commonly used in object-oriented programming. Software design pattern and facade pattern are software design patterns.
See Software design pattern and Facade pattern
Factory method pattern
In object oriented programming, the factory method pattern is a design pattern that uses factory methods to deal with the problem of creating objects without having to specify their exact class. Software design pattern and factory method pattern are software design patterns.
See Software design pattern and Factory method pattern
Fluent interface
In software engineering, a fluent interface is an object-oriented API whose design relies extensively on method chaining. Software design pattern and fluent interface are software design patterns.
See Software design pattern and Fluent interface
Flyweight pattern
In computer programming, the flyweight software design pattern refers to an object that minimizes memory usage by sharing some of its data with other similar objects. Software design pattern and flyweight pattern are software design patterns.
See Software design pattern and Flyweight pattern
Front controller
The front controller software design pattern is listed in several pattern catalogs and is related to the design of web applications. Software design pattern and front controller are software design patterns.
See Software design pattern and Front controller
Functional programming
In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions.
See Software design pattern and Functional programming
Graphics processing unit
A graphics processing unit (GPU) is a specialized electronic circuit initially designed for digital image processing and to accelerate computer graphics, being present either as a discrete video card or embedded on motherboards, mobile phones, personal computers, workstations, and game consoles.
See Software design pattern and Graphics processing unit
GRASP (object-oriented design)
General Responsibility Assignment Software Patterns (or Principles), abbreviated GRASP, is a set of "nine fundamental principles in object design and responsibility assignment" first published by Craig Larman in his 1997 book Applying UML and Patterns.
See Software design pattern and GRASP (object-oriented design)
Guarded suspension
In concurrent programming, guarded suspension is a software design pattern for managing operations that require both a lock to be acquired and a precondition to be satisfied before the operation can be executed. Software design pattern and guarded suspension are software design patterns.
See Software design pattern and Guarded suspension
Helper class
In object-oriented programming, a helper class is used to assist in providing some functionality, which isn't the main goal of the application or class in which it is used.
See Software design pattern and Helper class
Indirection
In computer programming, an indirection (also called a reference) is a way of referring to something using a name, reference, or container instead of the value itself.
See Software design pattern and Indirection
Interaction design pattern
Interaction design patterns are design patterns applied in the context human-computer interaction, describing common designs for graphical user interfaces. Software design pattern and interaction design pattern are software design patterns.
See Software design pattern and Interaction design pattern
Interpreter pattern
In computer programming, the interpreter pattern is a design pattern that specifies how to evaluate sentences in a language. Software design pattern and interpreter pattern are software design patterns.
See Software design pattern and Interpreter pattern
Iterator pattern
In object-oriented programming, the iterator pattern is a design pattern in which an iterator is used to traverse a container and access the container's elements. Software design pattern and iterator pattern are software design patterns.
See Software design pattern and Iterator pattern
Java (programming language)
Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible.
See Software design pattern and Java (programming language)
John Vlissides
John Matthew Vlissides (August 2, 1961 – November 24, 2005) was a software engineer known mainly as one of the four authors (referred to as the Gang of Four) of the book Design Patterns: Elements of Reusable Object-Oriented Software.
See Software design pattern and John Vlissides
Join-pattern
Join-patterns provides a way to write concurrent, parallel and distributed computer programs by message passing. Software design pattern and Join-pattern are software design patterns.
See Software design pattern and Join-pattern
Joshua Bloch
Joshua J. Bloch (born August 28, 1961) is an American software engineer and a technology author.
See Software design pattern and Joshua Bloch
Kent Beck
Kent Beck (born 1961) is an American software engineer and the creator of extreme programming, a software development methodology that eschews rigid formal specification for a collaborative and iterative design process.
See Software design pattern and Kent Beck
Lazy initialization
In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed. Software design pattern and lazy initialization are software design patterns.
See Software design pattern and Lazy initialization
Library (computing)
In computer science, a library is a collection of read-only resources that is leveraged during software development to implement a computer program.
See Software design pattern and Library (computing)
Lisp (programming language)
Lisp (historically LISP, an abbreviation of "list processing") is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation.
See Software design pattern and Lisp (programming language)
List of software development philosophies
This is a list of approaches, styles, methodologies, and philosophies in software development and engineering.
See Software design pattern and List of software development philosophies
Lock (computer science)
In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive that prevents state from being modified or accessed by multiple threads of execution at once. Software design pattern and lock (computer science) are software design patterns.
See Software design pattern and Lock (computer science)
Loose coupling
In computing and systems design, a loosely coupled system is one.
See Software design pattern and Loose coupling
Marker interface pattern
The marker interface pattern is a design pattern in computer science, used with languages that provide run-time type information about objects. Software design pattern and marker interface pattern are software design patterns.
See Software design pattern and Marker interface pattern
Martin Fowler (software engineer)
Martin Fowler (18 December 1963) is a British software developer, author and international public speaker on software development, specialising in object-oriented analysis and design, UML, patterns, and agile software development methodologies, including extreme programming.
See Software design pattern and Martin Fowler (software engineer)
Matrix multiplication
In mathematics, particularly in linear algebra, matrix multiplication is a binary operation that produces a matrix from two matrices.
See Software design pattern and Matrix multiplication
In software engineering, the mediator pattern defines an object that encapsulates how a set of objects interact. Software design pattern and mediator pattern are software design patterns.
See Software design pattern and Mediator pattern
Memento pattern
The memento pattern is a software design pattern that exposes the private internal state of an object. Software design pattern and memento pattern are software design patterns.
See Software design pattern and Memento pattern
Messaging pattern
In software architecture, a messaging pattern is an architectural pattern which describes how two different parts of an application, or different systems connect and communicate with each other.
See Software design pattern and Messaging pattern
Microsoft Press
Microsoft Press is the publishing arm of Microsoft, usually releasing books dealing with various current Microsoft technologies.
See Software design pattern and Microsoft Press
Module pattern
In software engineering, the module pattern is a design pattern used to implement the concept of software modules, defined by modular programming, in a programming language with incomplete direct support for the concept. Software design pattern and module pattern are software design patterns.
See Software design pattern and Module pattern
Monitor (synchronization)
In concurrent programming, a monitor is a synchronization construct that prevents threads from concurrently accessing a shared object's state and allows them to wait for the state to change. Software design pattern and monitor (synchronization) are software design patterns.
See Software design pattern and Monitor (synchronization)
Multiton pattern
In software engineering, the multiton pattern is a design pattern which generalizes the singleton pattern. Software design pattern and multiton pattern are software design patterns.
See Software design pattern and Multiton pattern
Mutual exclusion
In computer science, mutual exclusion is a property of concurrency control, which is instituted for the purpose of preventing race conditions.
See Software design pattern and Mutual exclusion
Nantes
Nantes (Gallo: Naunnt or Nantt) is a city in Loire-Atlantique of France on the Loire, from the Atlantic coast.
See Software design pattern and Nantes
Null object pattern
In object-oriented computer programming, a null object is an object with no referenced value or with defined neutral (null) behavior. Software design pattern and null object pattern are software design patterns.
See Software design pattern and Null object pattern
O'Reilly Media, Inc. (formerly O'Reilly & Associates) is an American learning company established by Tim O'Reilly provides technical and professional skills development courses via an online learning platform.
See Software design pattern and O'Reilly Media
Object (computer science)
In computer science, an object is a programming element that has state, has associated operations and is accessed via an identifier.
See Software design pattern and Object (computer science)
Object pool pattern
The object pool pattern is a software creational design pattern that uses a set of initialized objects kept ready to use – a "pool" – rather than allocating and destroying them on demand. Software design pattern and object pool pattern are software design patterns.
See Software design pattern and Object pool pattern
Object-oriented programming
Object-oriented programming (OOP) is a programming paradigm based on the concept of objects, which can contain data and code: data in the form of fields (often known as attributes or properties), and code in the form of procedures (often known as methods).
See Software design pattern and Object-oriented programming
Observer pattern
In software design and engineering, the observer pattern is a software design pattern in which an object, named the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods. Software design pattern and observer pattern are software design patterns.
See Software design pattern and Observer pattern
OOPSLA
OOPSLA (Object-Oriented Programming, Systems, Languages & Applications) is an annual ACM research conference.
See Software design pattern and OOPSLA
Outline of software engineering
The following outline is provided as an overview of and topical guide to software engineering: Software engineering – application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software; that is the application of engineering to software.
See Software design pattern and Outline of software engineering
Oxford University Press
Oxford University Press (OUP) is the publishing house of the University of Oxford.
See Software design pattern and Oxford University Press
Pattern (architecture)
Pattern in architecture is the idea of capturing architectural design ideas as archetypal and reusable descriptions.
See Software design pattern and Pattern (architecture)
Pattern language
A pattern language is an organized and coherent set of patterns, each of which describes a problem and the core of a solution that can be used in many ways within a specific field of expertise.
See Software design pattern and Pattern language
Pattern Languages of Programs
Pattern Languages of Programs is the name of a group of annual conferences sponsored by The Hillside Group.
See Software design pattern and Pattern Languages of Programs
Pattern theory
Pattern theory, formulated by Ulf Grenander, is a mathematical formalism to describe knowledge of the world as patterns.
See Software design pattern and Pattern theory
Pattern-Oriented Software Architecture
Pattern-Oriented Software Architecture is a series of software engineering books describing software design patterns. Software design pattern and pattern-Oriented Software Architecture are software design patterns.
See Software design pattern and Pattern-Oriented Software Architecture
Paul Graham (programmer)
Paul Graham (born November 13, 1964) is an English-American computer scientist, writer, entrepreneur and investor.
See Software design pattern and Paul Graham (programmer)
Pedagogical pattern
A pedagogical pattern is the re-usable form of a solution to a problem or task in pedagogy, analogous to how a design pattern is the re-usable form of a solution to a design problem.
See Software design pattern and Pedagogical pattern
Peter Norvig
Peter Norvig (born December 14, 1956) is an American computer scientist and Distinguished Education Fellow at the Stanford Institute for Human-Centered AI.
See Software design pattern and Peter Norvig
Portland Pattern Repository
The Portland Pattern Repository (PPR) is an online repository for computer programming software design patterns. Software design pattern and Portland Pattern Repository are software design patterns.
See Software design pattern and Portland Pattern Repository
Prentice Hall
Prentice Hall was a major American educational publisher.
See Software design pattern and Prentice Hall
Programmer
A programmer, computer programmer or coder is an author of computer source code someone with skill in computer programming.
See Software design pattern and Programmer
Programming idiom
In computer programming, a programming idiom or code idiom is a group of code fragments sharing an equivalent semantic role, which recurs frequently across software projects often expressing a special feature of a recurring construct in one or more programming languages or libraries.
See Software design pattern and Programming idiom
Programming paradigm
A programming paradigm is a relatively high-level way to conceptualize and structure the implementation of a computer program.
See Software design pattern and Programming paradigm
Prototype pattern
The prototype pattern is a creational design pattern in software development. Software design pattern and prototype pattern are software design patterns.
See Software design pattern and Prototype pattern
Proxy pattern
In computer programming, the proxy pattern is a software design pattern. Software design pattern and proxy pattern are software design patterns.
See Software design pattern and Proxy pattern
Publish–subscribe pattern
In software architecture, publish–subscribe is a messaging pattern where publishers categorize messages into classes that are received by subscribers. Software design pattern and publish–subscribe pattern are software design patterns.
See Software design pattern and Publish–subscribe pattern
Quality (business)
In business, engineering, and manufacturing, quality – or high quality – has a pragmatic interpretation as the non-inferiority or superiority of something (goods or services); it is also defined as being suitable for the intended purpose (fitness for purpose) while satisfying customer expectations.
See Software design pattern and Quality (business)
Ralph Johnson (computer scientist)
Ralph E. Johnson is a Research Associate Professor in the Department of Computer Science at the University of Illinois at Urbana-Champaign.
See Software design pattern and Ralph Johnson (computer scientist)
Reactor pattern
The reactor software design pattern is an event handling strategy that can respond to many potential service requests concurrently. Software design pattern and reactor pattern are software design patterns.
See Software design pattern and Reactor pattern
Readers–writer lock
In computer science, a readers–writer (single-writer lock, a multi-reader lock, a push lock, or an MRSW lock) is a synchronization primitive that solves one of the readers–writers problems. Software design pattern and readers–writer lock are software design patterns.
See Software design pattern and Readers–writer lock
Reinventing the wheel
To reinvent the wheel is to attempt to duplicate—most likely with inferior results—a basic method that has already previously been created or optimized by others.
See Software design pattern and Reinventing the wheel
Resource acquisition is initialization
Resource acquisition is initialization (RAII) is a programming idiom used in several object-oriented, statically typed programming languages to describe a particular language behavior. Software design pattern and Resource acquisition is initialization are software design patterns.
See Software design pattern and Resource acquisition is initialization
Richard Helm
Richard Helm is one of the "Gang of Four" who wrote the influential Design Patterns book.
See Software design pattern and Richard Helm
Scheduling (computing)
In computing, scheduling is the action of assigning resources to perform tasks. Software design pattern and scheduling (computing) are software design patterns.
See Software design pattern and Scheduling (computing)
Servant (design pattern)
In software engineering, the servant pattern defines an object used to offer some functionality to a group of classes without defining that functionality in each of them. Software design pattern and servant (design pattern) are software design patterns.
See Software design pattern and Servant (design pattern)
Singleton pattern
In software engineering, the singleton pattern is a software design pattern that restricts the instantiation of a class to a singular instance. Software design pattern and singleton pattern are software design patterns.
See Software design pattern and Singleton pattern
Software design
Software design is the process of conceptualizing how a software system will work before it is implemented or modified. Software design pattern and software design are software development.
See Software design pattern and Software design
Software development
Software development is the process used to create software.
See Software design pattern and Software development
Software development process
In software engineering, a software development process or software development life cycle is a process of planning and managing software development. Software design pattern and software development process are software development.
See Software design pattern and Software development process
Software engineering
Software engineering is an engineering approach to software development.
See Software design pattern and Software engineering
Source code
In computing, source code, or simply code or source, is a plain text computer program written in a programming language.
See Software design pattern and Source code
Specification pattern
In computer programming, the specification pattern is a particular software design pattern, whereby business rules can be recombined by chaining the business rules together using boolean logic. Software design pattern and specification pattern are software design patterns.
See Software design pattern and Specification pattern
Springer Nature
Springer Nature or the Springer Nature Group is a German-British academic publishing company created by the May 2015 merger of Springer Science+Business Media and Holtzbrinck Publishing Group's Nature Publishing Group, Palgrave Macmillan, and Macmillan Education.
See Software design pattern and Springer Nature
State pattern
The state pattern is a behavioral software design pattern that allows an object to alter its behavior when its internal state changes. Software design pattern and state pattern are software design patterns.
See Software design pattern and State pattern
Strategy pattern
In computer programming, the strategy pattern (also known as the policy pattern) is a behavioral software design pattern that enables selecting an algorithm at runtime. Software design pattern and strategy pattern are software design patterns.
See Software design pattern and Strategy pattern
Structural pattern
In software engineering, structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships among entities. Software design pattern and structural pattern are software design patterns.
See Software design pattern and Structural pattern
Tektronix
Tektronix, historically widely known as Tek, is an American company best known for manufacturing test and measurement devices such as oscilloscopes, logic analyzers, and video and mobile test protocol equipment.
See Software design pattern and Tektronix
Template method pattern
In object-oriented programming, the template method is one of the behavioral design patterns identified by Gamma et al. Software design pattern and template method pattern are software design patterns.
See Software design pattern and Template method pattern
Thread pool
In computer programming, a thread pool is a software design pattern for achieving concurrency of execution in a computer program. Software design pattern and thread pool are software design patterns.
See Software design pattern and Thread pool
Thread-local storage
In computer programming, thread-local storage (TLS) is a memory management method that uses static or global memory local to a thread. Software design pattern and thread-local storage are software design patterns.
See Software design pattern and Thread-local storage
Twin pattern
In software engineering, the Twin pattern is a software design pattern that allows developers to model multiple inheritance in programming languages that do not support multiple inheritance. Software design pattern and Twin pattern are software design patterns.
See Software design pattern and Twin pattern
Unified Modeling Language
The unified modeling language (UML) is a general-purpose visual modeling language that is intended to provide a standard way to visualize the design of a system.
See Software design pattern and Unified Modeling Language
User interface
In the industrial design field of human–computer interaction, a user interface (UI) is the space where interactions between humans and machines occur.
See Software design pattern and User interface
Visitor pattern
A visitor pattern is a software design pattern that separates the algorithm from the object structure. Software design pattern and visitor pattern are software design patterns.
See Software design pattern and Visitor pattern
Ward Cunningham
Howard G. Cunningham (born May 26, 1949) is an American computer programmer who developed the first wiki and was a co-author of the Manifesto for Agile Software Development. Software design pattern and Ward Cunningham are software design patterns.
See Software design pattern and Ward Cunningham
Wiley (publisher)
John Wiley & Sons, Inc., commonly known as Wiley, is an American multinational publishing company that focuses on academic publishing and instructional materials.
See Software design pattern and Wiley (publisher)
References
[1] https://en.wikipedia.org/wiki/Software_design_pattern
Also known as Design Pattern (Computer Science), Design pattern (computing), Design patterns (computer science), List of Object-oriented design patterns, List of software design patterns, Programmer's practice, Programming design pattern, Programming pattern, Programming practice, Software design patterns, Software pattern.
, Delegation pattern, Dependency injection, Design pattern, Design Patterns, Distributed design patterns, Documentation, Double-chance function, Double-checked locking, Dylan (programming language), Enterprise architecture framework, Erich Gamma, Execution (computing), Facade pattern, Factory method pattern, Fluent interface, Flyweight pattern, Front controller, Functional programming, Graphics processing unit, GRASP (object-oriented design), Guarded suspension, Helper class, Indirection, Interaction design pattern, Interpreter pattern, Iterator pattern, Java (programming language), John Vlissides, Join-pattern, Joshua Bloch, Kent Beck, Lazy initialization, Library (computing), Lisp (programming language), List of software development philosophies, Lock (computer science), Loose coupling, Marker interface pattern, Martin Fowler (software engineer), Matrix multiplication, Mediator pattern, Memento pattern, Messaging pattern, Microsoft Press, Module pattern, Monitor (synchronization), Multiton pattern, Mutual exclusion, Nantes, Null object pattern, O'Reilly Media, Object (computer science), Object pool pattern, Object-oriented programming, Observer pattern, OOPSLA, Outline of software engineering, Oxford University Press, Pattern (architecture), Pattern language, Pattern Languages of Programs, Pattern theory, Pattern-Oriented Software Architecture, Paul Graham (programmer), Pedagogical pattern, Peter Norvig, Portland Pattern Repository, Prentice Hall, Programmer, Programming idiom, Programming paradigm, Prototype pattern, Proxy pattern, Publish–subscribe pattern, Quality (business), Ralph Johnson (computer scientist), Reactor pattern, Readers–writer lock, Reinventing the wheel, Resource acquisition is initialization, Richard Helm, Scheduling (computing), Servant (design pattern), Singleton pattern, Software design, Software development, Software development process, Software engineering, Source code, Specification pattern, Springer Nature, State pattern, Strategy pattern, Structural pattern, Tektronix, Template method pattern, Thread pool, Thread-local storage, Twin pattern, Unified Modeling Language, User interface, Visitor pattern, Ward Cunningham, Wiley (publisher).