Elixir design and refactoring books

Hello, welcome to the forum.

As I also comes from Ruby/Rails I had the same questions when I started

But functional programming is not OOP, no object, no classes, and known design patterns doesn’t apply.

It’s just different.

But You might soon see that functional proramming brings You a lot of safety (no mutation) and a different mindset.

Now, when I write Ruby, I try to apply functional paradigm principles

Here are videos You might enjoy (as I did…)

There is also this recent topic, where some books are recommended…

Thank you!

Thank you so very much!

Further to what Koko has said, if you like Dave’s talk you might also be interested in his course: Elixir for Programmers (PragDave) (have a look at the comments/reviews in the thread). It’s not really about refactoring and such, but you do get a look into how Dave goes about architecting software (at least at the time he recorded the course)

I hope You enjoyed presentations, as they were kind of mind blowing for me.

Here is my 2 cents advises…

• pattern matching is THE thing
• |> creates beautiful and descriptive transformation pipeline
• The Enum module is a must
• Lists are not arrays
• Polymorphism can be achieved via protocols

And many more that I forget, all of these You can learn on https://elixir-lang.org

The last advise, for Rails developpers, Ecto is not AR, but You can do equal job… (same same, but different) Here is a post about a free resource on Ecto.

FP is just a mean to achieve greater goal, Here is a post from Erlang creator, about Erlang.

Once You reach the syntax barrier, You will see it allows You to have a complete isolation…

In complete isolation, You can have millions of processes working together. Coupled with a faillback mecanism (Supervisor) You can build softwares that are fault tolerant.

Apart from Functional patterns, there are Design Patterns for processes, it’s called OTP.

Thank you. I’ll take a closer look at OTP.

Regarding patterns/refactoring, in OOP there’s the idea of focused objects/little things. This is represented in objects like Services, Policies, Queries, Presenters, Decorators, etc… Are these patterns relevant in the elixir world as well? Doing some Googling doesn’t reveal much.

The beginner examples in both ruby and elixir show much of the examples either in irb/iex or in a Rails/Phoenix controller. This does not scale. In the Rails world I just look up some common patterns and I get a plethora of results. This does not happen with Elixir so I think I don’t know the patterns (and possibly they aren’t even called patterns).

In FP it’s the same, You just call those things functions. And You compose those functions to make bigger things.

Presenters, Decorators are from OOP, there is no need because functions are highly composables.

Services, Policies, Queries are probably bounded in a module.

Please note that in Erlang/Elixir we have MFA, You will see this a lot.

It means Module, Function, Arguments

I took the same way You did, just a bit earlier. As You, I read all the Ruby books You mentionned…

I can remember the depressing feeling of not finding the equivalent of what I learned, all those things Sandi Metz was praising… is it just replaced by MFA?

In Ruby, often You find small objects, used for one function only, that could be parser.parse(), presenter.present()… anything like this. In FP You pass a function.

High order functions are so powerful (something Ruby touch with Lambda) that You don’t need Template, or Strategy patterns.

In Erlang/Elixir, we have some famous Erlangelist… this is one of my favourite talk to understand why this difference is so appealing.

He is the author of Elixir in action, and runs https://www.theerlangelist.com/

Have you read Elixir in Action? Much of the book builds on the same example application of a todo system, with increasing complexity (adding a caching layer, persistency, fault-tolerancy, a web interface, and distribution). When I started out with Elixir I found the way this example evolved over the course of the book a really good guideline for how to evolve a real-world Elixir application.

Now that I’ve read (most of) it, it’s worth noting that the Ecto book also has a chapter on application design (covers pure/impure, Contexts, Umbrellas) while of course Programming Phoenix also covers application design in terms of Contexts - I highly recommend both books

Other books not mentioned here that cover app design (that I haven’t read yet) are Functional Web Development with Elixir, OTP, and Phoenix (Pragprog) and Designing Elixir Systems with OTP (Pragprog) and The Elixir Toy Robot (self-published) may also be worth a look