 |
Pattern-Oriented Software Architecture is a series of software engineering books describing software design patterns.
|
Pattern-Oriented Software Architecture is a series of software engineering books describing software design patterns.
David E. DeLano of C++ Report praised the first volume, writing, "Overall this text is good and I recommend it as an addition to any collection of books on patterns." He said "some of the language and grammar usage feels awkward to the reader" and some of the book has "stiffness and flow problems". [1] Ian Graham reviewed the first volume in the Journal of Object-Oriented Programming. [2] DBMS columnist David S. Linthicum found the first volume to be "the best book on patterns for application architects", while Bin Yang of JavaWorld thought it had "many interesting architecture and design patterns". [3] [4]
ACCU writer Ian Glassborow reviewed the second volume, writing, "This book is one of the more important contributions to the literature on 'patterns' and deserves to become a standard text on its specified area of interest." [5] The Software Engineering Institute author Paul Clemente found the first two volumes to be "the best-known catalog of architectural patterns". [6] Regarding the third volume, D. Murali recommended that software engineers should follow the "eager acquisition" pattern. [7]
 | |
| Author | Frank Buschmann, Regine Meunier, Hans Rohnert, Peter Sommerlad and Michael Stal |
|---|---|
| Language | English |
| Subject | Computer programming |
| Published |
|
| ISBN | 978-0471958697 |
| | |
| Author | Douglas C. Schmidt, Michael Stal, Hans Rohnert, Frank Buschmann |
|---|---|
| Language | English |
| Subject | Computer programming |
| Published | 2000 |
| ISBN | 978-0471606956 |
Service access and configuration patterns
Event handling patterns
Synchronization patterns
Concurrency patterns
| | |
| Author | Michael Kircher, Prashant Jain |
|---|---|
| Language | English |
| Subject | Computer programming |
| Published |
|
| ISBN | 978-0470845257 |
Resource acquisition
Resource lifecycle
Resource release
| | |
| Author | Frank Buschmann, Kevlin Henney, Douglas C. Schmidt |
|---|---|
| Language | English |
| Subject | Computer programming |
| Published |
|
| ISBN | 978-0470059029 |
Software architecture
Distribution Infrastructure
Adaptation and execution
Resource management
Database access
| | |
| Author | Frank Buschmann, Kevlin Henney, Douglas C. Schmidt |
|---|---|
| Language | English |
| Subject | Computer programming |
| Published |
|
| ISBN | 978-0471486480 |
Patterns referenced in volume 5:
Design Patterns: Elements of Reusable Object-Oriented Software (1994) is a software engineering book describing software design patterns. The book was written by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, with a foreword by Grady Booch. The book is divided into two parts, with the first two chapters exploring the capabilities and pitfalls of object-oriented programming, and the remaining chapters describing 23 classic software design patterns. The book includes examples in C++ and Smalltalk.
The Common Object Request Broker Architecture (CORBA) is a standard defined by the Object Management Group (OMG) designed to facilitate the communication of systems that are deployed on diverse platforms. CORBA enables collaboration between systems on different operating systems, programming languages, and computing hardware. CORBA uses an object-oriented model although the systems that use the CORBA do not have to be object-oriented. CORBA is an example of the distributed object paradigm.
In software engineering, the adapter pattern is a software design pattern that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code.
The facade pattern is a software design pattern commonly used in object-oriented programming. Analogous to a façade in architecture, it is an object that serves as a front-facing interface masking more complex underlying or structural code. A facade can:
In computer programming, the proxy pattern is a software design pattern. A proxy, in its most general form, is a class functioning as an interface to something else. The proxy could interface to anything: a network connection, a large object in memory, a file, or some other resource that is expensive or impossible to duplicate. In short, a proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes. Use of the proxy can simply be forwarding to the real object, or can provide additional logic. In the proxy, extra functionality can be provided, for example caching when operations on the real object are resource intensive, or checking preconditions before operations on the real object are invoked. For the client, usage of a proxy object is similar to using the real object, because both implement the same interface.
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. This information includes the method name, the object that owns the method and values for the method parameters.
This is a list of terms found in object-oriented programming.
Model–view–controller (MVC) is a software design pattern commonly used for developing user interfaces that divides the related program logic into three interconnected elements. These elements are:
In software engineering, structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships among entities.
In computer programming, a poltergeist is a short-lived, typically stateless object used to perform initialization or to invoke methods in another, more permanent class. It is considered an anti-pattern. The original definition is by Michael Akroyd at the 1996 Object World West Conference:
As a gypsy wagon or a poltergeist appears and disappears mysteriously, so does this short lived object. As a consequence the code is more difficult to maintain and there is unnecessary resource waste. The typical cause for this anti-pattern is poor object design.
Microsoft Transaction Server (MTS) was software that provided services to Component Object Model (COM) software components, to make it easier to create large distributed applications. The major services provided by MTS were automated transaction management, instance management and role-based security. MTS is considered to be the first major software to implement aspect-oriented programming.
In object-oriented design, the dependency inversion principle is a specific methodology for loosely coupled software modules. When following this principle, the conventional dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are reversed, thus rendering high-level modules independent of the low-level module implementation details. The principle states:
General Responsibility Assignment Software Patterns, 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.
The Spring Framework is an application framework and inversion of control container for the Java platform. The framework's core features can be used by any Java application, but there are extensions for building web applications on top of the Java EE platform. The framework does not impose any specific programming model.. The framework has become popular in the Java community as an addition to the Enterprise JavaBeans (EJB) model. The Spring Framework is free and open source software.
Domain-driven design (DDD) is a major software design approach, focusing on modeling software to match a domain according to input from that domain's experts. DDD is against the idea of having a single unified model; instead it divides a large system into bounded contexts, each of which have their own model.
Component Object Model (COM) is a binary-interface technology for software components from Microsoft that enables using objects in a language-neutral way between different programming languages, programming contexts, processes and machines.
Wrapper libraries consist of a thin layer of code which translates a library's existing interface into a compatible interface. This is done for several reasons:
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. Each processing object contains logic that defines the types of command objects that it can handle; the rest are passed to the next processing object in the chain. A mechanism also exists for adding new processing objects to the end of this chain.
Distributed Data Management Architecture (DDM) is IBM's open, published software architecture for creating, managing and accessing data on a remote computer. DDM was initially designed to support record-oriented files; it was extended to support hierarchical directories, stream-oriented files, queues, and system command processing; it was further extended to be the base of IBM's Distributed Relational Database Architecture (DRDA); and finally, it was extended to support data description and conversion. Defined in the period from 1980 to 1993, DDM specifies necessary components, messages, and protocols, all based on the principles of object-orientation. DDM is not, in itself, a piece of software; the implementation of DDM takes the form of client and server products. As an open architecture, products can implement subsets of DDM architecture and products can extend DDM to meet additional requirements. Taken together, DDM products implement a distributed file system.
  | This article about a software book or series of books is a stub. You can help Wikipedia by expanding it. |