QuickCheck, our testing tool for automatically generating tests, has a long track record of nailing serious and hard-to-find bugs and boosting quality, in software like dets (part of mnesia), Riak, and the embedded software in cars. QuickCheck is written in Erlang and can be used with Elixir, but... can we instrument Elixir code to find race-conditions with PULSE? Not until recently. Now we have an Elixir native interface to access QuickCheck. In this talk, we present QuickCheck and this interface and show how race-conditions can be nailed down.
Target audience: Elixir developers
This talk is about Elixir – a functional, meta-programming aware language built on top of the Erlang VM.
I introduce some of Elixir's more interesting language features. Then I will demonstrate some of the features that Erlang gives Elixir for free, such as the OTP framework, that let's you build fault tolerant and distributed systems.
So come along and join me to experience programming joy.
Bold Poker is a Phoenix-based web application with a Elixir game server. iOS and Android clients connect to the using WebSockets.
We give a short introduction to OTP releases and talk about what can be done in order to use releases without having to manually write app upgrade files.
We talk about how we use our open-source Erlang and Elixir deployment tool edeliver. Edeliver is a deployment tool that uses OTP releases to deploy both our Elixir Gameserver as well as our Phoenix web app.
Elixir is an elegant and powerful language. This makes the Raspberry Pi a usable server for Elixir Applications. What would happen if we had a cluster of Raspberry Pi devices? Can Elixir and OTP help with the distribution of the application? What would you do with a 16 core and 4 GB of RAM machine?
I’ll explore different techniques to deploy to a Raspberry Pi Cluster and how we can use the Elixir processes to balance the load between the devices.
Elixir (and Erlang) are often talked about as ""highly scalable"" languages. This talk will explore the ""other end of scalability"" - Elixir for the Internet of Things.
You will learn how to use Elixir with Nerves to build a small, powerful Elixir-based embedded system that boots in just a few seconds on a Raspberry Pi.
You'll also learn a lot about shipping real world products using Embedded Elixir.
Topics will include:
Using Elixir and Nerves to build production Internet-of-Things (IoT) devices
Advantages and tradeoffs in using Elixir (vs C) for embedded systems
How to explore these technologies with inexpensive devices like Raspberry Pi or Beaglebone Black
Live build, from scratch, of firmware for an Elixir embedded device
Managing the complexity of the cross-compile build environment
Remote debugging of IoT devices
Handling firmware updates safely and securely
The complexities of network configuration in IoT devices
Why Elixir is so suited to IoT
At Rose Point, we've been using Elixir with Nerves to build embedded systems for a couple years now, and we've shipped two commercial products based on the technology, with more in development.
We love this technology and believe it is an ideal platform for many Internet of Things devices. I'm excited to share our story with you.
Dave Thomas is a programmer, one of the founders of The Pragmatic Bookshelf, noted author of The Pragmatic Programmer, Programming Ruby, and Programming Elixir, as well as many other books and articles.
My analysis of the state of software, the trends affecting us, and why I've chosen Elixir & friends as my stack for the next 10 years.
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?
Processes in Erlang / Elixir resemble objects in many ways. Some even argue that Erlang processes and the Actor Model are a purer form of object-orientation. The Elixir community has a large contingent of Rubyists that have extended many of the core values (and joys) of Ruby into the world of Elixir. This talk exposes some of the reasons why while providing a starting point for further learning
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.
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"
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.
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.
José Valim is the creator of the Elixir programming language and the Director of R&D at Plataformatec, a consultancy firm based in Brazil. He is author of Adopting Elixir and Programming Phoenix as well as an active member of the Open Source community.
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.
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
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!
Dealing with money should be easy, because crunching numbers is the most basic thing that every computer can do. On the other hand, the cost of a mistake may be quite high. I am going to discuss what properties does a financial system need in terms of CAP theorem and how does using Elixir language fit into the problem domain. The talk will cover handling rounding errors, designing APIs that gracefully handle network and hardware failures, and usage of "let it crash" approach in the design. It is also a case study of using Elixir in real life. Lets discuss Elixir and money!
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.