I have a couple ideas:

• Functional data structures in elixir (queues, balanced trees, finger trees, zippers), mostly directed to people new to FP
• Integrating phoenix and javascript in a framework agnostic way, basically something that says “phoenix doesn’t care about your js as long as it lands in priv/static”
• Tailoring phx_gen_auth for your use case, with some example using Assent (for oauth2) or TOTP
• Phoenix is not Rails/Phoenix is not magic, for the newcomers that are afraid of using Phoenix thinking it is bloated
• Talking about Phoenix.Pubsub and how it can be used outside of phoenix and how it saves you from using Redis or whatever like you would need in other ecosystems

I propose a guide for (experienced) OOP-devs.

Stuff I think should be covered:

1. use composition instead of inheritance

Don’t do what I did, implement inheritance with GenServers

defmodule Base do
  use GenServer

  def handle_cast(:foo, state), do: ...
  def handle_cast(:bar, state), do: ...
end

defmodule Derived do
  use GenServer

  def handle_cast(:foo, state), do: ...
  def handle_cast(:baz, state), do: ...

  # !!!
  def handle_cast(method, state), do: Base.handle_cast(method, state)
end

2. Understand why immutability is great but comes at a cost - You give up mutability - I often miss this part in FP-introductions, which directly leads to …

3. survival without mutability (understand, ideally implement yourself) map-reduce algorithms. Learn to structure data so that its easy to handle without mutability.

4. learn to love pure functions (testability! understandable code!) which leads to

5. functional patterns - starting with a simple pipe, then with, understand plug and maybe functional core, imperative shell (with proposing this pattern Sasa Juric vastly improved some code of mine here so I love it)

Development tooling, ideally written in compile-time static and strongly typed language like Rust, OCaml, Haskell, Nim, Zig. I am partial to Rust so I’ll give examples with it.

I am talking about series of posts here, not just a single post:

• Long-term: rewrite Elixir compiler in Rust.
• Mid-term: rewrite Elixir LS in Rust.
• Short-/mid-term: efforts like Sourceror (manipulate Elixir code) Sourceror - Utilities to work with Elixir source code by @dorgan (thank you!)
• Short/mid-term: Phoenix/Absinthe tailored tooling that can do stuff like “add a field to this model and everywhere the model is used” – controllers, queries / mutators, views, templates, you name it. I’d like to see more intelligent generation and manipulation of code. (If I become a millionaire tomorrow that’s one of the projects that I’m extremely likely to pick up in my free time!)
• Short-term: basic GenServer wrapper that does away with boilerplate – or just codegen it. Maybe something like @pragdave’s component library?
• Long-term: rigorously tested library bridges to amazing technologies like Sqlite, Redis and DuckDB.