Go Patterns

A curated collection of idiomatic design & application patterns for Go language.

Creational Patterns:

Pattern	Description
Abstract Factory	Provides an interface for creating families of releated objects
Builder	Builds a complex object using simple objects
Factory Method	Defers instantiation of an object to a specialized function for creating instances
Object Pool	Instantiates and maintains a group of objects instances of the same type
Singleton	Restricts instantiation of a class to one object

Structural Patterns:

Pattern	Description
Adapter	Adapts otherwise incompatible interfaces to work together by adapting one to the other
Bridge	Decouples an interface from its implementation so that the two can vary independently
Composite	Encapsulates and provides access to a number of different objects
Decorator	Adds behavior to an object, statically or dynamically
Facade	Uses one class as an API to a number of others
Flyweight	Reuses existing instances of objects with similar/identical state to minimize resource usage
Model View Controller	Divides an app into three interconnected parts to separate internal representation from presentation to user
Proxy	Provides a surrogate for an object to control it's actions

Behavioral Patterns:

Pattern	Description
Chain of Responsibility	Avoids coupling a sender to receiver by giving more than object a chance to handle the request
Command	Bundles a command and arguments to call later
Mediator	Connects objects and acts as a proxy
Memento	Generate an opaque token that can be used to go back to a previous state
Observer	Provide a callback for notification of events/changes to data
Registry	Keep track of all subclasses of a given class
State	Encapsulates varying behavior for the same object based on its internal state
Strategy	Enables an algorithm's behavior to be selected at runtime
Template	Defines a skeleton class which defers some methods to subclasses
Visitor	Separates an algorithm from an object on which it operates

Synchronization Patterns:

Pattern	Description
Condition Variable	Provides a mechanism for threads to temporarily give up access in order to wait for some condition
Lock/Mutex	Enforces mutual exclusion limit on a resource to gain exclusive access
Monitor	Combination of mutex and condition variable patterns
Read-Write Lock	Allows parallel read access, but only exclusive access on write operations to a resource
Semaphore	Allows controlling access to a common resource

Concurrency Patterns:

Pattern	Description
N-Barrier	Prevents a process from proceeding until all N processes reach to the barrier
Bounded Parallelism	Completes large number of indenpendent tasks with resource limits
Broadcast	Transfers a message to all recipients simultaneously
Coroutines	Subroutines that allow suspending and resuming execution at certain locations
Generators	Yields a sequence of values one at a time
Reactor	Demultiplexes service requests delivered concurrently to a service handler and dispatches them syncronously to the associated request handlers
Parallelism	Completes large number of indenpendent tasks
Producer Consumer	Separates tasks from task executions
Scheduler	Orchestrates steps to be performed as part of a task

Messaging Patterns:

Pattern	Description
Fan-In	Funnels tasks to a work sink (e.g. server)
Fan-Out	Distributes tasks amongs workers (e.g. producer)
Futures & Promises	Acts as a place-holder of a result that is initally unknown for synchronization purposes
Publish/Subscribe	Passes information to a collection of recipients who subscribed to a topic
Push & Pull	Distributes messages to multiple workers, arranged in a pipeline

Stability Patterns:

Pattern	Description
Bulkheads	Enforces a principle of failure containment (i.e. prevents cascading failures)
Circuit-Breaker	Stops the flow of the requests when requests are likely to fail
Deadline	Allows clients to stop waiting for a response once the probability of response becomes low (e.g. after waiting 10 seconds for a page refresh)
Fail-Fast	Checks the availability of required resources at the start of a request and fails if the requirements are not satisfied
Handshaking	Asks a component if it can take any more load, if it can't the request is declined
Steady-State	For every service that accumulates a resource, some other service must recycle that resource

Profiling Patterns:

Pattern	Description
Timing Functions	Wraps a function and logs the execution

Idioms:

Pattern	Description
Functional Options	Allows creating clean APIs with sane defaults and idiomatic overrides

Anti-Patterns:

Pattern	Description
Cascading Failures	A failure in a system of interconnected parts in which the failure of a part causes a domino effect

Other Patterns:

Pattern	Description

License

This work is licensed under a Creative Commons Attribution 4.0 International License.