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.
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 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.
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.
Machine learning is a popular and rapidly growing field these days, but there aren't a lot of machine learning tools available in Elixir; some in the programming community have even suggested that BEAM isn't suited enough to the necessary number crunching to do serious machine learning work. Not so! In this talk, we'll walk through training a home-grown neural network written in Elixir on financial data from the S&P 500, then develop a Phoenix application to use that network to try to predict stock prices.
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.
The elixir of life is a mythical potion that supposedly grants the drinker eternal life and eternal youth. This elixir was said to cure all diseases. Alchemists in various ages and cultures sought the means of formulating the elixir. Today, thanks to José we can all use Elixir, and once you have tried, it's hard to stop. Why Elixir is so addictive? How is it transforming lives?
In this talk we will take a fun peek at the development of Elixir, and remind ourselves how it all started. We’ll join a whistle stop tour through the years from inception, learning how both the language and the community got to where we are today. We’ll take a closer look at some examples of how elixir has transformed the lives of those who have jumped in with both feet. And finally we’ll take a cautious but brave look towards the future, what opportunities might lay in the road ahead.
I would like to present a brief overview of the variety of tools available for visual reasoning about concurrency patterns, ranging from Erlang/OTP (Observer, erlyberly) through Elixir ecosystem (visualixir), to the toolset available for other concurrent platforms like Go (gotrace, streamtools). The second goal is to showcase a proof of concept for a visual tool that extends the feature set of the aforementioned ones, with a strong focus on specific Elixir abstractions (like GenStage + Flow), rather than concurrency primitives.
Successful mobile games have huge amounts of simultaneous users, which requires a scalable server in the backend. Getting featured in a store can also cause a rapid rapid ramp-up, putting even further pressure on the scalability of the backend. In this talk I'll present how Ministry of Games is tackling the scalability problem with distributed Elixir. I will cover how our system is implemented in Elixir as well as some practical aspects of deploying the Elixir server to a Kubernetes cluster.
Erlang's pg2 module provides distributed process groups and is a key technology underlying Phoenix's default PubSub adapter, which powers the Channels API that we know and love. Together, we'll take a guided tour of pg2's capabilities and see how easy it is to add distributed features to your own applications. Along the way, we'll dissect pg2's internals to see how the surprisingly short Erlang implementation can be accomplished in Elixir, while uncovering other primitives that make distributed Erlang so powerful. It's time to learn just how easy it is to tap into everything distributed Elixir has to offer!
With Phoenix 1.0 out recently, it's time to look ahead! Together, we'll outline what's next for Phoenix 1.1, then explore some exciting new features that take Phoenix to another level of modern web development.
Every new language or framework needs time to prove itself in production, for its early adopter to try, fail, iterate, and document what they have learned. Elixir and Phoenix can leverage the 30 years head-start of the underlying Erlang platform, but for newcomers to the platform it is not always easy to find and apply Erlang best practices. This talk explores some specific security-related aspects of Elixir, Phoenix and the Erlang VM, through practical demonstrations and use-cases. Topics covered include: use of Erlang's 'ssl' module, distributed Erlang, and VM hardening against DoS attacks.
The purpose of this talk is to make people familiar with some of the Erlang/Elixir specific security considerations. It is focussed on those things that may surprise people coming to Elixir from other languages, and therefore skims over common attack patterns (XSS, CSRF, SQLI, etc.) and their mitigations.
Anyone planning to deploy an Elixir application, with or without experience in deployment/security using other languages/platforms.
Bram is a system architect and security advocate at Cisco Systems. His work focusses on massively concurrent back-end systems for IoT/IoE applications, preferably built using Erlang/Elixir, as well as PKI-based security solutions for such environments. He has previously built/designed API servers using Ruby on Rails, as well as VoIP soft switches in Java.
00:00 Luke Imnoff: Decompiling .Beam Files
04:54 Fernond GalianaL: GraphQL
10:52 Dave Thomas: Code Like its 1999
19:25 Robert Beene: Talking to the Machine
26:10 Powell Kimmey Elixir Maths
It is the story of the birth of a quadcopter built using a 3D printer, a Raspberry Pi 3 and some Elixir magic. I will begin from the genesis of the project up to a flying drone. Expect some code, some hardware and some 3D printing time-lapse.
Can you have one and only one process consistently in a distributed system using elixir? :global, :pg2, something else? What about network partitions and stuff? Let's build and test some examples.
Chris McCord is the creator of the Phoenix framework, and author of Metaprogramming Elixir and Programming Phoenix. He spends his days crafting OSS and web applications at DockYard. His current interests focus on new web technologies, distributed programming, and teaching others the tools of the trade.
Setting up Ecto outside of Phoenix is really simple and can be a great way to get started learning about Elixir. In this live-coding presentation, we will set up Ecto in a test project and dive into some of the great things about Ecto and how to use it.
You may have heard about Phoenix and Elixir. It is a language and framework that give you performance without sacrificing productivity. Learn why Phoenix is a great choice for Rails developers and how you can introduce it into your organization.
The best way to get better at code is by reading other's code. It just so happens that Elixir is the best language for reading other people's code. We'll dive into some examples of popular libraries to see how the experts do it.
Have you always wanted to contribute to an Open Source project, but you're not sure how? The Elixir and Phoenix Framework communities are a great place to get started. In this talk you'll learn how to navigate the ecosystem, avoid missteps due to unwritten rules, find something to work on, and make your first contribution.
We'll start with the easiest things you can do, (ask a question! fix a typo in the docs!) move on to creating a bleeding edge project using the master branch of Phoenix so you can try out your changes, and go all the way through to building Elixir from source and patching the language itself.
"Programs that write programs are called metaprograms. They occupy the space between your problem and its solution. When used haphazardly the results can be confusing and cryptic. But when used wisely, they simplify that space and make it possible to solve hard problems in elegant ways.
Elixir embraces metaprogramming. In fact, it's fundamental to the implementation of the language itself.
This talk will answer questions for you such as:
When should I write a macro?
What is quote and unquote and when do I use them?
When and where does this macro code execute?
Macro.prewalk? What does this have to do with macros?
Along with some practical examples.
What's more astonishing is how approachable (and safe!) Elixir makes this complex subject. With this solid foundation, your code will be writing itself in no time!"
In this talk we'll build a custom visual programming language that compiles down to Elixir modules. The language will be focused on generating chatbots atop an XMPP server, but the concept more broadly involves building a Rules Engine that generates runtime-configurable output based on input documents. We'll define an Abstract Syntax Tree for a custom language, a compiler that translates that AST into Elixir modules, and a UI for building the AST directly (i.e. no parser - this is not a text-based language). We'll also walk through the supporting web application that handles storing the AST as it's built.