https://github.com/trykno/kno-elixir

This library manages sessions after authenticating with Kno, so you can quickly add passwordless authentication to a Phoenix, or Plug, application.

In this episode of Real World Phoenix Tjaco explores how easy it is to deploy our Phoenix app into the Real World!

https://www.theguild.nl/real-world-phoenix-lets-d4y/

In this episode of ElixirMix, we talk with Sophie DeBenedetto about her experiences with LiveView, her presentations, how to think about it, her work at Flatiron School, teaching others and much more!

Podcast Episode

All I needed to do was be one of the first ten comments on a YouTube video. To do that I wrote a little program that would post a comment whenever the video was published and hope I was faster than anyone else who had the same idea or anyone who was trying to post a comment manually.

https://blog.neillyons.io/I-tried-to-win-1000-dollars-recently/

A Phoenix, LiveView & Tai application for tracking and managing a cryptocurrency fund

https://github.com/fremantle-capital/back_office

Example of putting together a GraphQL subscription using Absinthe library with Guardian auth.

In this episode of ElixirMix, we talk together about managing a project as a monorepo. What are they? When does it make sense? Pros and cons? How does LiveView factor in? Umbrella projects? All this and more!

Podcast Episode

In this episode of Real World Phoenix we’ll find out how easy it is to welcome our new users with an email when they sign up for our app. Let’s send some emails!

https://www.theguild.nl/real-world-phoenix-lets-send-some-emails/

A quick post providing the code and some context for signing Cloudfront resources from Elixir.

https://underjord.io/elixir-signing-for-cloudfront-resources.html

In our latest episode, we talked with Chris Keathley from Bleacher Report and Elixir Outlaws about performance and functional programming.

https://podcast.smartlogic.io/s3e5-keathley

If you know about Phoenix, and you’ve heard about GenServers, but you’re not quite sure how they can work together to create wonderful web applications, this series may just help!

https://elixircasts.io/otp-web-app

We’re back with another post in our Real World Phoenix series! This time we’ll explore user-type based registrations utilising a LiveView form.

https://www.theguild.nl/real-world-phoenix-sign-up-flow-spa-style-with-liveview/

Michal’s article explains how to use JS hooks to handle connection failures and display push notifications in Phoenix LiveView

In this second article in a series on Phoenix LiveView LiveComponents, we create a server-side modal component using LiveComponents, live_redirect, pushState, and JavaScript hooks.

http://blog.pthompson.org/phoenix-liveview-livecomponent-modal

In this episode of ElixirMix, we talk with Miriam Pena about optimizing BEAM applications. We discuss advances in OTP 22, persistent terms, atomics, counters, and when to use them. We learn what she is doing at the Erlang Ecosystem Foundation how we can get involved and much more!

Podcast Episode

https://soundcloud.com/op-ryhmae/5-how-we-created-facial-recognition-payments-at-op

How did our team of experts create Facial Recognition Payments at OP?

Host Kristian Luoma interviews Technology Expert Thomas O’Rourke. Together with his team, Thomas has developed a whole new transaction method at OP: facial recognition payments.

In this episode, Kristian and Thomas talk about what are the facial recognition payments, how the actual transaction process was developed, and what are the advantages of using Elixir. Elixir is a programming language for developing a backend server for facial recognition payments.

Implementation of defs is_forty_two(n: integer) :: boolean do … end syntax to generate both @spec and the respective def clauses in 20 lines.

https://rocket-science.ru/hacking/2019/12/17/dialyzer-specs-2-in-1

https://podcast.smartlogic.io/s3e4-schneck-hunleth-nerves

From the very beginning, this library was heavily inspired by avro_turf simplicity and features. Now it’s time to say – Avrora moves one step closer to the feature set avro_turf provides.

The must-have feature inter-schema references comes to Avrora. Now you can split your huge schema into smaller pieces and glue them together via references.

What is a reference?

Reference is a canonical full name of a schema. Accordingly to Avrora name to location rules if you have schema under io/confluent/Message.avsc its full name (namespace + name) will be io.confluent.Message.

How do references work?

Technically Avro specification doesn’t support inter-schema references, only local-schema references. Because of this limitation, inter-schema references implemented via embedding referenced schema into the schema which contains reference and replacing all other references within this schema with local-references.

How to use references?

For example, you have a Messenger schema which contains references to the Message schema:

priv/schemas/io/confluent/Messenger.avsc

{
  "type": "record",
  "name": "Messenger",
  "namespace": "io.confluent",
  "fields": [
    {
      "name": "inbox",
      "type": {
        "type": "array",
        "items": "io.confluent.Message"
      }
    },
    {
      "name": "archive",
      "type": {
        "type": "array",
        "items": "io.confluent.Message"
      }
    }
  ]
}

priv/schemas/io/confluent/Message.avsc

{
  "type": "record",
  "name": "Message",
  "namespace": "io.confluent",
  "fields": [
    {
      "name": "text",
      "type": "string"
    }
  ]
}

Final compiled schema which will be stored and registered in the Confluent Schema Registry, will looks like this:

{
  "type": "record",
  "name": "Messenger",
  "namespace": "io.confluent",
  "fields": [
    {
      "name": "inbox",
      "type": {
        "type": "array",
        "items": {
          "type": "record",
          "name": "Message",
          "fields": [
            {
              "name": "text",
              "type": "string"
            }
          ]
        }
      }
    },
    {
      "name": "archive",
      "type": {
        "type": "array",
        "items": "Message"
      }
    }
  ]
}

⚠️ In case of avro_turf field archive will keep its canonical items type reference io.confluent.Message instead of local reference Message.

Discover how Broadway can help you create highly concurrent data processing pipelines in your Elixir app.

https://blog.appsignal.com/2019/12/12/how-to-use-broadway-in-your-elixir-application.html