Your topic ideas for bloggers

Inspired by what @tommica wrote:

I thought it could be nice to have a thread that might serve as inspiration for bloggers :blush: so, if there’s a blog post you’d love to see please say here - you never know, someone with the relevant experience on the topic might spot your post and write one :003:


For anyone interested, we have a similar thread for book authors, and for anyone interested in blogging, don’t forget you can get more exposure and help your SEO by posting via Devtalk (see this thread for details).

4 Likes

I’ll start by adding that I’d love to see more blog posts about LiveView (and Surface) :sunglasses:

1 Like

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
3 Likes

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
  1. 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 …

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

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

  4. 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)

2 Likes

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 @doorgan (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.
2 Likes