“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
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
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:
Applying DDD, similar to your excellent talk at ElixirConf!
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.
I would love to see something covering Elixir, Ecto, Ash, Phoenix and LiveView that shows how to use them all together. Not the basics (they are all aready covered several times), but some advanced topics that matter in most typical web apps. A collection of recipes. All starting with the tests.
Thanks so much for all the responses! It seems like there’s a desire for more advanced topics (which makes sense), and there’s a feeling that beginner topics are covered.
I like the idea of an OTP course. It’s something I’m mulling a little bit more. I’m surprised that Refactoring also scored high on the list (though happy too. Refactoring is near and dear to my heart).
Some of the comments elaborated on the idea of OTP. For example:
Anybody else have thoughts on OTP? Are there resources out there that you like on OTP? Or any you don’t like because there’s something missing?
That’s interesting. Unfortunately, I don’t think that’s in my wheelhouse. I wonder if too few people have that issue or by the time you have that issue, you solve it in a bespoke way without sharing blog posts, etc.
That is a good list! I completely agree that advanced LiveView uses need some resources. I wonder if a good course could be built around that. It’s always hard to design a situation in a course that represents the real-world well. I’ll have to think about this a bit more. But thanks for the info!
Have you found resources (blog posts, etc.) for some of those issues in the list?Anything you like/dislike?
At the moment I’d be interested in something a bit more intermediate to advanced regarding Phoenix and OTP
What would an intermediate/advanced course on OTP teach you?
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.
Is that what you mean? OTP in relation to data processing pipelines? One can build on the other, but I think those can be two different courses.
Elixir and Rust are always an interesting combination. I’ve worked with Rustler before but only in a very limited capacity (and it was a while ago). I think there could be something there for a course, though I’m not sure how popular it would be. I wonder if there’s a limited number of people who need/want to understand, even if many benefit from the libraries using it.