This talk will consider whether we can trust distributed systems to behave as we expect and to be available to us when we need them. We'll take a whistle-stop tour of the academic literature, visiting key results on what's possible, and more importantly, what's impossible, in the context of distributed computing. We will then see how this research has shaped how we reason about and build resilient distributed systems today. We'll look ahead to some up-and-coming trends, including trusted hardware and decentralization, to see how we can re-imagine today's systems and whether these technologies hold the key to circumventing the impossibility results in distributed systems and finally making the impossible possible.

Networking can seem like a challenging and overwhelming task, but the BEAM is truly one of the best matches for tackling it. I believe this so much that I'm writing a whole book on this topic! But in this talk, we'll mostly focus on two things. First, we'll talk about when the BEAM is the right fit for networking applications, especially compared to “lower-level” languages (such as Rust or Go). Then, we'll shift our focus to using the BEAM to write TCP applications, since TCP is the most-widely-used application networking protocol out there. We'll talk about:

We'll discuss how the BEAM's lightweight processes and messaging system provide a powerful and intuitive way to handle TCP sockets and data.
We'll explore how to use acceptor pools and supervision trees to build scalable and fault-tolerant TCP servers.
I'll show you how to use the gen_statem behaviour to build reliable TCP clients that can handle unexpected events and gracefully recover from errors.
This stuff is at the foundation of Phoenix, LiveView, channels, and more. Even if you're not working at the lower levels of the networking stack, this talk will help you understand how many of the tools and patterns we use every day work under the hood.

In this talk we will explore the fundamentals behind the magic of some of the debugging tools in Elixir and their benefits to debug borderline conditions and find hard to reproduce bugs in live Erlang systems 🔮🪄

Elixir has a very powerful set of debugging tools not everyone is aware of. They bring the community benefits inherited from the need to debug borderline conditions and find hard to reproduce bugs in live Erlang systems. In this talk, we'll explore the foundations behind Elixir wrappers like Rexbug, using examples to explain the fundamentals which give us all this magic.

I do a ton of work in the Kubernetes and Cloud Native space, but I'm also a big fan of Elixir. My general disgust towards Golang drove me to build k8s.ex and Bonny, so that I could work in Kubernetes without touching go.

Over the years, I've gotten increasingly involved with Go, particularly in some of the high-security provisioning areas of Massdriver. I've found a number of language features that I find myself missing when I get back to Elixir.

This talk will cover embedded filesystems, error interfaces (go's error handling is awesome if you understand it!), package management and internal packages, implicit interfaces, and struct tags.

The machine learning (ML) landscape in Elixir is evolving quickly. Our team does not have production ML experience and the go-to right now is clearly (clearly right?) Python. But, we wanted to see if we could stick to our tech stack (aka Elixir/Phoenix) and set out to build a recommendation engine for our gifting platform. We landed on scholar and our team explored algorithms like KNearestNeighbour, (Native) Bayes, and KMeans in building our recommender.

As a developer, some of the biggest time sucks can be: * Tracking down the cause of unexpected behavior. * Fixing data in production systems. * Answering user, or team member questions. * Running maintenance scripts, or other ad-hoc tasks.

It feels good and productive to do these tasks, but this approach does not scale. Your time spent developing new features, or improving existing features will start to suffer. Your team's feature output will not be consistent. Some weeks you may be swamped with support tasks which eat up your development time, and force you to context switch.

In this talk, I'll provide real examples of: * Support horror stories, and how a focus on admin tools helped the team recover. * Types of support tools and processes you can create from day one. * Elixir specific admin tools, and how to best leverage them. * Getting your team to adopt a support mindset.

Large-language models (LLMs) are leading a new wave of technological innovation. LLMs make it possible to develop and deploy increasingly complex and impressive applications. However, building LLM-powered applications also brings about a unique set of challenges and considerations. In this talk, I'll discuss the challenges of building LLM-powered applications, and why Elixir is the best choice to power the LLM-powered applications of the future.

At Savi Solutions, our video surveillance platform needs to be able to process billions of records per day for customers including Burger King, Little Caesars, 5 Guys, and more. As a result, we need a low latency, high performance, and linear scalable database, so we chose Cassandra. However, as our Cassandra cluster began to exhibit performance issues, degrade, and grow in cost, it was evident that we needed to make a change. Thanks to SQLite, Elixir, and the Beam, we were able to completely remove Cassandra from our stack, allowing us to distribute all storage workloads across existing application servers with minimal overhead at no cost.

In this presentation I will cover the strategies and lessons learned in setting up Cassandra and migrating to SQLite such as:

Cassandra and SQLite schema design for video streaming
SQLite partitioning strategies
Interacting with multiple SQLite database files via Ecto
Executing zero-downtime migrations
By the end of this presentation, you will have a better understanding of trade offs while using Cassandra and SQLite and their ability to pair with Elixir in building distributed, scalable, and fault-tolerant applications.