We can't find the internet
Attempting to reconnect
ElixirConf 2023 Keynotes, Speakers and Trainers
Keynote Speakers
-
-
-
-
Katelynn Burns
As someone who models, dances, and draws in my spare time, the movement of bodies is fascinating and complicated. AI might still have trouble knowing how many fingers a person should have, but with Liveviews’ open socket design and Bumblebee’s neural network capability guided by an artistic engineer, we can make some motion magic.
Speakers
-
- Building recursive workflows with Broadway
Anthony Accomazzo
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.
Building recursive workflows with Broadway
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.
-
- Nx Powered Decision Trees
Andrés Alejos
Creator of EXGBoost and Mockingjay libraries.
Nx Powered Decision Trees
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.
-
- Flex: Empowering Elixir with Fuzzy Logic for Real-World Solutions.
Aldebaran Alonso
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.
Flex: Empowering Elixir with Fuzzy Logic for Real-World Solutions.
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.
-
- Drawing to 7-color e-ink screens with Scenic and Nerves
Jason Axelson
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.
Drawing to 7-color e-ink screens with Scenic and Nerves
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.
-
- Easy Ergonomic Telemetry in Production w/ Sibyl
Chris Bailey
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!
Easy Ergonomic Telemetry in Production w/ Sibyl
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!
-
- Erlang Dist Filtering and the WhatsApp Runtime System
Andrew Bennett
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.
Erlang Dist Filtering and the WhatsApp Runtime System
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.
-
- ECSx: A New Approach to Game Development in Elixir
Andrew Berrien
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: A New Approach to Game Development in Elixir
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
-
- Elixir's Secret Ingredient
Owen Bickford
I am a Senior Developer at SmartLogic, co-host of the Elixir Wizards podcast, and an avid pun peddler.
Elixir's Secret Ingredient
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.
-
- Fine tuning language models with Axon
Toran Billups
Toran Billups is a self-proclaimed builder of empowered product teams, software engineer and aspiring machine learning practitioner
Fine tuning language models with Axon
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.
-
- Building a globally distributed router
De Wet Blomerus
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.
Building a globally distributed router
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.
- All login traffic passes through this router, so it should add minimal latency ✅.
- 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 ✅
-
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.
- 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.
- 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.
- 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.
-
- Black Box Techniques for Unit Tests
Jenny Bramble
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.
Black Box Techniques for Unit Tests
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?’
-
- Building a database gui and proxy with elixir
Michael St Clair
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.
Building a database gui and proxy with elixir
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.
-
- Ash 3.0: Better Together
Zach Daniel
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 3.0: Better Together
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!
-
- Managing a massive amount of distributed Elixir nodes
Razvan Draghici
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.
Managing a massive amount of distributed Elixir nodes
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.
-
- Scaling Up Travel with Elixir
Kimberly Erni
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.
Scaling Up Travel with Elixir
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.
-
- Filling the Gaps in the Ecosystem
AJ Foster
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.
Filling the Gaps in the Ecosystem
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. -
- Building Embedded and Core System with Elixir for millions AI-based point of sales
Alfonso Gonzalez
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.
Building Embedded and Core System with Elixir for millions AI-based point of sales
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.
-
- Handling async tasks in LiveView with style and grace
Chris Gregori
Staff Engineer @ Multiverse, Indiehacker and Elixir enthusiast
Handling async tasks in LiveView with style and grace
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.
-
- Replacing React: How Liveview solved our performance problems
Tim Gremore
Set free by God’s grace alone. Happily married. Father of five. Development Lead with Headway.
Replacing React: How Liveview solved our performance problems
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!
-
- Chess Vision!
Barrett Helms
Making computers do stuff one Unicode at a time.
Chess Vision!
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.
-
- Building AI Apps with Elixir
Charlie Holtz
Hacker in Residence at Replicate. Previously a quantitative engineer at Point72. Creator of ShlinkedIn.
Building AI Apps with Elixir
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.
-
- Our LiveView Native Development Journey
David Bluestein II
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.
Our LiveView Native Development Journey
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.
-
- Learn Stochastic Gradient Descent in 30 Minutes
Eric Iacutone
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.
Learn Stochastic Gradient Descent in 30 Minutes
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.
-
- Unleashing the Power of DAGs, introducing Pacer Workflow
Zack Kayzer
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.
Unleashing the Power of DAGs, introducing Pacer Workflow
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.
-
- “SVG Island“: On building your own charts in Phoenix LiveView
Mark Keele
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.
“SVG Island“: On building your own charts in Phoenix LiveView
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:
- Evaluating existing Elixir charting libraries and coming to the decision to build their own charts
- Pioneering a method to hand roll charts using SVGs
- Building an interactive chart as a Phoenix component
- 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!
-
- Driving Performance with Req and Finch at Cars.com
Christian Koch
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.
Driving Performance with Req and Finch at Cars.com
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.
-
- Unleashing the Power of DAGs, introducing Pacer Workflow
Stephanie Lane
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.
Unleashing the Power of DAGs, introducing Pacer Workflow
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.
-
- Introducing Vox: the static site generator for Elixir lovers
Geoffrey Lessel
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.
Introducing Vox: the static site generator for Elixir lovers
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.
-
- Elixir Security: a Business and Technical Perspective
Michael Lubas
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.
Elixir Security: a Business and Technical Perspective
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.
-
- Req - a batteries-included HTTP client for Elixir
Wojtek Mach
Wojtek Mach is a developer at Dashbit, based in Kraków, Poland. He’s a member of Hex, Ecto, and ExDoc Core Teams.
Req - a batteries-included HTTP client for Elixir
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.
-
- Functional Juniors: Leveling up your New Elixir Devs
Savannah Manning
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.
Functional Juniors: Leveling up your New Elixir Devs
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.
-
- “SVG Island“: On building your own charts in Phoenix LiveView
Meks McClure
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.
“SVG Island“: On building your own charts in Phoenix LiveView
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:
- Evaluating existing Elixir charting libraries and coming to the decision to build their own charts
- Pioneering a method to hand roll charts using SVGs
- Building an interactive chart as a Phoenix component
- 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!
-
- Lessons Learned Working with Ecto.Repo.put_dynamic_repo/1
Sam McDavid
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.
Lessons Learned Working with Ecto.Repo.put_dynamic_repo/1
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.
-
- A11y testing a LiveView application with Excessibility
Andrew Moore
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.
A11y testing a LiveView application with Excessibility
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.
-
- MLOps in Elixir: Simplifying traditional MLOps with Elixir
Sean Moriarity
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 in Elixir: Simplifying traditional MLOps with Elixir
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.
-
- Exploring LiveViewNative
Brooklin Myers
🎙️ Host of ElixirNewbie podcast 🧙♂️ Elixir Instructor at @DockYard Academy 🙏 I help new and aspiring developers adopt Elixir
Exploring LiveViewNative
Delve into the powerful combination of Elixir and LiveView as we explore LiveViewNative application development for Android, iOS, and beyond.
-
- The Alchemy of Elixir Teams; an Engineering Manager’s Tale
Sundi Myint
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.
The Alchemy of Elixir Teams; an Engineering Manager’s Tale
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
-
- Beyond LiveView: Getting the javascript you need while keeping the Elixir you love
Chris Nelson
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.
Beyond LiveView: Getting the javascript you need while keeping the Elixir you love
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
andLiveState
, 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 ;) -
- Beacon: The next generation of CMS in Phoenix LiveView
Leandro Pereira
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.
Beacon: The next generation of CMS in Phoenix LiveView
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.
-
- ex_cldr - Personalized Applications for a Global Audience
Petrus Janse van Rensburg
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.
ex_cldr - Personalized Applications for a Global Audience
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.
-
- Beyond Technical Prowess: Competency is Not Enough
Miki Rezentes
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.
Beyond Technical Prowess: Competency is Not Enough
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.
-
- Conversational Web APIs with Phoenix Channels
Nicholas Scheurich
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.
Conversational Web APIs with Phoenix Channels
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.
-
- A Real Life Example of Using Meta-programming: Speeding up dynamic templates.
Andrew Selder
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.
A Real Life Example of Using Meta-programming: Speeding up dynamic templates.
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.
-
- Rewrite Pion in Elixir
Michał Śledź
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.
Rewrite Pion in Elixir
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.
-
- Orb: Write WebAssembly with the power of Elixir
Patrick Smith
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.
Orb: Write WebAssembly with the power of Elixir
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.
-
- A LiveView is a Process
Jason Stiebs
Phoenix Core team member, Senior Framework Specialist at Fly.io and long time consultant. Using Phoenix since before it was cool (literally).
A LiveView is a Process
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!
-
- Keeping real-time auctions running during rollout. From white-knuckle to continuous deployments.
Rafal Studnicki
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.
Keeping real-time auctions running during rollout. From white-knuckle to continuous deployments.
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.
-
- Scaling Teams with Kafka on the BEAM
Jeffery Utter
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.
Scaling Teams with Kafka on the BEAM
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.
-
- Using DDD concepts to create better Phoenix Contexts
German Velasco
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/
Using DDD concepts to create better Phoenix Contexts
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.
-
- Exploring code smells in Elixir
Elaine Watanabe
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.
Exploring code smells in Elixir
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.
-
- fragment/1: Ecto.Query's underrated superweapon
Alexander Webb
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.
fragment/1: Ecto.Query's underrated superweapon
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 wherefragment
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
-
- State: A necessary Evil
Isaac Yonemoto
Elixir Software Developer
State: A necessary Evil
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!
-
- Rebuilding the Plane While It’s Still Flying
Tyler Young
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.
Rebuilding the Plane While It’s Still Flying
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.
Trainers
-
- Building Data-Driven Workflows in Broadway
Britton Broderick
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.
Building Data-Driven Workflows in Broadway
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.
-
- Ash Framework: The Fast Track to Full Stack
Zach Daniel
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: The Fast Track to Full Stack
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.
-
- Beyond LiveView: Getting the Javascript you need while keeping the LiveView you love
Andrew Ek
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.
Beyond LiveView: Getting the Javascript you need while keeping the LiveView you love
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
-
- Instrumenting Elixir Applications
Ethan Gunderson
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.
Instrumenting Elixir Applications
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.
-
- Instrumenting Elixir Applications