What topic do you think needs a course in the Elixir community?

Would love more info on deploying multi-node set ups running different OTP Applications that communicate with each other. Most (all?) of the stuff out there is about clustering a single application.

My “Other” List:

• “High-Performance-Code” (however we call it): like doing Stream instead of Enum chains, when to leverage ETS instead of plain/big data structures, moving some code to compile time instead of runtime, when to MapSet instead of List, … basically what to do if my code becomes “slow” in incremental ways (extreme end: Rustler :D) and what tradeoffs do exist to make stuff fast

• all the OTP primitives and when to use what and how. iE: when to use Agent over GenServer or ETS? Why? How to supervise it for different use-cases? Data bottlenecks (iE: Genserver state VS ETS with concurrent read when load increases)

• Scripting with Livebook: I think its severe underrepresentated still. Nearly as lightweight as a script file, Nearly as powerful as a full phx app, but immediately available when needed without any fuzz. iE: are there some bash scripts or cleanup tasks that have to be done from time to time? make it interactive in a notebook with some info for everyone

I would love that too, however how all these kind of guides end is by employing a lot of infrastructure tools, configs and other things that make it very hard to follow and unnecessary complex.

It would be great to see a guide that at least illustrates the thinking process and things to look out for, without going much into specific implementation details.

That would be great, I’d be extremely happy with that. I’d also be happy with a convoluted setup guide if that’s what actually needed but now that you mention it, it’s the gotchas I’m most interested in and being pointed in the right direction. I’ve heard lots of conflicting information.

+1 for documentation around various deployment strategies

I think Elixir needs more example projects. One thing I enjoyed about the churn of the Javascript community is the constant releasing of “how to do the thing in Javascript” tutorials on the web. The examples range from really small one off tasks to building entire applications from scratch. This is especially true on YouTube and even TikTok where there are hundreds of code along videos in every language. The Elixir docs are excellent, best I’ve ever used, but docs are like dictionaries, useful if you know what you’re looking for. Examples and code alongs are great because they provide jumping off points for what to later search in documentation

For me, I’d love an intermediate/advanced-level course on LiveView patterns and best practices.

The docs are pretty solid, but they mostly cover the “what” and less so the “how” or “why”. Fly’s Phoenix Files and other blogs are an excellent resource, which help fill in a lot of the gaps. But ultimately, I think there’s still a huge need for guides/books/courses on things like:

• async tasks in a LV (until it got added in officially into core in 0.20)
• situations where it’s useful to keep state on the client and best ways to pass that to the server on load; manually restoring LV state using client-side persistence
• complex, multi-step forms and different ways to approach those; how to keep and maintain partial state for each step in a multi-step wizard, sections of the form that are shown/hidden or trigger other actions depending on other selections in the form, etc.
• more involved authentication/authorization patterns
• passing user agent/other client-side info on load
• sessions/cookies/LocalStorage and how to persist different state for different situations from a LV
• complex interactions between client-side JS, hooks, and the server - best ways to coordinate multi-step transactions/operations between both, incl. how to pass data from the server to JS, how to trigger JS from the server, etc.; think, for example, a Stripe Elements purchase from a checkout cart
• how to make decisions between using LiveViews/LiveComponents/etc and specific situations for which is appropriate, how many LVs to have per page, when to make LVs sticky
• animations and transitions and how to make them work well with LV navigations
• design patterns to avoid the dreaded “loss of state” on server restart/redeploy for non-form elements
• optimistic client-side changes before receiving acknowledgment from the server
• (a big sore spot:) communication between LVs, live components, functional components and how to design those well without ending up with spaghetti and hard-to-follow dependencies

There’s a substantial amount of content on beginner/intermediate LV work, but once you start to design a large-scale production app, for a lot of the above you end up completely on your own, so I think this could be a really useful resource.

I think there are a lot of great beginner resources on Phoenix, LiveView, Ecto, and Elixir. At the moment I’d be interested in something a bit more intermediate to advanced regarding Phoenix and OTP. In particular:

1. Applying DDD, similar to your excellent talk at ElixirConf!
2. Background jobs, long-running multi-step workflows similar to https://temporal.io/. Oban looks like an excellent solution and one I’ll probably try in the future, but I would like to learn more about the Elixir/OTP primitives that would enable building this kind of thing.

Just saw your presentation on DDD and absolutely loved it. Gave me a lot of inspiration to integrate those ideas into my next elixir app. A high quality learning resource on that subject applied to our beloved tech stack would be valuable.

I think that a course on bridging Elixir and Rust via Rustler would have been very useful. As I understand, many of the latest serious (in my opinion) projects involving even Jose himself (e.g. explorer, tokeniser) involve the combination of Elixir and Rust. Even nx combines Elixir and C/C++.

I believe that It becomes evident in the community that we will benefit from such language combinations.

However, I am sure that this is not an easy task as also elaborated by Christopher Grainger.

I am not sure whether you have the background for such a course, but I would have been definitely interested.

I would love to see a course about the Ash Framework. I am following it since its introduction at ElixirConf 2020, but I have never had the opportunity to try and learn it.