WebAssembly runs in the browser, on the server/edge, and on your phone. Orb lets you write WebAssembly in Elixir.

This talk shows how to create your own WebAssembly modules and integrate them with LiveView. It covers why Elixir is a natural fit for authoring WebAssembly with its macros, composable modules, and Hex package manager.

Code smells are indicators of potential design problems in software code. They can impact maintainability, readability, and overall code quality.

While code smells have been extensively studied in object-oriented programming languages, their applicability and identification in functional programming languages like Elixir remain a fascinating area of exploration.

In this talk, we will dive into the world of Elixir and uncover code smells that may arise in its codebase. We will explore the traditional code smells (including the newly cataloged Elixir-specific code smells), discuss their impact on Elixir applications, and provide practical insights into refactoring techniques to eliminate them.

The productivity boost we get from LiveView as elixir devs is pretty spectacular. Sometimes we need dynamic, in-browser behavior beyond what LiveView gives us, which means we need Javascript. The challenge is integrating that javascript in a way that lets us both create the rich user experience we want while maintaining the simplicity and developer experience that LiveView provides.

In this session, we’ll cover two specific scenarios that require you to reach for javascript and provide solutions that give us a great experience as Elixir developers. We’ll talk about integrating Javascript in a LiveView application, and we’ll talk about how to maintain LiveView levels of productivity when you aren’t serving your application from Phoenix. We’ll explore why and how Custom HTML Elements give us the ideal abstraction for bridging to javascript in both scenarios. We’ll look at two libraries, LiveElements and LiveState, that give us what we need in each case. And, of course, we’ll walk through code, for example, applications. We’re going to cram a lot into a short time, so keep your seatbelts fastened and your arms and legs inside the vehicle at all times ;)

This talk is about prototyping and deploying AI agents with Elixir.

AI agents are all the rage right now. What are AI agents? Imagine a team of specialized AI models helping us with tasks throughout the day. One agent for handling email, one for booking appointments, one for scheduling your meetings, etc. Most people reach for Python to build these tools, but the distributed, functional, and scalable nature of the BEAM + Elixir Agents (funnily enough) is the ideal tool for building these kinds of agents.

As an engineer at Replicate (run open source machine learning models at scale), I’ve had a front-row seat to what people are building. I’ve created a bunch of AI applications, but I’ve also written an Elixir library (hex.pm/packages/replicate), and an open-source social network with Phoenix LiveView (shlinkedin.com). I’m very excited about recent AI developments, and I’d love to convince you why Elixir is well-positioned for an AI agent-driven future.

Every LiveView is a process, and this has important implications that aren’t always appreciated. In this talk, I expand upon my blog post (https://fly.io/phoenix-files/a-liveview-is-a-process/) and dig deeper into what we mean by Process by peaking under the covers and show how we might spy on an active LiveView!

My recent side project came from a common need for developers to have access to auditable production databases. In my talk, I will walk through how I utilized Elixir, Ecto, and LiveView to build a database GUI. I will also discuss how gen_tcp can be used to create a Postgres proxy, including how binaries work with Elixir in the context of the Postgres message protocol.

I’ve struggled to understand the internals of stochastic gradient descent or SGD. In this talk, we will explore SGD via an interactive Livebook example. SGD is the building block of neural networks. To understand how a neural network learns, we need to understand SGD.

The Micrograd framework, by Andrej Karparthy, helped build my intuition about SGD. From the README, “…is a small and lightweight automatic differentiation library written in Python. It provides a simple implementation of gradient-based optimization algorithms, including stochastic gradient descent. It allows users to define and train simple computational graphs, compute gradients, and optimize parameters using SGD.” We will port this framework to Elixir.

We will visualize how SGD works interactively from Livebook graphs by applying our Elixir-fied Micrograd framework. We will explore a process known as backpropagation. How does a derivative work? What is a derivative measuring, and what is it telling us? How do the input values to a function respond by changing the value of “h” in the derivative? Then, we will complete the SGD loop with a forward pass which updates a loss function–training our network.

By the end of the talk, we will use what we have learned to solve for a linear function with SGD. You will come away with a fundamental understanding of how SGD works to optimize a loss function and train a neural network.

I present (all?) 11 ways to store state in the BEAM VM.

Each example is designed to either cultivate understanding or provoke thought and help programmers of all levels avoid potential foot guns because, as we all know, shared state in distributed and concurrent systems is dangerous!

It’s time to break the LCD hegemony! Today we find ourselves surrounded by a multitude of brightly glowing LCD (or LCD-like) screens. It’s time to try e-ink. I still remember the blog post that hooked me on e-ink as a technology. It showcased high-quality microscopic images, placing an LCD screen, an e-ink display, and printed paper side by side. The unexpected extent of the similarities between the e-ink display and paper captured my attention and hooked me on the potential of e-ink displays.

In this talk, I will take you through the collaborative multi-part journey to support Pimoroni 7-color e-ink displays in Scenic and Elixir. I will delve into the special considerations required when working with e-ink screens and share my personal use case, highlighting how my e-ink screen has become a crucial component of my home office automation setup.

MLOps (machine learning operations) and, more recently LLMOps (large language model operations) are trendy terms for the paradigms and practices of deploying machine learning models. The MLOps ecosystem is a forest of tools and so-called best practices.

Entire companies are built to support the machine learning lifecycle. However, with Elixir, we can greatly simplify this process without much effort. This talk will show you how to do MLOps in Elixir.

When you’re tasked with implementing a well-understood but complex feature, conventional wisdom might say to reach for a library. But what do you do when nothing out there fits your particular needs? You build your own solution! Two GridPoint software engineers teamed up to do just that when challenged to create a set of interactive, customer-facing data visualizations.

In this talk, you will get the inside scoop on their process of solving the problem, including:

1. Evaluating existing Elixir charting libraries and coming to the decision to build their own charts
2. Pioneering a method to hand roll charts using SVGs
3. Building an interactive chart as a Phoenix component
4. Ensuring the solution relied on LiveView with no custom JavaScript

You will learn the basics of Scalable Vector Graphics (SVG), building a chart using only two SVG elements, styling the chart via Tailwind classes, using that chart as a Phoenix component with the ability to add a click event to any element, and appending to the chart with Phoenix streams. Join us on a trip to SVG Island!

In a world where learning styles vary greatly, the traditional one-size-fits-all approach in many educational institutions falls short of cultivating the next generation of exceptional developers. However, in our small but thriving niche community, we understand that taking the time to provide juniors with tailored attention can yield remarkable results. By investing in their development and providing specific guidance, we have the potential to transform the entire development space with a wave of highly skilled engineers.

Join this session as I explore the power of individualized learning in nurturing high-quality engineers. I’ll share my firsthand experience as a Junior Elixir developer and my journey of learning the language at a small startup that provided me with the ideal environment to grow and learn.

Decision Trees are an extremely popular class of supervised Machine Learning techniques that are beginner-friendly due to their intuitive and digestible design. However, they have also stood the test of time as one of the preeminent techniques for learning structured tabular data. This type of data, common among spreadsheets and relational databases, is still the gold standard used in business and enterprise environments and has now made its way to Elixir.

This talk introduces EXGBoost + Mockingjay, a Gradient Boosted Decision Tree library paired with a compilation library that converts trained Decision Trees to Nx tensor operations. We will discuss how both libraries work and work through some examples of using the libraries. Next, we will look at using trained Decision Trees in a scalable production environment using Nx’s Serving capability and a Phoenix web app. Finally, we will look at the future of Machine Learning in Elixir and how bringing this next class of machine learning techniques to the language benefits it.

Many applications have need for users to define their templates (multi-tenant eCommerce, CMSs, etc.). Phoenix has a reputation for lightning quick template rendering, but performance is quite lacking if you ever try to render a template not defined at compile time. At Estée Lauder, we found simple product grids take 400-500ms to render as we had to repeatedly render a brand-specific template to display the products.

Using Elixir’s ability to metaprogram, we developed a way to get compiled-template-level performance for arbitrary dynamic templates. Benchee showed improvements of over 300x when using our new method.

# Comparison:
# new black magic     8.33 M
# old way             0.0249 M - 334.37x slower +40.04 μs

In this talk, we’ll review the basics of meta-programming and hopefully de-mystify it and make it more approachable. Then we’ll explore how we used these techniques to deliver blazing fast performance for our customers.

We know that Elixir is a great choice for many software projects. However, despite its clear advantages, it is sometimes difficult to convince others. One factor we hear is the perceived size of its ecosystem: the existence of a library for a particular service can affect the appearance of maturity. The problem is, there are many services, and maintaining libraries takes time.

OpenAPI descriptions for these services promise to make the creation of client code easier, but so far they haven’t delivered. Client libraries tend to be a great developer experience through hand-crafted code, or easy to maintain thanks to code generation, but not both. This doesn’t have to be the case.

In this talk, we explore a new OpenAPI client code generator that combines the ergonomics of hand-crafted libraries with the maintainability of generated code. By walking through the process of creating a new library, we introduce a new way of thinking about maintenance and call upon the community to fill the gaps in our ecosystem.

LiveView was the entry point as we needed a real-time dashboard monitoring our point of sales. We extended all the Core through Phoenix, including WebSockets for IoT devices. Finally, we developed our firmware with Nerves, and we are exploring evision for AI inference. We want to share our history and show some examples of security, simplicity, and improvements in our tech based on the Elixir ecosystem.

Its functional paradigm, concurrency, and fault tolerance are frequently cited reasons for choosing Elixir. If it’s going to take over the world, there is a more fundamental rationale that newcomers will value as they make adoption decisions.

In this talk, I will review the many reasons Elixir is my first choice for most - if not all - programming challenges I encounter. Then, I’ll dig into one of the lesser talked about features of Elixir that allows it to tackle problems that were previously understood to be a bad fit for the language and the BEAM.

Ecto’s query DSL is very nice and powerful, even without fragment. However, many extremely interesting corners of SQL query syntax are out of reach to the DSL. That’s where fragment comes in.

I know, of course, that Ecto also supports SQLite and MySQL, but I have never used them professionally and won’t touch on them here. All of the Ecto content should generalize, but I will show some advanced Postgres query features which won’t.

In this talk, I will show:

• The basics of how a DSL query turns into SQL.
• How fluent and easy it is to use fragment when the DSL syntax isn’t available.
• How there are powerful expansion-time safety features that make it much harder to misuse than you would think
• How to combine fragment with PG’s JSON support and aggregates to write some cool and performant queries that unwrap deeply nested joins into flat queries returning nested JSON (which Ecto conveniently turns right into Elixir nested maps)
• How to safely wrap fragment in another macro to reduce duplication without making a SQL-injection vulnerability

Content Management Systems are an established and well know solution for an old problem on the web: allowing content creators to build and publish webpages. So why another product? And the answer is Phoenix LiveView which brings new perspectives and elements that enable innovations in this area.

Beacon is powering 700+ dynamic pages for the new DockYard website delivering high-performance rendering and template reloading at runtime to avoid redeployments and achieve high SEO scores.

This talk will discuss how it works, including HEEx template compilation and rendering, module reloading at runtime, embedding Phoenix LiveView, extensibility and configuration, cluster communication, and more.

https://github.com/BeaconCMS/beacon

In this talk, you will discover what is unique about managing and working with Elixir teams and how to foster effective communication on your teams. This talk is for Engineering Managers and Individual Contributors alike, as everyone writes Elixir with others and must have an effective way to communicate.

We’ll touch on subjects like how to deal with differences in opinion on strategy, how to balance working with the latest, coolest technologies while balancing against productivity, and how to deliver crucial feedback to Engineers. We will also dive into Elixir engineers’ unique journey when working in such a young language, including techniques managers can take to help their teams during adoption. Learn about the makeup of Elixir teams from an Engineering Manager’s perspective.

Key Points

• Leveraging your community: EMs of Elixir Roundtable
• Giving Feedback: Situational-Behavior-Impact
• Effective Communication: How to understand your team’s communication style

This talk covers the sharp corners and the lessons my team learned when working with Ecto.Repo.put_dynamic_repo/1. We received a requirement in which we needed to store data for specific customers in a separate database, with their own unique encryption keys, to satisfy contract requirements.

This talk outlines our approach. It will cover the initial requirements, how we addressed the requirements, the infrastructure changes that were required, and changes to how we developed our code that were also required. Sharp edges that we ran into with our implementation and how we adapted will also be covered.

Delve into the powerful combination of Elixir and LiveView as we explore LiveViewNative application development for Android, iOS, and beyond.

One of the greatest strengths of Elixir is the easy and accessible unit testing. Obviously, you’re testing your code–but are you thoroughly testing it? Are you testing the right things? Is there more you could be testing?

Enter black box testing techniques. Equivalence partitioning. Boundary value analysis. Decision tables. Combinatorial testing. State transition testing. While black box is done without considering the code, these are the foundational testing techniques and can be applied to any type of testing. You’ll learn about each type of testing and how to apply it to different situations to understand the features better and engage in deeper testing.

Join Jenny Bramble as she walks through these five foundational techniques and how we can apply them to our unit tests. You’ll come away from the talk with a stronger understanding of testing and how to go beyond ‘Does it work’ into ‘Does it work well?’

The team at theScore has grown by leaps and bounds over the past two years thanks to technologies including Elixir and Kafka. Kafka has enabled us to rapidly and successfully scale our backend services and teams.

It’s not all rainbows and unicorns - all technology choices come with their own tradeoffs and downsides. We’ll explore horror stories as well as wins, techniques enabling autonomy, and tips-and-tricks for performance.

Attendees can expect to learn how Kafka can help enable autonomous, decoupled teams. We’ll cover the social and organizational implications as well as technical details of using Kafka in an organization that makes heavy use of Elixir.

We started looking at LiveView Native development after the announcement at last year’s ElixirConf but did not have a client use case yet. Earlier this year, a use case arose, and we started with the iOS tutorial again. Using that as a guideline, we developed our real-time financial analysis alerting application to replace our previous technology of SMS messaging to improve our deliverability.

This talk will cover our development journey in using LiveView Native, including setting up the tutorial to run, adapting the tutorial for our needs, the level of iOS experience we needed to work with an LVN application, and our feel for the stability of the codebase to do app development. We want to show what it takes to develop an LVN application coming from the perspective of a non-iOS elixir developer. We also want to show several apps we are working on to explore the limits of LVN.

Deploying an Elixir cluster that keeps stateful connections with the clients and manages distributed state is usually a much more challenging task than in the case of stateless services.

At Whatnot, we learned this the hard way.

With every deployment, there was a big risk of data inconsistencies that were very disruptive to auctions in progress. Which, of course, led to the buyers’ dissatisfaction and the sellers’ financial losses. Consequently, we limited deployments to off-peak hours.

In this talk, we will present a case study of how we drastically increased the reliability of our Elixir service.

We did this by automatically verifying the system against most of the problems we’ve been experiencing in various conditions. We tested the deployments and locally simulated cases where nodes went up and down randomly. Having included these new tests in our CI pipeline, we gained enough confidence to deploy to production after every single commit at any time of the day.

Developers are spoiled by the choice and quality of telemetry & observability options in the OSS and BEAM communities.

With the :telemetry library being a de-facto standard used across almost every library conceivable and OpenTelemetry being a widely used, common standard, it brings a lot to the table.

Unfortunately, at Vetspire, we’ve found that much of the work needed to roll out good metrics/traces/telemetry is manual, repetitive, and potentially error-prone.

Over the last few months, we’ve been leveraging our experience rolling out telemetry, our learnings & failures, and some cool Elixir/Erlang features to automate away the “pain” of bootstrapping an easy, ergonomic Telemetry solution for your production apps!

As Elixir adoption increases, companies have questions about the security of software developed in Elixir. Is it safe? Is Elixir more or less secure than other languages?

This talk will show why Elixir is an excellent choice for developing secure software. On the technical side, this talk will cover how Elixir developers can secure their applications. More people should be aware of several open-source tools (Sobelow, MixAudit, Exploit Guard) and learning resources (Potion Shop, ESCT in Livebook).

Executives and engineers alike should be aware of the security benefits of Elixir, and concrete examples will be given for both audiences.

Broadway makes processing streams of data easy. A producer pulls work from a queue like SQS, fans the work out to workers, and handles lifecycle events like acknowledgements.

But what about situations where the work to be done can’t be modeled or built on top of a message queue?

At Sequin, we needed a way to process high volumes of requests to crawl APIs. We wanted to model after the producer/consumer architecture of Broadway. But in operations like crawling, work is created iteratively as work is completed—unlike a classic, queue-centric data pipeline.

In this talk, we’ll discuss Broadway, building custom producers, how to model concurrency in your pipelines, and tips to keep your pipeline fast.

Pion is currently the most popular, open-source WebRTC implementation written in Go. It’s a base of the awesome Livekit media server, known for its usage in Spotify.

In the era of rewriting everything in Rust, I rewrote Pion in Elixir.

In this talk, I will present the results of my recent work focusing on three basic protocols used in WebRTC and VoIP, namely STUN, TURN, and ICE. The main aspects I am going to cover are the theoretical introduction into the domain, architecture of the ICE library and TURN server, performance comparison with Pion (Go) and coTURN (C), challenges in implementing RFC documents in a functional language, and a couple of examples showing the API of my libraries and their integration with Pion.

Ash Framework has matured, and the original vision, “Model Your Domain, Derive the Rest,” is being realized. Ash users have been shipping production applications for over two years now. With a solid foundation in place, the ecosystem is expanding rapidly.

• AshAuthentication comes with OAuth2 and magic link strategies out of the box.
• AshOban schedules and triggers actions in your application with a simple DSL.
• AshStateMachine models complex, persistent workflows directly in your resources.
• Bulk actions make data migrations, imports, and ETL systems delightfully simple to build.

These features integrate in powerful ways. The whole is greater than the sum of the parts.

This talk discusses the design principles behind Ash Framework, what it enables, where we’ve come since 2.0, and where we are headed. We also have some big news that we are very excited to share!

To meet and exceed GDPR, we moved our EU customers to a new instance of our legacy Rails login service in the EU. But before we could do this, we needed a way to route traffic. We built a new Elixir service to sit in front of our legacy Rails login service to route traffic to the correct region. This router has an instance in the EU and the US so that EU traffic never touches the US.

Elixir is uniquely suited for this purpose for several reasons.

1. All login traffic passes through this router, so it should add minimal latency ✅.
2. IT is a proxy, so it needs to hold on to each connection for a request to a large cluster of Rails servers for as long as the Rails server takes to respond, which ends up being a lot of requests if the Rails server slows down for any reason ✅
3. The legacy service has over 200 routes. Different requests have different properties that can tell us which region the request should go to. Having a single Plug.Conn where we could place information as we figure it out and then pass responsibility to the next module in the pipeline helped us break a very complex problem into something solvable ✅

Mistakes.

1. I spent a lot of time thinking about optimizing routing speed. Trying not to pattern match all possible routes in a single request. Pattern matching 10s or even 100s of patterns is so fast that finding a quicker way was a waste of time.
2. We tried to flex our Elixir muscles by showing how few resources we could run in, which caused an outage about five months after launch.
3. We underestimated the project, it turns out a 6-year-old Rails app might be doing a lot of things. If you want to proxy it and be a router for it, you need to plan for many edge cases.

This presentation is on building an image recognition system in Elixir that converts a picture of a chessboard into Forsyth-Edwards Notation (FEN) for efficient storage and renders an interactive board in the UI.

Although this is a unique talk, most of the current resources I found during research for the task itself and they all use Python. I’d rather use Elixir!

I encountered the problem while building a web app for practicing chess tactics. I wanted to use the images in tactics books without manually setting up the digital board for each of the hundreds of exercises per book. Wouldn’t it be nice to take a picture of the board (a real-life or an abstract image) and have the app automatically set up the exercise? That would let me load arbitrary exercise books into the system in a fraction of the time.

ECSx is a new game development framework for real-time games and simulations. Leveraging the strengths of OTP for fast data access and strict serializability, ECSx makes it easy to bring your game ideas to life with the increasingly popular Entity-Component-System (ECS) architectural pattern.

In this talk, Andrew will show:

• How ECS architecture avoids many pitfalls which have historically driven skepticism towards game dev in Elixir
• How the ECSx framework manages your game’s data and logic under-the-hood
• Examples of building an app with the ECSx API and included generators
• How to use the ECSx LiveDashboard page to monitor the performance of a running app

In this talk, we will shed light on WhatsApp’s journey of managing one of the world’s largest Erlang/OTP clusters and the challenges faced due to the inherent limitations of the Erlang Distribution Protocol.

In our vast and intricate world of networked servers, the Erlang Distribution Protocol serves as the bedrock for clustering between Erlang and Elixir nodes, enabling the seamless communication and operation we enjoy today. However, with its original design not being inherently secure, the protocol can pose significant risks in larger-scale environments, where trust between servers becomes a question not only of capability but of security.

We’ve seen this trust question evolve at WhatsApp. What started as a question of “Should these few hundred servers trust each other?” has, due to our monumental growth, turned into “Should these tens of thousands of servers trust each other?” With such a scale, even unintentional mistakes can lead to massive outages, creating a large blast radius due to the mesh network formed by the nodes.

In the face of this challenge, we’ve developed a Native Implemented Function (NIF) named the “erldist_filter_nif” over the past year. This powerful tool assists in decoding dist packets on the receiving end, granting us the ability to either allow, drop, or redirect them for further inspection. This level of control will enable us to significantly reduce the blast radius a particular dist operation might have across the cluster.

Join me in this session as I share our experiences and lessons learned, and reveal how our innovations are pushing the boundaries of Erlang and Elixir in massive-scale production environments.

Phoenix Channels are great! They’re a go-to solution for adding real-time capabilities to our apps. But with a bit of creative thinking, Channels can also provide a full-duplex alternative to web API models like REST and GraphQL. Come and learn how building a stateful, Channels-based web interface can reduce network traffic, eliminate data overhead, and provide a unified mechanism for establishing application connectivity to browsers, mobile apps, and hardware devices.

After a brief introduction to (or perhaps a refresher on) Phoenix Channels, we’ll discover the interesting possibilities they represent and the problems they solve when backing a web API. You’ll learn how GridPoint leveraged Channels to build and deploy a “conversational” web API to support a critical business case, get the inside scoop on the tradeoffs involved, and learn why this model might fit your project well.

Stick around until the end for an introduction to a new Elixir library that can help jump-start your explorations with a Channel-based web API.

Access to large language models has revolutionized natural language processing, but to take better advantage of this capability, you need to fine-tune them for distinct tasks and with industry-specific data. This process seemed like magic until recently when I got my hands dirty solving a classification problem with RoBERTa. In this session, we will explore the key aspects of fine-tuning with Axon and Bumblebee, from data engineering and model selection to optimization techniques and evaluation strategies. By the end of the session, attendees will have a firm understanding of the nuance involved in fine-tuning language models and the confidence to apply these techniques effectively with Elixir.

Highlights:

• Connecting the Dots with Deep Learning: Attendees without prior knowledge of deep learning will get an introduction to help them comprehend the training techniques discussed throughout the session.
• Classification is the “Hello World” of Fine-Tuning: We will delve into the fundamentals of fine-tuning and discuss why classification was an ideal starting point for exploring the potential of large language models.
• Training Datasets: We will address the complexities involved in data engineering and what to be aware of when you start pulling together real training data.
• Accelerated Training with NVIDIA GPUs: The faster you train your models, the more quickly you can learn and adapt. We will explore the advantages of NVIDIA GPUs and how I got started with PopOS!. We will also cover out-of-memory errors and pitfalls I ran into while training on a GPU with limited vRAM.
• Model Selection: Attendees will learn how to leverage different models from the Hugging Face library by modifying specifications, allowing for flexibility and customization with help from Bumblebee.
• Optimization: Understanding the impact of batch size and sequence length on model performance is crucial. We will delve into the intricacies of these parameters and provide optimization strategies specific to NLP.
• Trainer Accuracy: While trainer accuracy is a useful metric, it is important to approach it with skepticism and manually verify results. Attendees will gain insights into effective methods for validating model performance.
• Comparative Analysis: We will guide attendees through the process of training multiple models such as BERT and RoBERTa and demonstrate the importance of comparing and contrasting results to determine the most suitable model for a given dataset.
• Quantity vs. Quality: More training data is not always better, it turns out. Attendees will gain an understanding of the tradeoffs involved in using larger training datasets and the risks of overfitting.
• Evaluation: We will conclude the session by addressing common challenges you face throughout the training process and how you might perform static analysis on your fine-tuned models to be sure the network is adequately trained.

Explore and benchmark the performance of distributed Erlang when connecting a large amount of Elixir nodes (200+). I plan to explore how increasing the number of connected nodes affects the performance of the whole mesh network using simple to understand examples and answer questions like: how is the total number of nodes affecting the speed at which other nodes can join or the performance of message passing between nodes?

The talk will explore different network topologies that can help with a large number of nodes (such as not connecting all the nodes together in a mesh) and also show an alternative to Distributed Erlang called Partisan and how that can help with some of the problems facing large number of node setups.

Vox is a new static site generator for folks that love Elixir. Write your site using things you already know: EEx and Elixir. Everything is set up so that if you know and love Elixir, things should be super simple for you to create a static website quickly and efficiently.

In this presentation, I will go over the philosophy behind Vox and why I chose to do things like I did. Beyond the philosophy and demonstrating its capabilities, I will detail the code that powers the site generator. There were many things I had to learn while creating this project, and I’m excited to share my learnings with others (topics include metaprogramming, code evaluation, filesystem considerations, Mix tasks, and others).

Finally, I’ll present the roadmap for what’s to come and how people looking to contribute can start contributing right away. Or, if someone wants to start writing their site using Elixir, how to get started either porting an old site to one using Vox or starting from scratch.

Phoenix contexts were introduced in Phoenix 1.3. Four minor versions later, we’re still confused when trying to apply them in our applications.

Contexts may make sense in theory, but it is hard to figure out just what makes a good context when it comes to practice. At least I know I’ve created many “contexts” that became… glorified junk drawers.

That’s because Phoenix contexts are generic: they’re a namespace. So, even though they give us a nudge in the right direction, they don’t provide enough guidance to implement our own successfully.

That’s where domain-driven design (DDD) can help us.

Using DDD’s concepts, we can create different Phoenix contexts based on their role!

So, join me as we walk through different types of Phoenix contexts we can use in our applications. Some will be DDD’s bounded contexts (different from Phoenix contexts), others will be DDD entities, and others will be DDD aggregates.

By the end, you’ll have a more extensive toolset for creating Phoenix contexts and a new lens through which you can organize your Elixir modules.

In today’s complex and ever-evolving world, the ability to make sense of uncertain and imprecise information is crucial for developing intelligent and adaptable solutions. How can we make a computer understand phrases like “The sensor is too cold” or “Increase the fan speed”? Traditional programming languages often struggle to handle such ambiguity effectively.

In this talk, we delve into the world of Fuzzy Logic and explore how it can be integrated into Elixir projects. Fuzzy Logic offers a framework for dealing with imprecise data, incomplete information, and uncertain conditions, making it a perfect match for solving complex problems that require human-like decision-making.

During the talk, we will start by introducing the foundations of Fuzzy Logic and its principles. We will then shift our focus to the integration of Fuzzy Logic concepts into an Elixir library called Flex, demonstrating how to model Fuzzy Sets, define Linguistic Variables, and create Fuzzy Rules that drive intelligent behavior with a complete Fuzzy System. Throughout the session, we will showcase a practical example and case studies where Fuzzy Logic has been successfully applied to enhance Elixir applications.

Furthermore, we will discuss the benefits and trade-offs of incorporating Fuzzy Logic as an alternative or complement to Control Theory and Artificial Intelligence, as well as future work.

With Elixir and the Erlang runtime, it has never been easier to build resilient software applications that span the globe, with computation distributed across countries or continents, running close to end-users.

But as our software’s ambitions grow beyond our borders, the user base becomes diverse in ways that can be challenging to anticipate. Each new language, currency, or calendar that we support can add significant complexity to our code if we’re not careful.

This talk will show how you can use tried-and-trusted tools, like gettext and the Common Locale Data Repository (CLDR) in Elixir, to build interfaces that live up to the expectations of diverse audiences around the globe.

We’ll discuss some of the trade-offs involved and show how you can prioritize which languages to support first in your applications.

Success in software engineering requires more than just technical proficiency/mastery. Continual, successful delivery of products and features requires vision, leadership, and communication. Some believe vision and leadership are only required of organizational leaders, but in reality, effective software engineers display these qualities regardless of title or position.

While the words “vision,” “leadership,” and “communication” are buzzwords and could be used to describe a plethora of concepts, this talk will break high-level concepts down into daily skills and habits that all developers could employ to increase their impact and effectiveness.

Whether you are a seasoned professional or an aspiring software engineer, this talk will provide specific skills and behaviors that will contribute to the holistic development of your skill set. Embrace the idea that true success in software engineering stems not only from code mastery but also from cultivating a range of skills.

Your UX is broken, and you probably don’t know it. LiveView lets you easily offload work in async processes to fetch information, talk to an external service, or perform some work for the user. But what happens when things go wrong?

Many times, developers reach for Task.async and only pay attention to the happy path. Let it crash, right?! Wrong. Unfortunately, what this really means for LiveView is to let it crash the UI. Even when you plan on failures and handle process isolation, you end up with logic spread throughout your LiveViews and templates. We can do better.

In my talk, I plan to dive deeply into how developers should approach asynchronous tasks in LiveView, focusing on loading states, responses, CSS animations and demonstrating the critical role of databases or ETS for persistence.

Asynchronous tasks in LiveView can be victim to timeouts, unexpected events in the client, or even user navigation which can cause development challenges and user headaches when poorly implemented.

This talk demonstrates how to safely and gracefully handle these unexpected hurdles by walking through tried and tested code used in production systems built entirely in LiveView and Elixir. We’ll see best practice techniques and demos for making asynchronous calls, demoing how to gracefully handle these potential errors, and walk attendees through patterns to promote system resilience and delightful user experiences.

Your UX is just as important as your Elixir code. Following the nitty-gritty details of async operations, we’ll also learn how to trigger CSS animations from the server to keep users informed about progress. Developers can greatly enhance interactivity and user engagement by employing these animations as a feedback mechanism.

Attendees will walk away with valuable insights and clear, actionable knowledge from peering inside production systems that have solved these problems. By the session’s conclusion, attendees will be equipped with the necessary tools and confidence to effectively navigate async jobs in Elixir & LiveView.

Req is an HTTP client for Elixir designed with the “batteries-included” approach. It does a lot of things out of the box. It automatically decompresses & decodes responses, follows redirects, retries on errors, etc. Req also has “replaceable batteries.” Virtually all of its features are implemented as distinct functions which developers can easily reuse, re-arrange, or write new ones. In this talk, you’ll see Req in action, learn more about its features and internals, and how you can extend it yourself.

It is insidiously easy to underestimate the difficulty of running a large-scale, zero-downtime data migration. For those with production experience, it can be rated the most challenging problem of a career; without experience, it’s likely to be scoffed at. After all, we’re “just” talking about moving data (or protocols or systems) from an old format to a new one, right?

This talk will present a case study from our work at Felt, where we migrated both large swathes of our Elixir codebase and many Ecto schemas atop our Postgres database over a period of months. Motivated by that, we’ll explore what makes data migrations so thorny and why success looks very different from fixing a bug or shipping a new feature. From there, we’ll turn our attention to the practice of executing migrations: patterns for successful management and how you can build a culture that makes zero-downtime migrations low-stress and low-risk.

Performance challenges with a React SPA created an opportunity to explore Liveview. After two days of exploration, we were convinced Liveview provided a path forward, and within a few weeks, we replaced our React SPA with Liveview.

This talk is the story of challenges we encountered with React while building Birdseye, a personal task aggregator and management tool, and how Liveview solved them.

In addition to the technical challenges we faced, we’ll discuss how patterns and conventions familiar to the React community will help React developers begin writing Liveview.

Liveview makes a compelling case to replace React in many products, so join me to explore the possibilities!