Pattern-Oriented Software Architecture

Pattern-Oriented Software Architecture is a series of software engineering books describing software design patterns.

POSA1
Architectural patterns
 * Layers
 * Pipes and filters
 * Blackboard
 * Broker
 * Model–View–Controller
 * Presentation–Abstraction–Control

Design patterns
 * Whole–Part
 * Master–Slave
 * Proxy
 * Command Processor
 * View Handler
 * Forwarder-Receiver
 * Client–Dispatcher–Server
 * Publisher–subscriber

POSA2
Service access and configuration patterns Event handling patterns Synchronization patterns Concurrency patterns
 * Wrapper Facade
 * Component Configurator
 * Interceptor
 * Extension interface
 * Reactor
 * Proactor
 * Asynchronous Completion Token
 * Acceptor-Connector
 * Scoped Locking
 * Strategized Locking
 * Thread-Safe Interface
 * Double-checked locking
 * Active object
 * Monitor Object
 * Half-Sync/Half-Async
 * Leader/Followers
 * Thread-Specific Storage

POSA3
Resource acquisition
 * Lookup
 * Lazy acquisition
 * Eager acquisition

Resource lifecycle
 * Caching
 * Pooling
 * Coordinator
 * Resource Lifecycle Manager

Resource release
 * Leasing
 * Evictor

POSA4
Software architecture
 * Domain model
 * Layers
 * Model–View–Controller
 * Presentation–Abstraction–Control
 * Microkernel
 * Reflection
 * Pipes and filters
 * Shared repository
 * Blackboard
 * Domain object

Distribution Infrastructure
 * Message Channel
 * Message endpoint
 * Message translator
 * Message route
 * Publisher–subscriber
 * Broker
 * Client proxy
 * Requestor
 * Invoker
 * Client request handler
 * server request handler

Adaptation and execution
 * Bridge
 * Object Adapter
 * Chain of responsitiblity
 * Interpreter
 * Interceptor
 * Visitor
 * Decorator
 * Execute-Around Object
 * Template method
 * Strategy
 * Null Object
 * Wrapper Facade
 * Declarative component configuration

Resource management
 * Container
 * Component Configurator
 * Object manager
 * Lookup
 * Virtual Proxy
 * Lifecycle callback
 * Task coordinator
 * Resource pool
 * Resource cache
 * Lazy Acquisition
 * Eager Acquisition
 * Partial Acquisition
 * Activator
 * Evictor
 * Leasing
 * Automated Garbage Collection
 * Counting Handle
 * Abstract Factory
 * Builder
 * Factory method
 * Disposal Method

Database access
 * Database Access Layer
 * Data mapper
 * Row Data Gateway
 * Table Data Gateway
 * Active Record

POSA5
Patterns referenced in volume 5:
 * Abstract Factory
 * Acceptor-Connector
 * Active Object
 * Adapted Iterator
 * Adapter
 * Align Architecture and Organization (see Conway's Law)
 * Application Controller
 * Architect Also Implements
 * Architecture Follows Organization
 * Asynchronous Completion Token (ACT)
 * Automated Garbage Collection
 * Batch Iterator
 * Batch Method
 * Blackboard
 * Bridge
 * Broker
 * Build Prototypes
 * Builder
 * Bureaucracy
 * Business Delegate
 * Cantrip
 * Chain of Responsibility
 * Class Adapter
 * CLI Server
 * Client Proxy
 * Collections for States
 * Combined Method
 * Command
 * Command Processor
 * Command Sequence (see Composite Command)
 * Community of Trust
 * Compiler
 * Completion Headroom
 * Component Configurator
 * Composite
 * Composite Command
 * Composite-Strategy-Observer (see Model-View-Controller (MVC))
 * Context Object
 * Conway's Law
 * Cooperate, Don’t Control
 * CORBA-CGI Gateway
 * Data Access Object (DAO)
 * Data is the Next Intel Inside
 * Data Transfer Object (DTO)
 * Decorator
 * Disposal Method
 * Distributed Callback
 * Domain Appropriate Devices
 * Domain Model
 * Domain Object
 * Domain Store
 * Don't Flip the Bozo Bit
 * Dynamic Invocation Interface (DII)
 * ed
 * Encapsulated Context (see Context Object)
 * Engage Customers
 * Enumeration Method
 * Explicit Interface
 * External Iterator
 * Facade
 * Factory Method
 * Few Panes Per Window
 * Filter
 * Firewall Proxy
 * Flat and Narrow Tree
 * Forwarder-Receiver
 * Front Controller
 * Half-Sync/Half-Asynchronous
 * Harnessing Collective Intelligence
 * Immutable Value
 * Information Just In Time
 * Interceptor
 * Internal Iterator (see Enumeration Method)
 * Interpreter
 * Invisible Hardware
 * Involve Everyone
 * Iterator
 * Layers
 * Leader/Followers
 * Leveraging the Long Tail
 * Macro Command (see Composite Command)
 * Manager (see Object Manager)
 * Mediator
 * Memento
 * Message
 * Methods for States
 * Mock Object
 * Model-View-Controller (MVC)
 * Monitor Object
 * Mutable Companion
 * Network Effects by Default
 * Nouns and Verbs
 * Null Object
 * Object Adapter
 * Object Manager
 * Objects for States
 * Observer
 * Organization Follows Architecture
 * Page Controller
 * Perpetual Beta
 * Pipes and Filters
 * Pluggable Adapter
 * Pluggable Factory
 * Polyvalent-Program
 * Presentation-Abstraction-Control (PAC)
 * Proactor
 * Prototype
 * Prototype-Abstract Factory (see Pluggable Factory)
 * Proxy
 * Publisher-Subscriber
 * Reactor
 * Reflection
 * Remote Proxy (see Client Proxy)
 * Resource Lifecycle Manager (see Object Manager)
 * Roguelike
 * Separated Engine and Interface
 * Short Menus
 * Singleton
 * Sink
 * Smart Pointer
 * Software Above the Level of a Single Device
 * Some Rights Reserved
 * Source
 * Stable Intermediate Forms
 * Standard Panes
 * State (see Objects for States)
 * Strategized Locking
 * Strategy
 * Template Method
 * Template View
 * The Long Tail (see Leveraging the Long Tail)
 * The Perpetual Beta (see Perpetual Beta)
 * Transfer Object (see Data Transfer Object)
 * Transform View
 * Two-Way Adapter
 * Users Add Value (see Harnessing Collective Intelligence)
 * View Handler
 * Visitor
 * Window Per Task
 * Wrapped Class Adapter
 * Wrapper (see Adapter and Decorator)
 * Wrapper Facade