Hands-on workshop for developers with no prior experience in OTP and Elixir, which aims at building a simple client-server architecture using Elixir/OTP and real tools like telnet or curl.
The workshop has several steps, each one requiring a short introduction followed by a programming exercise for the audience. If one gets lost, but would like to continue to the next step, they can switch to the next git branch. All branches will be published on github.com.
At the end of the workshop attendees will have a fully functional Elixir TCP server that can be tested using telnet or curl.
Participants may want to install Erlang runtime and Elixir before attending the workshop so that they can implement exercise themselves.
As developers, we know that we should use the right tool for the right job. While we may love Ruby, there are also many interesting technologies that may complement our favourite programming language.
This talk introduces Elixir, a programming language that is built on the legendary Erlang virtual machine. I will first give a quick walk through of the language, focusing on core concepts such as concurrency and fault tolerance - areas where Elixir shines.
After that, we will dive straight in to an example application to see how Ruby can exploit the powerful features of Elixir. More importantly, the audience would realise that there's more to Ruby than just Ruby.
It will be a fun ride!
Phoenix is an Elixir framework for building scalable web applications with realtime connectivity across all your devices. Together, we’ll take a guided tour of the framework, going from the very basics, to building our own realtime applications. You’ll see the framework’s foundations, core components, and how to use Phoenix to write powerful web services.
We’ll start by exploring the foundations of the framework in Elixir’s Plug library, followed by the core components of Phoenix’s Router and Controller layers. Next, we’ll review the View layer and build an application together as we learn each concept. We’ll finish by using the PubSub layer to add realtime functionality to our application. Along the way, attendees will see how to apply advanced features like router pipelines and plug middelware and receive tips on how to structure a Phoenix application for real-world services.
The audience for this talk is any Elixir or Erlang programmer looking to dive into Phoenix and learn how to build powerful applications quickly and easily. Attendees should have an introductory level experience with Elixir or Erlang and the ability to run Elixir on their laptops.
This talk will start with the basics of match types, sizes, units, and encodings. We'll then cover function heads and logical branching with a real life example of recursive parsing using pattern matching. Towards the end, we'll cover how to optimize binary matching for BEAM and get feedback directly from the compiler.
This talk is relevant both to those new to Elixir and those looking to learn more about how to tune existing code for BEAM.
You want to perform integration tests on your development computer. As part of testing, you want a 3rd-party sandbox server to send its notifications to your computer, but, alas, your computer is behind a firewall.
In this session, you will learn how to set up an EC2 instance managed by Phoenix to relay communications bidirectionally between the sandbox and your development computer. See how a Phoenix channel eliminates polling and how an Elixir distribution primitive sets up the channel through the firewall.
Elixir's strings and iolists enable great features, but do you understand them? Why is a string a binary, and what do the numbers in the binary have to do with Elixir's great Unicode support? What are iolists, and how do they enable efficient template rendering?
In this talk, you'll learn how to:
Understand the relationship between bitstrings, binaries, and strings
Properly compare and dissect UTF8 strings
Efficiently build string output to write to a file or socket
Come along for a magical journey 🌈🌠 into the bits and bytes that make these structures so powerful.
We will walk through the development of a voice survey application using Phoenix, MySql, and the open source Asterisk PBX. We will build a simple web interface to create survey questions and display the results of completed surveys. We will build an Asterisk AGI application that reads the configured questions to a caller and accept touch tone responses which will be saved for later viewing in the Phoenix application. We will then demonstrate the application.
Availability should be one of our major concerns when writing web applications, yet more often than not we ship code that is simply not resilient enough. Elixir and OTP provide powerful tools to improve resilience and increase availability: in this talk we'll look at how we can leverage them to provide continuous service even when our database is down. The talk will be a walkthrough of a refactor of an Elixir application with a Phoenix frontend, powered by PostgreSQL
José Valim, Elixir Creator, is a member of the Ruby on Rails Core Team and a writer for Pragmatic Programmers. Software developer for 8 years, he graduated in Engineering from the São Paulo University, Brazil and has a Master of Science from Politecnico di Torino, Italy. He is also the lead-developer of Plataformatec, a consultancy firm based in Brazil, an active member of the Open Source community and is frequently travelling and speaking at conferences.
Distributed graph processing systems are an important part of the modern data toolkit. Graph structures are a great way to solve a lot of problems, and distributed systems let us scale our problem size. This talk walks through how some of Elixir's features (including OTP, macros, and functional programming itself) can come together to simplify writing a distributed graph system. The result is Edgelixir; an early, work-in-progress, Pregel-based graph framework.
I started learning Elixir by creating a couple of simple libraries, and have never stopped writing libraries since. In this process, I learned a lot about Elixir and Erlang, open source, API design, extensibility, documentation, and people. I tried to distil all of this in a data validation library called Saul. In this talk, I will share my learnings and thoughts on the library side of software, showing off Saul as a practical example.
00:24:00 - It's all about Elixir! by Rene @rrrene
04:47:21 - GenRetry by Pete Gamache
09:46:16 - ???
13:35:14 - Mr. Schrock
18:30:24 - My Elixir App is Crashing more than my Ruby App! by ???
21:51:18 - Ratchet by ???
26:49:28 - The Tension Between Expendience and Correctness by Josh Adams
31:39:25 - Let me tell you a story by Ian Warshak
35:04:00 - Casey Rosenthal
38:50:26 - Elixir, Elm, Games and Cats by P. Krowinski
43:35:18 - You, Mix and Kube! by Fernand Galiana
48:32:22 - Mocks, Adapters and Microservices by ???
53:38:23 - This is my first... by ???
Introducing Elixir and/or Phoenix to a team is not without its challenges. New languages and frameworks tend to be tech debt heavy as developers learn and iterate. At Bleacher Report, weäó»ve had great success with training developers to use Elixir by focusing on application standards, community developed tools and consistent testing practices. As a result of these practices, our code reviews are more meaningful and developers are able to move between applications with relative ease. This talk will provide app standard suggestions, lessons learned and code review guidelines that will help your organization adopt Elixir and Phoenix and enjoy all of the immense benefits they bring without incurring the heavy tech debt that generally comes with new language or framework adoption.
Let me take you through the idea and realisation of vutuv. The fast and free LinkedIn killer.
Protocols are an important part of the Elixir language, and they play a key role in many of its prominent libraries. However, it's not always obvious how and when to use them. In this talk, we'll demystify protocols and see how to leverage them to solve real-world problems. We'll walk through some practical examples to see how protocols can solve a variety of use cases. We'll start with some simple examples and end with relatively sophisticated scenarios. We'll even dive into the Elixir source code to see how protocols are implemented on the BEAM. After attending this talk, you'll have practical understanding of protocols and the use cases they can help solve.
This talk aims to present the most important ideas behind high availability support in Elixir/Erlang. It is a medium to high-level explanation of tools and approaches that can help developers drastically increase the uptime of their systems.
About the speaker:
Talk given at Full Stack Fest 2016 (https://www.fullstackfest.com)
Elixir is a concurrency-oriented programming language built atop the Erlang VM. Its syntax is very Ruby-influenced, and it takes some great features from the Python world as well. In this talk, I'll provide a quick introduction to the language. I'll provide just a quick overview of the language syntactically, as well as cover some areas where it differs wildly from Ruby.
We all want to have performant concurrent code, but threads are such a pain. Who wants to deal with race conditions in their code?! In this talk we show a better way of doing concurrency, the Actor model. No, that’s not just for Erlang or Elixir, we can have it in Ruby too.
In this talk, we'll walk through the design of a collaborative music composition environment using Elm for a frontend that interacts with a Phoenix-channels based backend. We'll see how we can use the building blocks that Phoenix provides to allow us to build collaboration and persistence features to an Elm-based frontend and represent the frontend application's data structures and actions nicely in Elixir for persistence and transfer.
In this talk, we will explore how developers new to functional languages tend to gravitate towards old patterns, and the new patterns they can learn to replace these with. To give this context, we will review how one functional newbie converted an existing Rails application to Phoenix. The goal of this talk is to give a perspective of a newcomer to the Elixir of today.
Elixir: Power of Erlang, Joy of Ruby
I’m a language nut. I love trying them out, and I love thinking about their design and implementation. (I know, it’s sad.)
I came across Ruby in 1998 because I was an avid reader of comp.lang.misc (ask your parents). I downloaded it, compiled it, and fell in love. As with any time you fall in love, it’s difficult to explain why. It just worked the way I work, and it had enough depth to keep me interested.
Fast forward 15 years. All that time I’d been looking for something new that gave me the same feeling.
Then I came across Elixir, a language by José Valim, that puts a humane, Ruby-like syntax on the Erlang VM.
Now I’m dangerous. I want other people to see just how great this is. I want to evangelize. I won't try to convert you away from Ruby. But I might just persuade you to add Elixir to your toolset.
So come along and let me show you the things that I think make Elixir a serious alternative for writing highly reliable, scalable, and performant server code.
And, more important, let me show you some fun stuff.
This talk will be in dialog with Avdi Grimm's book "Confident Ruby". It will also be a distant echo of Kent Beck's book "Smalltalk Best Practice Patterns". We'll talk about what confidence looks like in code, and how to achieve it. We'll look at examples of non-confident code in Ruby, briefly look at how to make them less timid, and then spend quality time with them in Elixir.
Confidence is reflected in code which clearly states its intention. It means removing the clutter of conditionals and error handling which obscure meaning and flow. Elixir provides many language-level constructs to make confident code the natural path to follow. Pattern matching, multi-clause functions, guard clauses, and protocols all foster code confidence. Tagged tuples provide significant, non-nil return values, and structs provide a form of type system. We'll introduce each of these and show how they can work together to even greater effect. We'll work up to supervision trees, the ultimate trump card in confident Elixir code.
Let's look at a quick example involving inserting a new record into a database. In Ruby, we might use the ActiveRecord save method, which returns boolean true on success and false on error. This pushes us toward a branching conditional.
In Elixir applications, there's often the need to have persistent connections to external services such as TCP connections to database servers. In this talk, we'll explore how to build such connections in a way that takes advantage of some of Elixir's most appreciated features: concurrency and resiliency. We'll see how to make such connections concurrent, e.g., making them asynchronous or using pooling, and how to make them resilient by reacting to network failures and disconnections. We'll reserve some time to explore TCP connections in particular and talk about dealing with binary protocols.
After this talk, you'll be able to take advantage of the techniques I discussed to build connections to external services in your application or in libraries you're developing (database drivers are great candidates for these techniques).
This talk is directed at anyone who has just enough Elixir experience to be able to understand the language syntax and core principles (such as its concurrency models) and that is familiar with the basics of OTP (such as GenServers).
Andrea is a programming enthusiast with a soft spot for functional programming and beautiful code. He loves learning new stuff. He strongly believes in accessible culture and education and in open-source software. He's active in the Elixir community and uses almost exclusively Elixir for work purposes.
Elixir/Erlang systems are typically powered by thousands, or sometimes even millions of processes, which, in order to work together, frequently send messages to each other. To send a message to a process, we need to obtain its process id (aka pid). In this talk I'll present various ways of achieving this seemingly simple task. Drawing from my own experience in wheel reinvention and choosing inappropriate solutions, I'll discuss strengths, weaknesses, and caveats associated with each approach. After the talk you will not only be able to find your processes - you will also be able to select the best approach for each given situation.
To systematically present typical techniques that can be used in one of the most important task of almost every Elixir/Erlang based system.
Mostly people who are just starting to explore concurrency in Elixir/Erlang. More experienced programmers might also discover some useful tips.
Simpli.fi takes part in nearly two million and growing ad auctions per second. Each auction is for only a fraction of a penny; but at this frequency, such fractions can accumulate to tens of thousands of dollars in minutes.
Our real-time accounting system is built with a mixture of Elixir and Erlang. It achieves high throughput while servicing 25,000+ (doubling every 8 months) active ad campaigns worldwide. Our performance can be directly measured in dollar figures in real time. Downtime and inaccuracy are both immediately obvious and costly.
We wrote this application in Erlang and it has been in production for over two years. Today we do all new development in Elixir. I'll discuss the evolution of our approach and how the Erlang VM has proven a great fit for real-time accounting. I'll also talk about how we've revised our design and assumptions over the course of scaling ten-fold.