Keynote - 23.5 Days with Elixir
In preparation for my talk I've decided to program only in Elixir for the next 23.5 days.
I'll present my experience as a total newby to the language - what do I like, what do I dislike, what did I have difficult understanding? What took me a long time to fix? - What's good what's bad?
Elixir 1.3 adds new built-in types for date and time.
Hear about the considerations behind them and how they can improve the quality of your data and software.
When should you use a NaiveDateTime instead of a DateTime? Find out the what best practices are for all the new types. Be it with Ecto, with Phoenix or in Elixir in general.
The Elixir eco system is moving fast. So fast that we sometimes look to how we did things in other languages to inform what we should do in Elixir. This is a good starting place but ultimately does us a disservice. Let's take a look at how to TDD a web-based API in Phoenix with a suite a of tools that have been optimized for the "Elixir Way"
This talk will cover the current state of releases in Elixir, where things are headed with exrm, and how releases are making their way into Elixir itself. We will also see how releases fit into the current deployment landscape with the proliferation of containerized infrastructure; and approaches to deploying clusters of nodes with releases. I'll cover the approaches I've taken at work, lessons learned, and tools that can help.
Interoperability in Elixir
Dealing With the World Outside of the Beam
Ports, Nifs, and Interfaces, Oh my!
Elixir is an incredibly powerful language that sits on top of the battle tested and reliable Erlang ecosystem. This power is a big reason I am excited about building applications in Elixir. It enables us to write more of our application's stack in Elixir itself--especially compared to previous languages I have used.
Still, not everything can be written in Elixir. Sometimes you have to interact with the outside world, other tools, the operating system, or other code bases written in a completely different language. Thankfully, Erlang, and by extension, Elixir received a ""plays well with others"" award in kindergarten!
The Erlang ecosystem gives us several tools to work with other systems, processes, and code bases. In this talk, I'll cover the basics of each type of interoperability, as well as the pros and cons of each. These include:
Nifs: powerful native extensions
Ports: allow external programs to be treated like any other Erlang process
Jinterface: gives us interoperability with the Java Virtual Machine
These tools enable us to tap into the power of other ecosystems and make it easy to fit Elixir into our existing systems. This can be an excellent way to introduce Elixir into your organization and solve problems well-suited to Elixir.
Learn how naively copying a grammar file from one parser generator to another won't work. Go back to the beginning and learn about lexers vs parsers, but discover that the power of interpolation changes the computational complexity and forces the lexer to be a push-down automata instead of a finite-state machines and how this maps to Erlang implementation of the tokenizers in native Elixir.
Understand that there are different types of parsers and what each of their names mean. Learn why some of the Ruby-ish feature of Elixir's syntax (like no parentheses function calls and do block) favor some parser types or others and why this complicates, writing the intellij-elixir parser.
Learn how intellij-elixir uses Elixir and JInterface to check parser equivalence and found bugs in native Elixir.
Slides (Viewable): https://kronicdeth.github.io/the-road-to-intellij-elixir-1.0.0
Slides (Source): https://github.com/KronicDeth/the-road-to-intellij-elixir-1.0.0/tree/gh-pages
Project (Source): https://github.com/KronicDeth/intellij-elixir/tree/v1.0.0
Knowledge share about building "touch typing glove" with Arduino and Elixir.This talk is about my journey from research, choosing tools, making flexible tiny pressure sensors, plugging them into Arduino, reading information from Arduino to the server running Elixir, rendering result in the browser.
We'll live-code the game of Tetris from scratch, culminating in a browser-based tetris game that multiple audience members can connect to and control collaboratively.
- Elixir beginners through intermediates
The goal of this talk is to provide new and existing Elixir programmers with knowledge on how to get their application into production and, once it's there, how to tune it for scale.
Chris McCord is a programmer with a passion for science and building things. He spends his time crafting the Phoenix Framework, working with the fine folks at DockYard, writing books like Metaprogramming Elixir, and teaching others the tools of the trade.
Rewriting a Ruby application in Elixir
Dragonfly is a fairly popular Ruby library to manage file uploads and it includes a Rack server to serve those files back. This talk is a postmortem of a rewrite of this server component in Elixir, so that it can be used to process Dragonfly-compatible urls with improved performance. The talk will focus on the structure of the application, managing pools of workers, pattern matching to simplify complex Ruby logic, interacting with external tools (like streaming data back and forth from Imagemagick) and deployment considerations.
Target audience: Beginners - Medium
Starting out as a self-taught designer, learning front end development was a challenging climb – but going from front end to full stack with Elixir and Phoenix was easier than many would expect. Having built a well-tested Phoenix API from the ground up, I'll narrate the adventure of learning to think the ""Elixir Way"", and reflect on lessons learned.
In this beginner-friendly talk, we'll talk about overcoming the temptation of bringing over OOP practices into Elixir, harnessing the power of Plugs, techniques for testing, and more!
Elixir provides the joy and productivity of Ruby with the concurrency and fault-tolerance of Erlang. Together, we'll take a guided tour through the language, going from the very basics to macros and distributed programming. Along the way, we'll see how Elixir embraces concurrency and how we can construct self-healing programs that restart automatically on failure. Attendees should leave with a great head-start into Elixir, some minor language envy, and a strong desire to continue exploration.
Robots are fun. Programming is fun. Programming Lego robots with the visual environment... well, not so fun. This is the starting point for putting Elixir on the Lego Mindstorms EV3. It ought to be fun to do, but my son and I got lost in the visual environment when trying to do advanced things. After having created a simple EV3 library in Elixir, the fun started coming back. This talk is about how the EV3 Elixir library works and how to use it to make robot control software that is easy to write and understand. Among the key building blocks of Elixir are processes, and we will have a look at how to design things using lots of processes and how that makes things easier to work with. We start from conceptual architecture and end with elegant Elixir programs.
- Show how using lots of processes with asynchronous message passing create super solutions in Elixir.
- Inspire people to hack Elixir on Lego Mindstorms EV33
- Programmers curious about how to apply Elixir's processes in a good way
If you are a developer or company evaluating Elixir and looking for convincing and compelling reasons to do so, Bleacher Report is a case study in the fulfillment of the promises of Elixir and Phoenix. Iterative code samples will illustrate how our understanding and use of Elixir and Phoenix over the last two years have led to greater developer productivity and happiness and more reliable, responsive and efficient systems. With billions of monthly visitors and push notifications sent, Bleacher Report is in a unique position to show metrics that validate the aforementioned claims. Metrics will convincingly show that technical problems with fluctuating traffic problems have been eliminated through the adoption of Elixir and Phoenix. Finally, learn how we were able to train all of our former Ruby developers to become Elixir developers with minimal effort.
Evercam connects to thousands of IP cameras, pulling streams and/or jpegs. We first built the project using .NET and at a certain point we decided to rebuild on OSS. The main project was well suited to Ruby but the camera connections could not scale so we rebuilt that part to Node. Right now we're just about to embark on re-architecting to make use of Elixir and would be happy to share our experiences and learning with the Elixir community.
- People considering Elixir or interested in hearing how it compared in a real project to other languages.
This talk discusses the high availability challenge, an important property when building a system that needs to provide the service continuously. Based on my own experience in building an Erlang/Elixir powered system that constantly pushes the fast changing data to a few thousand of connected users, I will provide a high-level overview on how Erlang can help us implement continuously running systems, and back this theory with some real life examples. This is an introductory talk that targets mostly people new to Elixir and Erlang, aiming to explain why and how Elixir/Erlang can be beneficial. The talk is language agnostic with the focus on Erlang virtual machine rather than a particular BEAM oriented language. After the presentation, the audience should have a better insight on how highly available systems can be implemented, and how Elixir/Erlang can help in achieving that goal.
One of Elixir's greatest strength are macros, and everybody knows that. However, macros are just one way to access a powerful and magical land: the compile time™.
In the last few months, I've been working on a gettext implementation for Elixir (under the direction of José). This library does most of its work at compile time.
In this talk, we'll have a look at what crazy things you can do at compile time as well as some examples of taking advantage of compile time in the wild (and in Elixir itself). We'll see how moving things from the runtime to the compile time has huge benefits in terms of performance, without sacrificing clarity and expressiveness. We'll dive into Gettext's source code as the main example of this.
This talk will quickly introduce Ecto for unfamiliar audience members. Ecto recently underwent some major changes with improvements from the lessons learnt after it was first created almost two years ago. Eric will talk about some of the design choices made in Ecto and what sets it apart from traditional ORMs.
Elixir developers interested in Ecto
Phoenix is an Elixir web framework for building productive, reliable applications with the performance to take on the modern computing world. Together, we’ll review what makes Phoenix great and how it uses Elixir to optimize code for performance – without sacrificing programmer productivity. Along the way, we’ll see neat features like live-reload and generators and how Phoenix’s realtime layer takes on the modern web.
We have built backends for three games in Elixir. Going to talk about what we learnedand how we did these. Also share a bit about our journey to using Elixir/Erlang.
Learn about working production systems. Learn about solutions used to build realtime PvP, singleplayer and a turn based games. How we deploy the servers.
Game developers, programmers, devops people.
Roope spent the last 10+ years building services, most of it for mobile games. Currently a Co-Founder and lead server developer at Grand Cru.
Starting with a brief explanation for why Elixir is an excellent choice for embedded systems, we will look at how to building a cool Elixir robot, using [Nerves](http://nerves-project.org). You will learn how to: * get started (often the hardest part) * structure an embedded OTP appplication * customise an embedded linux using Buildroot/Nerves * control your robot using an embedded web server * control your robot with [Slack](https://slack.com) You will leave this presentation with more than just inspiration; you will have an actionable plan to make something fun with embedded Elixir. You will also have a genuine stepping stone towards creating a robust and secure _Internet of Things_ product.
The audience should leave with a clear understanding of how to get started with embedded Elixir. It will be a practical, rather than purely inspirational talk.
Those with some Elixir knowledge, but no experience of using Nerves to embed Elixir.
Paul is a coder with 20 years experience (only a couple with Elixir, though). Paul has spoken at various conferences and events including RubyConf, The Naked Agilist, and guest lectures at Glasgow Caledonian and Edinburgh Napier Universities. Paul is now CEO of Cultivate Software. He was also part of the team that won the giant banana presented to Jim Freeze at Elixir Conf 2015.