Exploring design patterns in Elixir

There is the Token pattern that is very common in many Elixir libraries. Designing Token APIs for Architecting Flow in Elixir · rrrene
I had a talk on it https://www.youtube.com/watch?v=arYOSYrjC8s but I didn’t know the name yet

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.

Thank you so much this was really good