When Chris McCord showed off doing image classification in a single-file Phoenix application, he used a really cool way to run an async Task in a LiveView that is linked to the LiveView process. This means if the user leaves the page, it automatically kills the worker process! This can come in really handy! In this post, we dig in deeper to see how it works and how to choose when to use this approach. https://fly.io/phoenix-files/liveview-async-task/

I’ve been working on an @ElixirLang @ElixirPhoenix video course over the past couple of months. Today, I’m launching its landing page. Check out https://builditwithphoenix.com and let me know what you think! Sign up for updates while you are there. #MyElixirStatus

This post showcases ten of the most noteworthy features released with Livebook 0.8.

https://news.livebook.dev/whats-new-in-livebook-0.8-4gQiEE

Introducing the second part of the “Phoenix LiveView Architecture discussion”:

• Is LiveView a stable ecosystem?
• What is the best approach for GraphQL vs other APIs, like REST, when you have LiveView code?
• What’s the best way to integrate the Ash Framework with Phoenix?
• Is there a way to implement dynamic events with no JS in LiveView?

The following post is about implementing dependency inversion principle on Elixir and using it to achieve useful results, such as circuit breakers.

https://dev.to/dcdourado/dependency-inversion-on-elixir-using-ports-and-adapters-design-pattern-4k3f

In a Phoenix context, we frequently need to create and update resources, using changesets.

Each operation requires a function to get the changeset, and a function to perform the operation. If the operation in question is “create”, the standard approach is to name the changeset function “create_changeset”, but that’s just confusing; am I getting a changeset for the “create” operation, or am I creating a generic changeset?

I prefer the following conventions: https://www.stephenlewis.me/blog/naming-phoenix-context-functions

Episode 133 of Thinking Elixir. We talk with Philip Brown who started Prise in Jan 2022 using Elixir, Axon and Nx to apply machine learning to project management. He shares what he’s accomplished as a one-person dev team and how Elixir enabled him to develop more rapidly. He shares how, with no ML academic training, he learned as he went and developed and trained his own models that classify and prioritize people’s tasks spread across multiple systems! A fun and empowering discussion!

https://podcast.thinkingelixir.com/133

In the second and final part of this two-part series, we’ll dive into Erlang tools you can use for debugging: https://blog.appsignal.com/2023/01/10/debugging-and-tracing-in-erlang.html

Implement an easy way for validating request params in Pheonix with Ecto. No extra tools needed!

https://0x7f.dev/post/validating-pheonix-with-ecto/

An important thing to consider when writing long blog posts or articles is providing a Table of Contents that shows an overview of what is covered. This is important for readers who might want to see if the content is relevant or if they want to jump to the specific section they are interested in. Providing a Table of Contents is also important for SEO and it can help your content perform better in search results.

In this tutorial we’re going to be looking at adding a Table of Contents to a Nimble Publisher blog.

https://www.culttt.com/2023/01/09/table-of-contents-nimble-publisher

Learn how to build forms without writing a single line of HTML by using JSON Schemas. Just define your form as JSON file and BOOM! It’s live✨ If you have many forms that differ just slightly, this one is for you!

https://www.peterullrich.com/build-dynamic-forms-with-json-schemas

https://www.badykov.com/elixir/blockchain/ton/

It allows:

- Generate a seed from a mnemonic
- Generate public and private keys from a seed
- Generate a v4r2 wallet from a public key
- Parse an address
- Create a transaction which can be submitted using TON API

A new version of the library has been released.

Links:

• https://github.com/fuelen/owl
• https://hexdocs.pm/owl
• https://hex.pm/packages/owl
• Topic on ElixirForum

Enhancements

• Highly customizable tables! The biggest change in this release. They work with Owl.Data.t() which allows colorizing even different chars inside a cell, not just a whole cell. Input expects a list of maps, and this structure allows autodetection of columns. There is sorting and filtering of columns, ability to specify max width for entire table and for individual columns. See all options in docs.
• Allow labels for progress bar to be Owl.Data.t()

Paraxial.io can now scan your Elixir project for vulnerabilities, and records a detailed audit trail for your regulatory and compliance needs.

https://paraxial.io/blog/vuln-scan

In programming, we often need fairly distribution of data. Using phash2 we can get the same hash for the same Erlang term regardless of machine architecture and ERTS version. This fast function should always be used for hashing any data and limiting the result to a range of integers.

Check: https://bartoszgorka.com/using-phash2-data-partitioning

In this episode we’ll use Swoosh Gallery to setup previews for our Swoosh mailers.

https://elixircasts.io/swoosh-gallery

In Elixir, unrestricted atom creation is a denial of service vector. Learn how to find and prevent this vulnerability in your Phoenix apps!

https://paraxial.io/blog/atom-dos

Episode 132 of Thinking Elixir. LiveView isn’t always the right answer. Chris Nelson created LiveState to enable embedding custom HTML components in other websites and connect over Phoenix channels to keep UI state on the server! LiveState takes an interesting approach that tries to keep many of the benefits of LiveView but apply it to situations like custom components in static sites hosted by other people. Chris explains how it works and what problems it solves. Check it out!

https://podcast.thinkingelixir.com/132

Wrote some rant on Business Process Driven Development with Finite Automata (and Finitomata library in particular.)

Hello fellow Elixir enthusiasts!

I wanted to share a blog post with you all that I think will be of great interest. The post is called “Principles of Elixir Application Development” and it covers some key principles and best practices for building robust, scalable Elixir applications.

You can find the post here: https://medium.com/@SergeyChechaev/principles-of-elixir-application-development-a4f5018094c5 I hope you enjoy it and find it useful! Let me know what you think in the comments.