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.
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.
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.
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!"
This panel will discuss strategies for increasing Elixir adoption in your organization, and then take questions.
About Shanti: Shanti Chellaram is currently a senior engineer at Teachers Pay Teachers, with a year and a half of experience migrating a legacy PHP stack to Elixir. If she's not at a computer, she's trekking through the hills and mountains of New England.
About Brandon: Brandon Richey is an Engineering Manager at Greenhouse and a long-time web developer. He's been working in Elixir for over two years now, and has successfully adopted Elixir at four companies! When not working on building an amazing recruiting product at Greenhouse, he also is spending time working on the technical side of the Cured Foundation, programming hobby projects, and working on his art. He has a book on Elixir and Phoenix development currently in progress, slated for release later this year.
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.
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!
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.
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.
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
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.
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.
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.
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.
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.
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)
Let me take you through the idea and realisation of vutuv. The fast and free LinkedIn killer.
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.