Anthony started Sequin to free developers from the monotonous work of HTTP API integrations. Outside of Elixir, he enjoys beach volleyball, getting too hot (saunas), getting too cold (plunges), and making swedish arthouse parodies.

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.

Creator of EXGBoost and Mockingjay libraries.

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.

I’m an Embedded Systems Engineer at Valiot, where I do what I love on a daily basis: making hardware work by delving as deeply as possible to understand the problem until I reach the core issue. Essentially, I’m part of the hardware and software design team, focusing specifically on Edge device design. Before joining Valiot, I worked in various startups designing embedded systems for intelligent lighting equipment. Prior to that, I went through a phase in bioengineering, where I was involved in biological signal processing for the development of brain-machine interfaces.

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.

Jason has been a professional developer for 12 years, using a variety of programming languages before falling in love with Elixir in 2016. His is a member of the Scenic core team has previously contributed to ElixirLS and many other dev tooling projects. He enjoys tinkering with hardware and pushing Elixir to its limits. Oh, and he also enjoys a good whiskey.

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.

I’m a tech and team lead based in London who is currently leading a team at Vetspire building awesome stuff in Elixir.I graduated in 2017 with a Computer Science degree from the University of Canterbury (the birthplace of the Miranda PL) and fell in love with Erlang during my second year.After graduating, I joined Erlang Solutions as an Erlang & Elixir consultant and have since joined a small Veterinary Practice Management startup, trying to help improve the lives of Veterinarians across the US and Canada!Because I’ve been pretty single-mindedly focused on the BEAM and I’ve seen a lot of Erlang and Elixir apps of various scales in the wild, I aim to take and distill my learnings and papercuts I’ve gained along the way and share them with my team, to empower them to do great things and hopefully discover the same love of the BEAM as I have!

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!

Andrew Bennett, with over a decade of experience in Erlang and Elixir, currently works on the Erlang Runtime Team at WhatsApp, assisting with one of the world’s most substantial Erlang/OTP clusters. Previously, he has applied his expertise to scale and secure systems within the automotive, insurance, and finance industries. Andrew balances his technical pursuits with an interest in distributed system performance, security, and cryptography research. Away from work, he appreciates quality time with his family.

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.

Andrew P Berrien is a Senior Software Engineer at DockYard, where he enjoys solving complex problems with the magic of Elixir. In addition to his contributions to open source libraries such as Ets and Beacon, he is also the creator of the ECSx game development framework. Outside of work, Andrew spends most of his free time training in the sport of submission grappling a.k.a. jiu-jitsu.

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

I am a Senior Developer at SmartLogic, co-host of the Elixir Wizards podcast, and an avid pun peddler.

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.

Toran Billups is a self-proclaimed builder of empowered product teams, software engineer and aspiring machine learning practitioner

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.

My name is De Wet (Sounds like The Vet)

I’ve been writing Elixir professionally since 2019. I keep trying to get more people to notice that in most scenarios, using Elixir is in the best interest of the business, and the engineer.

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.

Jenny came up through support and devops, cutting her teeth on that interesting role that acts as the ‘translator’ between customer requests from support and the development team before diving headlong into her career as a tester. Her love of support and the human side of problems lets her find a sweet spot between empathy for the user and empathy for her team. She’s done testing, support, or human interfacing for most of her career. She finds herself happiest when she’s making an impact on other people–whether it’s helping find issues in applications, speaking at events, or just grabbing coffee and chatting.

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?’

I am currently the Director of Platform Engineering at PDQ. I have been working with elixir since 2016 building various services from accounting software to banking. The last few years I have taken a more DevOps focused approach in my career but continue to use elixir to build tools to make developers lives easier.

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.

Zach is a software engineer with seven years of experience with production Elixir applications. He is the Creator of Ash Framework, a resource-oriented declarative design framework for Elixir, and principal platform engineer at Alembic. He has a passion for declarative design, functional programming, and contributing to the open source community. When not programming, he enjoys spending time with his wonderful wife, pets, friends and family.

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!

I’m a techie based in Toronto, Canada. I have done multiple startups, led teams, freelanced and worn almost all hats in the software engineering: from sys-admin / devops engineer to software architect on both the front-end and back-end of the stack. I’ve been using Elixir in production since 2017 and it has been my go-to stack ever since.

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.

Kimberly Erni is a passionate Elixir enthusiast and junior developer at TravelPass Group, a leading travel technology company. With over a year of experience in software development, Kimberly has dedicated herself to mastering Elixir as her first programming language as she has worked to be able to contribute to TravelPass Group.

Inspired by the powerful capacity that Elixir has to develop scalable, fault-tolerant systems that developers are happy to work in, Kimberly has been excited and eager to support the development of the travel products at TravelPass Group. As an advocate for Elixir, Kimberly brings a fresh perspective to the language, showcasing how it can be harnessed effectively by developers with different backgrounds.

Through her proposed talk at ElixirConf US 2023, Kimberly aims to inspire developers at all levels, showcasing how Elixir has been an effective tool in the development of a travel product that TravelPass Group is proud and happy to share with friends, family, and the world. She will share lessons learned from the teams journey of building a scalable and fault-tolerant travel platform.

I would love to share TravelPass Group’s experience and insights on leveraging Elixir to transform our travel platform. Our journey began over a year ago when we migrated our backend system to Elixir. The tremendous benefits allowed us to build a scalable, fault-tolerant, highly available, and concurrent system.

During the presentation, I will provide an overview of Elixir’s key features and strengths, making it an excellent choice for developing our travel platform. I will showcase how the migration to our Elixir App significantly sped up the booking flow, making It faster and easier for our users to book.

Moreover, I will discuss our successful integration with data services using the GenServer behavior. This efficient tool enabled us to send and manage data effectively, fostering seamless communication with our data services team.

Throughout our journey, we learned valuable lessons and developed best practices for building Elixir-based travel platforms. I will summarize these key takeaways, including pitfalls to avoid and strategies for successful development. Attendees will gain practical knowledge to apply when embarking on similar projects.

In conclusion, my talk will highlight how TravelPass Group harnessed the power of Elixir to create a more efficient travel platform. Attendees will gain insights into the advantages of Elixir, the complexities of integrating with travel providers, the benefits of using GenServer for data services, and the best practices we’ve learned along the way.

AJ is a native of Central Florida who works as a Software Engineer at CodeSandbox. He is lucky enough to write Elixir every day, and he spends his free time serving as a FIRST Technical Advisor for youth robotics teams.

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.

tarted in the electronic engineering world, started to work on desktop and web development, delivering big systems, understanding good ways to deliver valuable information from data storages, and building IoT platforms collecting data for Machine Learning training had been my high-level journey through technology.

I have over 10 years of software development experience, designing and implementing systems for governments and private companies, got involved in the VC global community, and working to re-invent the retail world.

Currently helping to build an AI and computer vision company for retail 3.0 infrastructure from the engineering perspective.

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.

Staff Engineer @ Multiverse, Indiehacker and Elixir enthusiast

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.

Set free by God’s grace alone. Happily married. Father of five. Development Lead with Headway.

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!

Making computers do stuff one Unicode at a time.

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.

Hacker in Residence at Replicate. Previously a quantitative engineer at Point72. Creator of ShlinkedIn.

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.

David Bluestein II is the founder of ii, inc., where he consults as a senior software developer. Starting with Perl in the 1990’s, he moved to Ruby on Rails in the 2000’s and Elixir/Phoenix in the late 2010’s. He has done projects for companies such as Gerber Baby Food, The University of Texas - Austin, SXSW, AMD, the Arkansas Department of Education, and numerous startups. He is a co-manager of the Austin Elixir group. He is currently working on projects with real-time financial data feeds using LiveView PubSub and LiveView Native, argument mapping using LiveView and dynamic SVG, and some side projects using Nx for Machine Learning and Data Visualization.

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.

Eric Iacutone is a software developer based in St. Petersburg, FL. Eric learned web development at the Flatiron School in 2013 and has been involved in the software industry for nearly a decade. Eric writes Elixir code at cars.com.

Outside of work, you can find Eric chasing his toddler around the park. Additionally, Eric has an interest in photography, capturing family moments through a lens. He also tries to find time to do physical activity by running and powerlifting. He can also make a decent pizza.

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.

Zack Kayser is an Elixir enthusiast and software engineer working on cool problems at scale at cars.com. He has worked with Elixir since 2016 and contributed to production systems big and small, as well as contributed as the lead developer on the project that won Dockyard’s Phoenix Phrenzy competition in 2019. Outside of the software engineering world, Zack enjoys traveling, running, and sipping on coffee and/or fine beer.

Have you ever had a complex module that is challenging to comprehend, debug, and maintain due to data that has intricate interdependencies with logic stuck in numerous private functions? How do you sort out the dependencies while keeping the relationships between your data points clear and easy to reason about? Try a Directed Acyclic Graph (DAG)!

In this talk, we’ll explore how we originally tried to solve the problem, how we settled on using a DAG to create a dependency graph, and what we were missing from a traditional DAG that led us to write an abstraction called Pacer.Workflow. Graphing libraries like Erlang’s :digraph and the Hex package LibGraph provide functions and algorithms for working with DAGs like topological sorts and utilities for visualizing graphs out of the box; however, we wanted to build some more tooling and utilities on top of these features, such as the ability to collapse several nodes in the graph into a single node representation in certain situations (spoiler: we associate nodes in the graph with functions that we want to run, and in some cases, we want to run several functions in parallel if possible, thus the need to collapse multiple nodes into one).

While building out Pacer.Workflow, we focused heavily on the developer experience, starting from providing a number of compile-time checks and guarantees with descriptive messaging when constraints are violated, building in Telemetry events from day one, and a focus on documentation and example usage.

Mark Keele (he/him) is a software engineer with a background in computer science with a BS and MS in Computer Science. Mark’s first interaction with a computer was him sneaking on to his brother’s MS DOS system to play DOOM. From there he began building computers and ended up in computer science because his high school math teacher suggested it. He works as a software engineer at GridPoint, focusing on using Elixir to accelerate a sustainable energy future, building by building.

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!

Christian is an experienced software engineer with over a decade of expertise and a tech enthusiast for over two decades. When he’s not diving into code, you can find him embracing his active side as an occasional triathlete and passionate cyclist. He lives & works in Chicago with a wife, son, and 3 cats.

Buckle up and join us on a ride to explore our unique approach to improving web request performance at Cars.com. We will take you on a journey from HTTPoison to Req and Finch and showcase how we unlocked the true horsepower of our web requests.

Our approach goes beyond simply selecting Req as the new default. We developed a solution that harnesses the combined power of Req and Finch to optimize performance and resource utilization. Our solution is backed by data demonstrating a significant improvement in web request performance, making it an ideal solution for high-scale web requests. We will provide a detailed analysis of the comparative strengths and weaknesses of various HTTP libraries we considered and tested, including performance benchmarks and resource utilization. We will also discuss the architectural considerations and design patterns contributing to our decision-making process.

As a car-themed website, we couldn’t resist the opportunity to sprinkle in some puns. This talk is designed to be accessible to all levels of expertise, with a focus on practical techniques to drive high-scale web requests. Attendees will gain valuable insights into our innovative approach to driving web requests at Cars.com and leave with a full tank of knowledge to accelerate their web request performance.

Stephanie Lane is a software engineer working at Cars.com and has worked with Elixir since 2019. She resides in Atlanta with her fiance and 2 dogs.

Have you ever had a complex module that is challenging to comprehend, debug, and maintain due to data that has intricate interdependencies with logic stuck in numerous private functions? How do you sort out the dependencies while keeping the relationships between your data points clear and easy to reason about? Try a Directed Acyclic Graph (DAG)!

In this talk, we’ll explore how we originally tried to solve the problem, how we settled on using a DAG to create a dependency graph, and what we were missing from a traditional DAG that led us to write an abstraction called Pacer.Workflow. Graphing libraries like Erlang’s :digraph and the Hex package LibGraph provide functions and algorithms for working with DAGs like topological sorts and utilities for visualizing graphs out of the box; however, we wanted to build some more tooling and utilities on top of these features, such as the ability to collapse several nodes in the graph into a single node representation in certain situations (spoiler: we associate nodes in the graph with functions that we want to run, and in some cases, we want to run several functions in parallel if possible, thus the need to collapse multiple nodes into one).

While building out Pacer.Workflow, we focused heavily on the developer experience, starting from providing a number of compile-time checks and guarantees with descriptive messaging when constraints are violated, building in Telemetry events from day one, and a focus on documentation and example usage.

Geoffrey Lessel has been loving Elixir since first discovering it in 2014. Since then, he’s written Phoenix in Action (published by Manning) and many blog posts at geoffreylessel.com, spoken at 8 Elixir conferences (including ElixirConf 2017, 2019, and 2021), and currently has a video course on Phoenix for sale in early access at BuildItWithPhoenix.com. He’s currently living in Little Rock, AR with his wife, 3 kids, and a dog.

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.

Michael Lubas is the founder of Paraxial.io, a security platform for Elixir and Phoenix. He has several years of experience working in web application security, software development, and security consulting. He wants to see every Elixir and Phoenix developer have the tools they need to keep their software safe.

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.

Wojtek Mach is a developer at Dashbit, based in Kraków, Poland. He’s a member of Hex, Ecto, and ExDoc Core Teams.

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.

Savannah is a full-stack software engineer currently working at Iconic Moments, where she is building an innovative NFT marketplace for museums worldwide using primarily Elixir. She brings a wealth of experience to the role, having started her own successful international rock-climbing company after graduating from university. In late 2019, she decided to pursue her passion for technology and transitioned into software development, quickly becoming proficient in technologies such as Elixir, Phoenix, and LiveView. As a self-taught developer, Savannah has a unique perspective on software development and is constantly seeking new ways to expand her knowledge and skills. She is dedicated to her work, and is responsible for implementing new features, debugging reporting tools, creating efficient code with a TDD approach, and staying up-to-date with the latest advancements in the field.

Beyond her work in software development, Savannah is also passionate about empowering others to seek education and create more opportunities for diversity and inclusion in the tech industry. Based in Chattanooga, TN, Savannah is an avid rock climber and spends much of her time traveling the world to pursue her passion.

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.

Meks McClure (they/them) is a software engineer with an unconventional background with a BA in Biology and Philosophy. Meks found their passion for programming after building a website for a Mexican non-profit. Seeing people use the website and how it helped the community inspired Meks to pursue a career in programming. They work as a software engineer at GridPoint, focusing on using Elixir to accelerate a sustainable energy future, building by building.

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!

I am a lead software engineer at Validere. We build an MRV platform for tracking Carbon emissions, methane and CO2. I have been working in Elixir for over 5 years now and have a lot of experience delivering solutions.

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.

I began as an apprentice with Launch Scout 2.5 years ago. I live in a tiny mountain town called Pagosa Springs, CO with my partner Robyn, our son Jude, and our cat Nina. I enjoy all things tech related, and when I am not enjoying that, I am probably enjoying either fishing, hiking, reading, or playing a video game.

At Launch Scout, we’ve made it a goal to have automated accessibility testing on all new projects we take on. Excessibility is the culmination of several months of effort toward that goal. This tool allows you to take a snapshot of the DOM at any point in your tests. These snapshots can then be analyzed via a mix task for any WCAG violations, either locally or in a CI pipeline.

We have gone through several iterations of this concept. This session will cover some of the approaches we tried initially, and why we found them lacking, We’ll also go over some of the challenges we faced in developing the tool and how we overcame them. We’ll look at some different a11y fails that the tool will catch for you and a little about how you might fix them. We’ll also talk about some of the challenges people with different disabilities face in using the web and how we can make it a little easier.

As someone with a fairly significant visual disability, I feel like I’m uniquely positioned to talk about the topic from a user and developer standpoint. I’m thrilled to be able to spread awareness and give back to the community.

Author of Genetic Algorithms in Elixir and Machine Learning in Elixir. Co-creator of Nx, creator of Axon, and co-chair of the Erlang Ecosystem Foundation Machine Learning Working Group.

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.

🎙️ Host of ElixirNewbie podcast 🧙‍♂️ Elixir Instructor at @DockYard Academy 🙏 I help new and aspiring developers adopt Elixir

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

Sundi is an Engineering Manager at SmartLogic, based out of Baltimore, MD. She is a Co-Host of the Elixir Wizards Podcast, as well as runs the DC |> Elixir Meetup, which helps to fulfill her hobby of connecting all Elixirists across the community. When she is not Elixiring, you can find her in her garden.

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

Chris Nelson is the Co-Founder of Launch Scout, an agile software development firm in Cincinnati. He created the company’s apprenticeship program, mentors new developers, and sets technology direction. He loves sharing what he’s learned from over 25 years of developing software across a wide range of industries. Chris has given workshops across the country and spoken at conferences including Elixirconf, RailsConf, RubyConf, JavaOne, CodeMash and Scottish Ruby Conf.

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 ;)

Leandro Pereira is a Software Engineer at DockYard building Beacon and live_monaco_editor. He started working with Phoenix LiveView in the early days, is an Open Source enthusiast, and enjoys contributing to Elixir projects.

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

Petrus Janse van Rensburg is a full-stack Engineer from Cape Town, South Africa. He enjoys building software startups in emerging-markets, and some of his favorite tools are Elixir, Postgres & Python. Talk to him about UX, localization, machine learning, optimization or startups in general.

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.

Miki Rezentes currently works as a Principal Engineer with dscout. She’s been part of eight startups and seen more than her share of the chaos. Her years as a software engineer were preceded by 18 years of being a homeschool mom to her 5 kids. When Miki isn’t working there is a good chance she is at a rink on 8 wheels. For your own good, don’t bring up skating to her unless you are prepared for a long and lively conversation.

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.

Nicholas Scheurich (he/him) is a scholar of arcane mysteries such as computer programming, game design, and ancient text editors. He works as a software engineer at GridPoint, focusing on using Elixir to accelerate a sustainable energy future, building by building.

When not hacking on some ill-fated side project, Nick can often be found drawing, playing tabletop RPGs, or trying to pull the perfect shot of espresso. He resides in southeast Louisiana with his wife, son, and loyal feline companion.

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.

Andrew is currently a Senior Staff Software Engineer at Estée Lauder Online, leading the charge in bringing monitoring and observability to all our apps. Andrew has been involved in the Elixir and Ruby communities for almost 20 years. Some of his previous spots have been technical leadership roles at Pepsi eCommerce, UserTesting.com, GoDaddy and more.

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.

Membrane Framework developer and co-creator of Jellyfish media server with over 3 years of experience working on WebRTC. Mostly interested in networking, and audio/video processing.

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.

Patrick has made websites since following a tutorial for Adobe ImageReady back in 2000. Since then he has co-founded multiple startups, worked as front-end engineer and designer, taught 3 bootcamps cohorts, made several Mac apps, and worked as a consultant.

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.

Phoenix Core team member, Senior Framework Specialist at Fly.io and long time consultant. Using Phoenix since before it was cool (literally).

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!

Rafal is a software engineer with 12 years of experience in C, Erlang, and Elixir. He has worked on various distributed systems, ranging from tiny clusters on microcontrollers to some of the largest chat servers in the world.

Having consulted on many real-world projects, he has come to believe that clean architecture, ruthless simplicity, and a principled stance towards testing for correctness are required for software to serve its business purpose successfully in the long run.

Currently, Rafal is a software engineer at Whatnot, a rapidly growing live shopping platform.

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.

Jeff is a staff software engineer on the platform team at theScore. In his free time, Jeff leads a double-life as a jazz double bassist.

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.

German is an independent software developer and product consultant. He loves Elixir’s functional style, but he loves the power of the BEAM even more. He loves to share what he learns with the community through writing, videos, and courses. You can find out more about him at https://www.germanvelasco.com/

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.

Elaine has been a Software Developer since 2008. She has a M.Sc. in Computer Science, and a B.Sc. in Computer Engineering, and is fascinated by Elixir and Ruby languages, software engineering, technical leadership, and scientific research in distributed systems.

Since 2017, she has presented +15 talks at multiple tech conferences for audiences of different levels (beginner, intermediate and advanced) about Ruby and Elixir languages, introduction to programming, code design, and code review practices. She is also a Rails Girls São Paulo mentor, coffee lover, and former taiko drummer.

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.

Ten years of experience working on SaaS backends. Wife + 2 stepkids. Too many cats (4 right now), and one white fluffy dog. Coding, jeeping, sleeping.

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

Elixir Software Developer

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!

I’m a backend-focused developer working at Felt, where we’re building a real-time, collaborative mapmaking app. (Think Figma meets maps.) I’ve worked in a number of soft real-time, distributed systems domains, including flight simulation, networking, video streaming, and IOT command-and-control systems. I fell in love with the Elixir language in 2019, when I used it to build a massively multiplayer game server for the X-Plane flight simulator, and I’ve been working primarily with Elixir ever since.

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.

Britton is the cofounder and CTO at QuotaSignal, where he’s building the team and tools to help solve sales hiring and training. He’s spent his career in startups, and has been involved in the Elixir community for the past seven years.

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.

Zach is a software engineer with seven years of experience with production Elixir applications. He is the Creator of Ash Framework, a resource-oriented declarative design framework for Elixir, and principal platform engineer at Alembic. He has a passion for declarative design, functional programming, and contributing to the open source community. When not programming, he enjoys spending time with his wonderful wife, pets, friends and family.

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.

Andrew Ek is a principal engineer at Launch Scout, where he builds software for clients with Elixir, Ruby, and JavaScript. Before being a software developer he taught poetry and math. Andrew lives in Lincoln, Nebraska, with his family.

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

Ethan is a principal software engineer at Cars.com where he focuses on platform architecture, scalability, and performance. In previous roles he has run the gamut from product development, management, security, infrastructure, and data engineering.

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.

Zack Kayser is an Elixir enthusiast and software engineer working on cool problems at scale at cars.com. He has worked with Elixir since 2016 and contributed to production systems big and small, as well as contributed as the lead developer on the project that won Dockyard’s Phoenix Phrenzy competition in 2019. Outside of the software engineering world, Zack enjoys traveling, running, and sipping on coffee and/or fine beer.

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.

Andrew is a Staff Engineer at Divvy currently working on building data pipelines to scale our card product to the next level. He has a love for learning and breaking down complicated topics into simple pieces for others to learn along with him. He enjoys rock climbing, spending time with his two cats, and playing video games.

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.

Michael Lubas is the founder of Paraxial.io, a security platform for Elixir and Phoenix. He has several years of experience working in web application security, software development, and security consulting. He wants to see every Elixir and Phoenix developer have the tools they need to keep their software safe.

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

Chris Nelson is the Co-Founder of Launch Scout, an agile software development firm in Cincinnati. He created the company’s apprenticeship program, mentors new developers, and sets technology direction. He loves sharing what he’s learned from over 25 years of developing software across a wide range of industries. Chris has given workshops across the country and spoken at conferences including Elixirconf, RailsConf, RubyConf, JavaOne, CodeMash and Scottish Ruby Conf.

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

Josh Price is a polyglot software developer and technology consultant from Sydney, Australia.He’s passionate about modern approaches to Software Development and helping teams build amazing software faster with better tooling. He’s organised community events such as the Elixir Sydney and GraphQL Sydney meetups for many years.He also co-founded Alembic, which is building a team to bring functional programming benefits to everyone’s day to day work. When not running Alembic or thinking about how to build software more effectively, he’ll generally enjoy talking interesting ideas over a pint of craft beer. or thinking about his next adventure.

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.

Parker Selbert is a developer with a passion for building things both virtual and physical. He is the creator of the Oban job processor, chief architect at dscout, and partners with his wife at Soren building Oban Web and Pro.

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

Shannon Selbert is an aspiring polyglot, programmer, product manager, and contract law enthusiast (really!). After a stint doing technical training for the government, her entrepreneurial spirit led her to co-found Soren in 2008, where she consulted for over a decade before transitioning to the development of Oban Pro.

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

Bruce Tate is a boater, climber, and author from Chattanooga, Tennessee. A serial entrepreneur, he has helped start three companies. The author of more than 15 books, he is is active in the Elixir community as a speaker, author, mentor and conference organizer. His love for teaching and computer languages led him to found Groxio in 2018.

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.