Exploring design patterns in Elixir

I wanted to reach out to the community and see who is using design patterns and what are the ones that are relevant to FP and Elixir, as well as an overall discussion on the validity and applicability of patterns.

Now, let me start with a couple of statements that might be valuable (I might be wrong; feel free to comment):

  • Design patterns are not recipes, meaning their value is not to be implemented to the letter
  • Most Creational and Structural patterns have little to no use in the functional programming world.
  • For FP and Elixir, the most valuable and applicable patterns are going to be architectural and behavioral

Within that realm, there are a few patterns that I have identified that seem useful:

  • Circuit Breaker for managing calls to external services
  • Event Sourcing for situations that require a highly reliable audit log; CQRS is also relevant

Curious what else is being used and tried for example Sagas? Proxy? Strategy? Maybe some unique to Functional languages?


There is the Token pattern that is very common in many Elixir libraries. https://rrrene.org/2018/05/14/flow-elixir-designing-apis/
I had a talk on it https://www.youtube.com/watch?v=arYOSYrjC8s but I didn’t know the name yet :smiley:


Nice, thanks for sharing this.

I have been translating this book…

…from Node to Elixir

I really like DDD and Event sourcing, I feel Elixir is a good fit for this kind of reactive programming.

It’s not a pattern, but I like to define domain events first.


A good place to start is the OTP Design Principles User’s Guide which describes the supervision and communication patterns used by the OTP + BEAM infrastructure.

One technique that’s seems a lot more common in languages with pattern matching is defunctionalization (and another presentation) - note that both of these require a little Haskell to fully understand the examples, but it looks kinda like Erlang.


I don’t disagree as being a good place to start, and for example, the documentation on gen_statem is pretty good, but I have the feeling this is too specific to elixir/erlang and too low level.

What I’m trying to collect is a bit higher level patterns and their applicability, pros, cons, and general notes on each of those patterns. For example, the Circuit breaker pattern has clear applicability when having to rely on external services or even local services but built in a different language which could common cases on certain implementations.

Event Sourcing/CQRS has value if high traceability / detailed audit logs are required like for example an Order Management System or Inventory tracking.

State pattern via GenStateMachine might highly applicable for things like booking engines or shopping cart.

Other patterns that are more microservice specific like Sagas might be also applicable for larger systems.

I have seen the implementation of singletons in elixir but I’m undecided if those make sense.

This is really interesting, and I hadn’t heard about it before. Thank you for the links.

There’s a lot of patterns described in the OTP design principles doc, but they aren’t as obvious as in OOP:

  • the OTP model is an implementation of the Actor pattern, using message-passing processes to emulate mutable state

  • I don’t know of a name for it, but the “tree of supervisors that restart children” patten is really important for producing a reliable system

  • the minimum-weight implementation of the Strategy pattern in BEAM languages is the module / function / args tuple (MFA tuple) that’s used in lots of places

  • gen_statem does implement a version of the State pattern, but the quantum of change is the function (changing the machine’s state changes which handlers are called) and not the module

Also take a look at things in Elixir like DynamicSupervisor and Registry used together.

1 Like

Thank you so much this was really good