Are you an Elixir developer looking to build ambitious applications? Have you felt the pain of building large applications with a lack of consistency, tooling and extensibility? Join us on a hands-on journey from beginner to expert using the Ash Framework to build a fully fleshed out Elixir application to help ElixirConf attendees get together for dinner.

Starting with the basics, we model our domain with Ash resources. We cover the structure that Ash provides for your application and the basic building blocks that you will use. From there, we can start leveraging the power of Ash to build more complex parts of our applications.

We then dive into the extensions that give Ash its true power, with emphasis on LiveView and GraphQL. To secure our application, we will add AshAuthentication and authorization policies to allow specific users to perform specific actions. Finally, we will add LiveViews to interact with the application, and effortlessly integrate a GraphQL layer with just a few lines of code. No resolvers necessary!

Taking things further, we will build a custom extension, illustrating the full customizability of Ash. We will teach you practical strategies to incrementally adopt Ash in existing applications, so you can start using Ash in your applications right away. Finally, the app will be deployed to fly.io for ElixirConf attendees to use.

At the end of this course, you’ll have a complete, deployed application, as well as the tools and knowledge to build ambitious full stack applications with ease.

Training objectives:

You’ll emerge familiar with a firm grasp on Oban’s fundamentals and best practices for running in production. Along the way you’ll build out the background services of a food delivery service, including tasks such as:

• Installing and configuring Oban for concurrent processing
• Scheduling for the future and running tasks on a periodic basis, e.g. “CRON”
• Preventing duplicate, potentially expensive, operations using unique jobs
• Investigating and handling expected or unexpected errors
• Testing the operation of worker modules and queues
• Preparing for production with good data practices and monitoring

Training prerequisites:

Understanding of basic Elixir concepts and familiarity with SQL

Possible topics and labs include: Custom element 101 Lit Phoenix hooks The event reducer pattern Custom Events Phoenix-custom-event-hook Functional phoenix components (in brief, if needed) Live_elements (library map custom elements to functional components) Finding and leveraging existing custom elements Wrapping js libraries as custom elements Integrating React with LiveState Where are the rough edges and what could be better

Detailed Summary: Break Down - Better LiveView Components

With the emergence of Surface in Phoenix LiveView, components got significantly more complicated, but also more powerful. Learn how to use function components and live components in ways that will supercharge your overall LiveView experience.

With function components, we’ll learn to build better components with slots, use directives like :for and :let, and build cleaner abstractions with better layering. With live components, we’ll learn techniques to extract them and package them for better consumption.

In this course we’ll use message brokers, like Rabbit and Kafka, via Docker to set up data pipelines on your local machine to introduce Broadway’s functionality. We’ll show how it’s easy to leverage these tools within Broadway to create data pipelines capable of processing tens of thousands of messages per second.

We’ll start with a simple producer and consumer, and work through extending it using various producer-consumers. From there we’ll experiment with increasing load at various stages, and how the Erlang VM’s fault tolerance combines with Broadway’s back-pressure to solve load issues. Then, we’ll show how you can instrument your pipeline using telemetry to get valuable insights about how it’s performing. Finally, we’ll introduce the batching capabilities that come baked into Broadway.

By the time you’re finished, you’ll have implemented your own ETL pipeline, understand how to integrate it with an existing ETL pipeline, and see how easy it is to switch message brokers without changing the underlying implementation.

Come learn about the tools and techniques needed to instrument an Elixir application.

This course will be a hands-on dive into the world of instrumenting Elixir applications. We’ll cover the Telemetry library. How it works, drawbacks, and why it’s pervasive in the community. From there we’ll see how we can use Telemetry to generate metrics and trace data for an application. We’ll look at popular libraries and frameworks and how to use their Telemetry events to further enrich our instrumentation. From there, we’ll explore options for visualizing the data we’ve collected.

By the end of the day, you’ll have a solid understanding of the available tools to add an extensible instrumentation framework to any Elixir application.

Topics that will be covered: Why instrumentation is important. How traces, metrics, and logging fit into the observability stack. What is Telemetry and how to use it? What are the different types of instrumentation we can gather for an application. How to use Telemetry.Metrics to collection data from the BEAM. How to generate traces and spans for Phoenix requests, Broadway consumers, and Oban Workers. How to trace across distributed contexts. Different options for visualizing metrics and spans. Where OpenTelemetry fits into the instrumentation stack.

1. Introduce web application security vulnerabilities, and how they occur in Phoenix applications

2. Show vulnerable code in Elixir/Phoenix, and have students run the code locally to understand how it works

3. Demonstrate tools to prevent and fix these vulnerabilities