Get professional training on Nerves, LiveView, Broadway, Telemetry, and Nx at ElixirConf!
Choose one of four training classes for in-person training or take one of the online training classes on the Friday before the conference.
|Bruce Tate, Frank Hunleth
|Andrew Lewin, Britton Broderick
|Ethan Gunderson, Zack Kayzer
|Vanessa Lee, Herman "Boomer" Rogers
|Sophie DeBenedetto, Steven Nunez
Build a Binary Clock with Elixir, Livebook, and Nerves
Build your own binary clock with Elixir, Livebook, and Nerves. A binary clock is a puzzle for viewers that cryptically represents time using individual LED lights instead of digital numbers. Rather than building an LED circuit yourself, you’ll use a custom printed circuit board custom-built to power the clock. Building the clock in this way gives us a greater opportunity to explore layered design concepts.
Along the way, you’ll explore:
- Nerves Livebook to experiment with hardware.
- Read a data sheet to understand how data is transferred and represented on hardware devices
- Use Elixir’s binaries and for comprehensions to precisely build data
- Transfer data using a serial port interface (SPI)
- Build layered software to power your clock.
When you’re done, you’ll get to take your hardware home for more experimentation on your own time.
Bruce Tate is a kayaker, climber, programmer and father of two from Chattanooga, Tennessee. The award winning author’s dozen titles include Seven Languages in Seven Weeks, Designing Elixir Systems with OTP, Programming Phoenix, and Adopting Elixir. His love for teaching and computer languages led him to found Groxio in 2018, a teaching company that uses innovative techniques to teach developers Elixir. The serial entrepreneur has helped start three companies, and before Groxio, served as CTO for icanmakeitbetter. Bruce stays active in the functional programming community as a speaker, author, editor and conference organizer.
Frank has built embedded Linux-based software for products in many industries including medical, consumer, telecommunications and defense. He is a co-author of the Nerves project and maintains several projects used in embedded Elixir-based devices such as the Elixir Circuits set of libraries, toolshed, fwup, and erlinit.
Building Data-Driven Workflows in Broadway
Broadway gives us powerful tools for dealing with large data sets and creating robust data-processing pipelines. It comes packaged with rate-limiting, back-pressure, and real time visualization dashboards. By the end of this course you’ll be able to create and extend your own pipeline backed by a message broker like RabbitMQ, AWS SQS, or Kafka.
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.
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.
Britton is the CTO at Savi Solutions, building the team and tools to help small footprint brick and mortar owners and operators understand and improve their operations. He’s spent his career in startups, and has been involved in the Elixir community for the past six years.
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.
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.
Introduction to Machine Learning in Elixir with Nx and Axon
In this course, we will begin with an overview of machine learning which includes a brief history and introduction to the field. This provides a foundation for then distinguishing the different types of machine learning: supervised, unsupervised, and reinforcement; regression and classification; and prediction and clustering. The overview section is rounded out with a gentle review of statistics and linear algebra.
We’ll then move on to work with data. We will cover data concerns. What is the nature of the training data and what kinds of queries will be made? What do we know about the source of the data or the form of the solution? What is the goal of the prediction or estimation system? How will the answers to individual queries be evaluated? How will the overall performance of the system be measured? These questions will lead us into a discussion of models. How will the model be used to make predictions? What criterion will we use to pick a particular model? What computational process will be used to fit the model to the data and/or to make predictions? What is the best way to describe the data? Normalize it? What are the ways to create both test and training datasets?
Once we cover the data, we are able to move on to solving sample problems using machine learning. To do this, we will work with the Nx Suite: Nx, Axon, and Scidata. Nx gives us multi-dimensional arrays (tensors) and numerical definitions. Scidata provides scientific datasets. Axon requires an overview of neural networks before we tackle its API, inputs, weights, bias/threshold, and output. With these libraries at our disposal, we will create a model and optimize, train, and test data. Lastly, we will repeat those steps using Axon to experience the benefits firsthand.
What will you learn from your data?
Vanessa is a software engineer, avid reader, mother of three sons, and student of forensic genealogy. She’s been developing s/w since the 90s and is currently a Senior Elixir Manager to a magnificently talented team making the world better at Papa. Vanessa began working in the Erlang Ecosystem in 2011.
Herman "Boomer" Rogers
Backend Focused; Full stack enthusiast; AI Researcher. Always building something.
Over the course of the day, you’ll build out a real LiveView application and learn how LiveView works under the hood to support interactive UIs, how to build basic forms, how to make your forms more advanced with live uploads, how to secure your LiveViews with live sessions and LifeView lifecycle hooks, how to design layered UIs with components, how to test your LiveViews, how to support advanced client-side interactions with the JS commands API, and how to integrate PubSub into your live views for real-time functionality.
You’ll get hands-on experience by pairing up with your classmates to iteratively build out a set of features into a real LiveView app, interspersed with brief lectures and code samples from your instructors.
LiveView empowers developers and teams to be highly productive by keeping your brain firmly focused on the server-side. Backed by OTP, it brings a fast and fault-tolerant UI to your web apps and enables you to build complex interactive and real-time features easily. In this training, you’ll master the tools you need to be a productive LiveView developer.
Sophie is a Senior Engineer at GitHub and the co-author of Programming Phoenix LiveView. She is the co-host of the BeamRad.io podcast. She is committed to promoting Elixir education through weekly mentoring sessions, frequent blog posts, and by giving trainings and workshops. Historically, she is a cat person but will admit to owning a dog.