Ecto is a library for connecting to relational databases in Elixir. It's the default database library that ships with Phoenix, so many developers first encounter it there. But Ecto is a large library with a lot of parts, and it's easy to feel confused about what it can do, and how to use it effectively. If you're new to Ecto, or just want to get a better handle on it, this workshop is for you.
You'll get a guided tour of all the main components of Ecto, and build up your skillset one step at a time. We'll start by looking how Ecto implements the repository pattern for data access, then learn how to write queries using Ecto's elegant but powerful query syntax. We'll then create schemas to convert database records to and from Elixir structs, and learn how to use changesets to help manage updates to those records safely and reliably.
We'll put it all together with a deep dive into associations: Ecto's mechanism for working with relationships between tables. We'll look at detailed examples of all the types of associations Ecto offers, and learn best practices for creating and updating collections of related records.
Along the way, you'll be learning in the most effective way possible: by writing code yourself. At each step, you'll be given exercises to reinforce what you're learning, and get Ecto's APIs into your fingers. You'll walk out with a solid grounding in how Ecto works, and you'll be ready to start working with it effectively and confidently.
Previously in love with Ruby/Rails, Zachary had his heart stolen by Elixir/Phoenix shortly after its initial release. Since then he has worked extensively with Elixir and launched multiple large and small applications while working as a senior software engineer for Infinite Red. He has a passion to help teach and share Elixir with others.
Phoenix channels and presence unlock a new class of web applications which can support millions of connected users and effortlessly send data between them. Features that were previously too costly to support or too complex to implement are now at your fingertips.
Learn how to make use of these exciting new features by building a real-time application step-by-step. You'll use Phoenix channels and presence combined with rock-solid OTP techniques. Along the way, we'll cover OTP basics through advanced multi-node communication, showing you how to leverage the best features of the platform for your ambitious applications.
Chris Freeze has worked independently developing gaming, web and embedded software and now works at Dockyard.
Touchscreen interfaces are all around us. They are used for digital signage, information kiosks, control surfaces, and more. Devices like these in the field can be difficult to maintain and often are running insecure, out of date code. In this session, we will learn everything we need to build, develop, and deploy devices using Nerves. This includes building a Raspberry Pi-based touchscreen device, learning the ins and outs of Nerves development, creating user interfaces with Phoenix, and interfacing with hardware. After everyone has built a working kiosk, we will go through the steps to maintain these devices in the field and securely update them as needed. This is a hands-on session and you get to take working kiosks back with you to extend, repurpose, and share.
Frank Hunleth designs embedded Linux-based software that can be found in products spanning the medical, consumer, telecommunications and defense industries. His work on high density VOIP switches in the 1990s eventually led him to discover Erlang. Since then, he has re-implemented Erlang design elements in everything from a cutting edge diabetic screening device at LKC Technologies to motion controlled UI frameworks at Hillcrest Labs. He started the open-source Nerves project to make it easier to use Erlang in a cross-compiled environment.
Whether you have experienced the awesomeness of developing with Elixir and Phoenix, or simply want to learn how to take advantage of modern multi-core CPUs, the concurrency that Elixir provides is a great start to amping up the performance of your applications. In this hands-on workshop you’ll be introduced to concurrent programming concepts and the methods for implementing these concepts in Elixir. At the end of the workshop you will have built a fault-tolerant, multi-process communication application.
Topics covered in this workshop include working with multiple processes, including Elixir specifics such as GenServers and Supervisors.
Rob Keefer is a co-founder and the Chief Scientist at Pomiet, a software development consultancy. Rob works with organizations to envision and develop web and mobile applications that promote peace of mind for users and decision makers alike. His Masters Degree in Human Factors Engineering and PhD in Computer Science give him a great appreciation for interdisciplinary teams working to solve complex problems. When he is not building systems that make people awesome, Rob enjoys distance running and cycling.
Elixir can be a demanding programming language to learn. People who are coming from object-oriented languages have new concepts to learn such as modelling programs in a functional way and working with processes and message passing. In this class
new Elixir programmers will get to lay a firm foundation. We'll learn to code with testing from the ground up, presenting all of the core concepts in Elixir.
We'll start with Elixir datatypes, including maps, structs, tuples, and other primitives. We'll move on to core concepts like using recursion, building higher order functions, composing with pipes, processes, and organizing that code into modules.
Once we're through those concepts, we'll build a chatroom on the concurrency concepts that you should know, and if we have enough time, using Erlang's OTP.
This is a hands-on course, we've learned that best way to teach these new concepts is with tests, and have students make those tests pass. This is a lab-focused workshop so come ready to to do a lot of programming and a lot of learning.
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.
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.
Phoenix Framework provides a powerful toolset for building future-focused web applications. Over a one-day training session we'll build a tool to view and share preferred conference sessions during multi-track events like ElixirConf. We'll use Elixir and Phoenix to authenticate users, generate profiles with avatars, view the conference schedule, pick favorite talks, and share personalized schedules between users.
Attendees will learn Ecto basics, how to add common functionality through hex packages, the role of contexts and how Phoenix fits in to umbrella applications, Phoenix resource routing, creating controller resources, and how to generate HTML views and and JSON apis.
Brian McElaney (or "Mac" as his friends and coworkers know him) cooks competitively, pretends to like parades, and feels that brunch should be protected by law. For over 20 years, has lead user-focused software teams building everything from medical device monitoring systems to foreign exchange trading platforms. With three years experience with the language in production he now works with a number of companies transitioning their existing businesses systems to Elixir and Phoenix.
Eric Meadows-Jönsson is a member of the Elixir team and an active member of the Elixir community being the creator of many libraries, including Ecto and the Hex package manager. Eric works as a Software Engineer at Cabify.
Developing a custom hardware/software embedded system can seem like a daunting or even impossible task. With Elixir and Nerves, you can quickly get started with a Raspberry Pi-based project and walk away from this one-day session with your own WiFi-enabled, video-streaming webcam and all the skills you need to customize it.
This session is beginner-friendly. That includes those who are new to Nerves, new to Elixir, or even new to working with hardware. Some programming skills will be required, but working code will be provided along with the hardware, so you only need to make changes that you’re comfortable with. It’s very unlikely that you’ll melt, damage, or ruin anything. ;)
Tim works at Gaslight in Cincinnati, OH building software solutions with Elixir and Ruby and is a member of the Nerves Core team. While he spends part of his time as a lead investigator on crimes against Elixir, he also concurrently perpetrates crimes against Elixir. He has yet to catch himself.
Greg is a father of three, husband of one, and member of the Nerves core team. He loves to help new people get involved in the Nerves community, whether by making the tools easier to use, writing documentation, answering questions, or giving presentations.
Nhu fell in love with Elixir two years after its first released. She hasn’t stopped thinking about it since then. Along with Elixir, she has also written Ruby, Java, and Clojure code for small startup with less than five employees to multi-million dollar companies with more than thousands of developers. She loves to share her knowledge. Nhu is currently an instructor at Zipcode Wilmington. She loves coding, fresh bake cookies, and puppies (not always in that order).
I’m in a constant state of wanting to make the world around me bend to my imagination. At one time I wondered how hard it would be to start my motorcycle from my phone. Rewiring the motorcycle and writing an interface was easy, but connecting it all together proved to be a challenge. A challenge that would define my career. That invisible, often impenetrable layer in the air between all the hardware in the world has become my stomping ground. Hardware is hard, so I’ve been working on nerves to make it easy.
Paul is the Delivery Director and co-founder of POMIET, a healthcare systems consulting company. He brings sharp focus to defining and leveraging processes for both POMIET and client organizations. He leverages over twenty years of experience towards continuously learning, modifying, and applying to over 40 engagements/projects with software craftsmanship, agile and lean practices.
Attend this intensive two-day workshop to discover how to add GraphQL's flexible queries, mutations, and live data subscriptions to your own production applications. Elixir's the perfect platform for building robust, declarative GraphQL APIs, and you'll learn directly from the co-creators of Absinthe, the GraphQL toolkit for Elixir (and the co-authors of a recently published Pragmatic Bookshelf title on the topic).
You'll start from GraphQL's core principles, building a GraphQL schema from scratch, learning how to model a domain from the ground-up, and using GraphQL's built-in introspection capabilities to power a host of useful tools. You'll go beyond the basics, learning how to use Absinthe's middleware and phase extensibility to expand its capabilities. You'll focus on key production topics like performance, security, and new service aggregation capabilities that help you provide a common, GraphQL API across databases, your umbrella apps, and external microservices.
Bruce Williams is a polyglot technologist, speaker, and writer interested in everything from learning type systems and writing parsers to designing UX. He is the CTO of CargoSense, a logistics intelligence company committed to the Elixir open source ecosystem, and the co-creator of Absinthe, the GraphQL toolkit for Elixir.
Ben Wilson is a full-stack developer and leading member of the Elixir community as an open source maintainer, contributor, and conference speaker. He is a Principal Engineer at CargoSense and the co-creator of Absinthe.
Darin Wilson has been coding professionally since the days when you got help with coding problems by posting a message to a BBS over a 300-baud modem. Over the years, he's developed apps for banking, education, television, social media, and robotic arms. He is currently a principal software engineer at Infinite Red, a web and mobile application development company, and co-author of the book "Programming Ecto" soon to be published by Pragmatic Bookshelf.
The talk discusses an attempt at building a chatbot framework to deliver a rich conversation that is not just responses to commands. It is motivated by my master's research on using chatbots and natural language understanding to increase cigarettes smokers motivation to quit. This research is a collaborative project between engineering, psychology, and psychiatry, and it is powered by Elixir.
I'm a Computer Engineer and graduate student currently researching ways to automate behavioral change in smoking cessation through the use of artificially intelligent conversational systems.
Docker is the hot deployment technology across the industry, and many workloads are moving into cloud services. But for Elixir and other BEAM languages, there's some hesitation. Will containers work with stateful processes? What about hot code upgrades?
This talk will survey the sources of friction, real or perceived, between Docker and OTP. You'll discover techniques and tools that let your stateful Elixir applications thrive in a container-based cloud environment.
Daniel Azuma is a senior engineer at Google Cloud Platform, where he leads the Ruby and Elixir teams, building libraries and tools for users of his favorite languages. He lives with his wife in the Seattle area, and loves playing the piano, skiing, and having deep conversations with cats.
Sustainable test suites are long lived and effective at revealing bugs. However, the complexity of distributed cloud applications can make it challenging to have much confidence in system correctness. What testing practices are present in other functional languages? How is property-based testing related to model checking and formal verification?
We'll explore test frameworks and practices from other functional languages and academic sources in hopes of improving the way we test software in Elixir. We'll discuss tools as they exist today, as well as future tools being developed at Toyota Connected and among the Elixir community to empower developers to more efficiently test their systems.
Andrew Bennett is a polyglot programming enthusiast who enjoys using Erlang and Elixir to build distributed systems at Toyota Connected. He enjoys systems performance challenges, security and cryptography research, cooking, and robotics. Away from the computer, he loves spending time with his wonderful wife and their two little girls.
20 years ago Erlang/OTP was released as Open Source. And we have a lot to celebrate.
When we are first introduced to Elixir we notice that although it does an excellent job in simplifying and abstracting the thorny parts of the platform, every once in a while we encounter some straight calls to Erlang code. Why do we need them? How do they work? Fear not, for these are in fact the tips of amazing, old, beautiful icebergs.
This talk opens the box of Erlang/OTP and introduces some of the coolest built-in tools and libraries available in a standard Erlang/OTP installation, such as wx, ssh, timer, crypto and digraph. We will go over the most popular ones, without forgetting to stop by the most underground (and often underrated) ones, showing some examples of how they can come in handy in numerous occasions.
With about 10 years of experience in the software industry –7 of which as a consultant at Plataformatec– I have worked with a diverse and rich ecosystem of applications: from e-commerces to news portals and mobile APIs, from monoliths to microservices and enterprise integrations. During this long journey I've had the opportunity to learn a lot about evolving and maintaining applications to last.
Starting in 2016, PagerDuty started replacing a lot of its in-house custom monitoring tools and SLA calculators with off the shelf software. However, for one critical piece of monitoring that involved detailed business logic, could not be replaced with anything off the shelf. As a result, PagerDuty built its own highly available Elixir powered monitoring tool that used Kafka not only as a communication layer but also as a storage layer.
This talk is a story of how PagerDuty replaced a complex in-house monitoring tool with a rather simpler and more reliable/scalable one all by using Elixir/OTP.
Aish works as an Engineer at PagerDuty in San Francisco. He current works in building PagerDuty’s event intelligence platform often dealing with fallacies of distributed computing. His recent focus has been on Elixir/OTP and building event driven microservices using Kafka and Elixir. In the past he has worked as an early stage employee at HackerRank as well as a programmer at Goldman Sachs.
Much is said about the BEAM and how it’s GC per process is amazing, but sometimes memory leaks do happen! While developing Elixir apps I encountered such cases more than once, and this talk is about why that happens and what to do when it does.
Understanding how the Erlang runtime is different from other platforms we’re used to is crucial for solving such issues. How can you pinpoint what’s causing the leak? What are common reasons and solutions? These are the questions that will drive this talk.
I’m a software engineer with 10 years of experience, focused on web applications, from ops to backend. Currently working at Telnyx, a Chicago based telecom company with the mission of democratizing universal communications.
I’ve been in love with Elixir since I started working with the language in 2015, being an active member of Elixir Meetups in São Paulo, Brazil and spreading Elixir love all around :)
I also love science fiction books, movies and tv series.
Chatbots have gotten a lot of hype over the last few years. Now that the hype is dying down, it’s clear that there is a long way to go before chatbots are ubiquitous tools for interacting with our favorite services.
There are many tools to help you develop a bot, but when SmartLogic wanted to develop "The Incredible Baltimore Bill Bot", we couldn’t find anything in the Elixir ecosystem that suited our needs.
So we decided to roll our own.
In the process, we learned that a chatbot architecture based on our own cognitive processes was easier to develop for and more efficient in its use of resources.
Out of this attempt, I’ve developed a platform-agnostic framework for developing chatbots using Elixir and Phoenix. The architecture is loosely inspired by modern cognitive psychology and easy to grasp at a glance.
The result of this is a framework called Virtuoso (WIP) which I will describe in this talk. If you follow along you should have a working FB Messenger bot in about 30 minutes.
Justus is an Elixir Developer and AI Enthusiast from Baltimore. He's best known for his work on the Pavlok shocking wristband and designing single-page calendars. Accepting rap cypher invitations.
This talk is about 'architecting flow', which basically means 'organizing and structuring what is done when, where and by which actor' during the execution of our programs.
Making this top-level flow of data and responsibility obvious and comprehensible for the major parts of our applications is self-serving: When it’s easy to get the general flow of a program, it is easier to reason about changes, onboard new people into the team and communicate across teams.
In this talk, we’ll look at the spectrum of techniques to Architect Flow in Elixir. The audience will learn to reason about the trade-offs of each approach. We’ll look at the use of pipes and `with` macros in smaller programs. We’ll learn how to use the Token approach to create binding contracts between different parts of bigger programs. And we’ll discuss how to (and when NOT to) use metaprogramming to build custom DSLs for the most common use-cases in larger domains.
René has been fortunate enough to work as a professional software developer since he’s been 17 years old. Next to working at 5Minds IT-Solutions, he’s an Open Source enthusiast and the creator of Credo, Inch and ElixirWeekly.
Much of today's problems can be solved using machine learning algorithms, even really simple ones. More and more teams are incorporating their use into their product and solution offerings. While these algorithms themselves aren't the focus of this talk, Mathew will show how one may go about working with them in Elixir. From basic black box API calls, to using ports and NIFs, showing how to bring machine learning closer to the Elixir application.
Mathew is a software engineer at Toyota Connected where he helps to power mobility. He graduated with a computer science degree from the University of North Texas and enjoys all things tech. He's always learning new technologies to hone his craft, and lately, it's been all about machine learning.
We all know Elixir is fast and scalable, but knowing how to leverage its strengths can be the difference between a fast program and one unrivaled by other platforms. Whether you're reaching for Tasks and GenServers, or wrangling data with Ecto, understanding subtle nuances of each tool is the key to avoiding bottlenecks and writing efficient applications.
Starting from real-world scenarios, we'll explore various OTP tricks and concurrency patterns to drive maximum performance. Along the way, we'll see how features built into Elixir and OTP can apply to applications from small to large. We'll also navigate the unexpected pitfalls that come with cheap concurrency and how to safeguard from each trap.
Whether you're an intermediate or seasoned Elixir developer, you'll leave with some new performance tricks and a mental model for writing highly concurrent applications.
Alex Garibay is an Elixir developer at DockYard where he helps others develop exciting applications as well as spread Elixir knowledge. In his free time, he enjoys developing his own applications, spending time with his family, and eating Kansas City barbecue.
Using Elixir and OTP behaviors, infrastructure engineers at Optoro, Inc. monitor and interact with legacy infrastructure. This talk describes how SSHex, GenServers, Supervisors, and a Registry were used to monitor and interact with processes across multiple servers. It will also describe how the main library was created to be used across multiple projects (command line and a Phoenix web application).
Jeffrey Gillis is an Infrastructure Engineer at Optoro, Inc. He loves to learn new technologies and programming languages to solve difficult problems. He spends his free time with his wife and three children playing outdoors in their home state of West Virginia.
Many of us are initially attracted to Elixir because of its performance and fault tolerance. Make no mistake, these are stellar, but there are times when they are not the most critical requirements for our applications.
We’re going to take a look at a warehouse management system, originally written as part of a Rails monolith, for which data consistency and message ordering matter more.
That original system was deployed with Puma, forking multiple OS level processes on multiple nodes to gain parallel execution. That greatly increased the potential for multiple representations of an item in the system at any given moment. The result was an increase in stale data errors and inconsistent state.
As we rebuilt the system in Elixir, we turned these problems inside out. Stateful BEAM processes and their mailboxes allowed us to ensure that there would only be a single representation of each item in the system as well as order the messages each process receives. Throughout this talk, we’ll see how we accomplished this. We’ll also see how we handled some issues associated with this approach, like the cold start problem and keeping memory usage in check.
Lance is a member of the Phoenix core team and author of Functional Web Development with Elixir, OTP, and Phoenix. He is currently a Senior Software Architect at LeTote living in Portland, OR.
Elixir supports various ways to debug code: printing with `IO.inspect`, prying with `IEx.pry`, or using more advanced OTP tools like `:debugger` and `:int`. Choosing when to use these different tools can be confusing, and understanding how they work can prove downright intimidating.
Throughout this talk we'll peel back the covers on the more advanced debugging techniques and dissect exactly how each debugging tool can be used to examine our compiled code. None of debugging techniques leave your code the same as how it was running in production. Adding `IO` and `IEx.pry` calls obviously changes the code as you edit the source, but using the OTP debugger, either with `:debugger`, IntelliJ Elixir, or Elixir Language Server, or by adding new `break` points from the `IEx.pry` shell changes the module code being run.
Luke Imhoff will show how each type of debugging changes the code by revealing how `IEx.pry` and `:debugger` are implemented. You'll see why sometimes the debuggers can't reproduce bugs because the modifications to make the code debuggable also subtly changes the execution of the code by looking at changes to the bytecode and AST. Although the modified code never exists as source, we can recover the Abstract Syntax Tree (AST) of either the Elixir quoted form or the Erlang Abstract Code from the Dbgi chunk, but the Dbgi chunk ASTs aren't terribly easy to read, so we can use tools to decompile the code and translate it to Elixir or Erlang modules.
When looking at Dgbi code isn't enough, we can drop down to the Code chunk and look at the bytecode. The bytecode is a unique binary format, so once again we reach for for tools to render it, so instead of having to read machine code, we can read assembly. Looking at this bytecode also allows us to check if our high-level optimizations, such as module attribute reuse, compute variables once, and the order of pattern matching, have an impact on the code run by the VM, as unlike Dbgi, the Code chunk is actually loaded by the VM when running code without debugging.
Luke Imhoff has been writing Elixir since June 2014 and started writing IntelliJ Elixir in July 2014 after he couldn't find pre-existing support for Elixir for JetBrains IDEs he loved like Rubymine. While developing the plugin, he's found bugs in the native Elixir lexer and parser and the OTP debugger. He has 3 hex packages for JSONAPI: Alembic (validate format of JSONAPI), Calcinator (transport neutral JSONAPI, so you can use them for APIs and RPCs), and Retort (JSONAPI over JSONRPC over RabbitMQ for RPC). He hosts the Austin Elixir meetup on the 3rd Monday of each month.
The story begins on August 12th, 2015, not even one year after the Elixir 1.0 release. Phoenix is on version 0.16.1, Ecto callbacks haven’t been deprecated yet. My current boss pushes our first Elixir commit to Gitlab.
ElixirConf is happening on September 4th, 2018. Three years and 60 thousand lines of code later, the project is still alive, serving one million registered users. We’re now on Elixir 1.6 and Phoenix 1.3. Ecto callbacks are long gone and only few of us can remember them.
A lot has changed. We’ve made a lot of mistakes. This is a success story, though. Running the same project for such a long time gave us a unique opportunity to observe how the language changed and became really mature. This talk will try to share some of the lessons learned during this time and insights on how changes in the ecosystem affected our codebase.
Maciej is a developer at AppUnite where he's been using Elixir for about two years now. Interested in software architecture, distributed systems, data synchronisation and consistency guarantees. Currently writing his Master’s Thesis on CRDTs. A frequent speaker and co-organiser of Poznań Elixir Meetup. Started to love speaking even more after giving a talk at ElixirConfEU 2018.
I've been fascinated with the weather, unknowingly, for years. When I first
met my wife we would watch a movie during storms to pass the time.
Then when a gust of wind hit the house, I would turn to her and say "Did you hear that wind?".
Fast forward many years, we now live at a higher elevation with lots of wind. Storms
would roll in and wind would hit the house. A few seconds later I would receive
a message from my wife, "Did you hear that wind!". The trolling led me to dive
into the hardware space and luckily enough I would be able to use my favorite
The weather station is comprised of a Raspberry Pi 3, wind speed sensor, weather
proof temperature sensor, and a few other bits to make it all work. As this was my first attempt at a hardware hacking project, we can laugh (together I hope) at my mix ups and
take a peak at the many components. Elixir is used with Nerves to communicate with the hardware (1 wire Dallas and MCP3008 analog to digital), persist readings to an external API (Phoenix), and display with live updates via Elm.
The talk will cover the entire stack giving a look into a project that many commented that "they wish they could do" or "I have no idea where to start".
Frank Kumro is a software engineer from Buffalo, NY. He loves working with
Elixir/Nerves, playing with his kids, and working on his car. Enjoys long walks
on the beach, pina coladas and getting caught in the rain.
The concurrency primitives provided by Erlang are a perfect match to build stateful web applications.
Nowadays it is common to see stateless applications that depend on databases to keep any kind of state, but that adds some overhead.
Arguably, not using databases will create more problems than solve them. I will try to describe the trade-offs in building a databaseless web application and what are the different scenarios befitting such an approach. A web application that is independent of databases also has its own set of problems, specially when thinking about running that application in a distributed manner.
We've built such an application at uSwitch and I will walk you through the steps and different challenges we've faced while building it.
We hope that after hearing this talk you will be able to identify scenarios where databases won't be needed and thus write a stateless application.
I love coding, distributed systems and all the different challenges that come with them. I'm a Brazilian living in London trying to work and learn from the best.
This talk is a history of how GenStage became the perfect fit to a Video Watch Progress software.
In the beginning of 2016, we started to migrate a High Throughput Ruby Web API to Elixir. Starting with a single 1:1 rewrite, we did lots of improvements and in the beginning of 2018, GenStage was a great fit to deliver the best solution we could. We did load-shedding, back-pressure and lots of techniques using this powerful Elixir tool.
For more about this history, see the following blog posts:
Software Engineer professionally for the last 20 years.
OTP20 officially introduced dirty schedulers. In this talk, we'll cover why they're part of OTP and what function they perform. Using Rust NIFs, we'll compare schedulers and dirty schedulers to illustrate the trade-offs between scheduler types. By the talk's end, it should be apparent why dirty schedulers are part of OTP and how and when you should consider using them.
Ben is the software architect at Bleacher Report, co-author of Adopting Elixir and co-organizer of the Erlang Elixir meet up in San Francisco. In his free time, he's also programming in Rust, playing guitar, and building guitar pedals.
Client-side applications are expensive to make, difficult to maintain and practically impossible to account for all edge cases. We've gotten so caught up in the front-end framework fever that we haven’t yet taken the time to consider if there are better ways to achieve the goal of building rich user interactions.
Texas takes the Virtual DOM approach for updating the DOM with lightweight patches, but instead of calculating patches on the client, it does all the heavy lifting on the server-side bringing control back to the developer and keeping your source of truth closer to your business logic. The end result is faster initial page loads, less data over the wire, more flexibility in choosing your transport methods, graceful application degradation, and maybe the most attractive feature is the development speed increase you'll see when you come back to the server and stop struggling with client-side code!
Dan McGuire has been a software developer for around 5 years. He's most interested in how different tools can be used to solve people problems. Hailing from Nashville, TN he writes elixir remotely for Rentpath and loves watching instructional youtube videos before confidently breaking everything around him.
Elixir and Phoenix have unlocked a new world of responsiveness in our applications. Gone are the days of mashing the refresh button to see updates to data that frequently changes. You can send near real-time updates to every user on your site about every change that happens, but should you?
We’ll share some of the design questions we’ve learned to consider when deciding how and when to notify users of changes. When the session ends, you’ll have some design tools from real-world examples to ensure your users aren’t drinking from a firehose of updates or making decisions from stale data.
This session is co-presented by Bailey Miller and Tim Mecklem. Bailey creates amazing things as a designer at Gaslight (teamgaslight.com) and has written about her experience working with Phoenix from a front end developer perspective. Tim is a developer at Gaslight, where he builds exciting software and helps people build themselves. They have presented separately at conferences like Adobe Jam and ElixirConf, and this is their first time teaming up to show how design and development complement each other.
After years of work, I am releasing Scenic, a UI framework you can use to build UI directly in Elixir or Erlang without using a browser. Scenic can create small, fast, and robust interactive applications on Nerves devices, MacOS, Linux and more.
In this talk, I’ll give an overview of the framework, how it works and demonstrate it running in addition to connecting it to a Phoenix service to remote the application across the net.
After many years at Microsoft, where he founded Xbox Live, XNA and ran engineering for the Xbox One console, Boyd dived into the Elixir/Erlang community and is now focused on next-generation apps across both single-purpose and general devices.
We know that OTP is an important part of the elixir ecosystem. But why is it important and how does it work? How do we leverage OTP appropriately to build highly concurrent systems at scale. We will walk through the why and the how by building a crypto-currency exchange, and then adding load to the exchange to see OTP at work.
This talk will also provide context about crypto-currency and how the protocol is implemented - so that the audience has appropriate context for understanding building an exchange.
Anna Neyzberg is a San Francisco native who has done a lot of work in the ruby community in SF and currently sits on the board of RailsBridge. She has taken this community organizing experience and 2 years ago co-founded ElixirBridge in SF- an organization that offers free weekend long workshops, with the goal of creating an inclusive welcoming space for under-represented populations in tech to learn elixir. By day she works as a Developer at Carbon Five. When not in front of a keyboard, she is trying to get better at climbing rocks.
You have an application that works well on a single node, and you’ve heard that Erlang lets you scale out in a cluster. How do you go about doing that?
We’ll walk through the steps I took to turn ExVenture (a multiplayer game server) into a distributed application.
Starting with connecting nodes in development and production, to picking a cluster leader via the Raft protocol, and dealing with process groups to fan calls throughout the cluster.
Finally we’ll see some of the hurdles I encountered when spanning multiple nodes.
Eric Oestrich works at SmartLogic building applications with Elixir. In his spare time he works on ExVenture, a multiplayer text based game server. He also helps run the REST Fest Midwest unconference.
Coming from Ruby on Rails, the convention is to have a `User` model handle multiple aspects of an account such as login, logout, password reset, and email confirmation. While there is a temptation to bring that convention with us when building an Elixir application, we can do better by leveraging bounded contexts,
Ecto's embedded schemas, and `Ecto.Multi` to break these separate pieces of functionality into isolated chunks that are easier to maintain and extend.
Come on a journey with me as I take a large Elixir `User` module and break it down into smaller, focused modules. We'll employ a test-driven development approach and may even end up with a better database design for managing user accounts in an Elixir application.
For the past decade, Zach has been helping several companies solve problems with software written in a variety of languages and frameworks. Zach is currently a Senior Developer at Viget where he provides custom software solutions for a mix of companies including Dick's Sporting Goods, the Wildlife Conservation Society, and the Privia Health Group.
Elixir's code-generation capabilities require a sophisticated compiler with complex dependency tracking. Given such complexity, it is often unclear why sometimes changing a single line in a single file triggers the recompilation of 100 other files. This talk aims to clarify that.
Most of the content presented in this talk was "discovered" while struggling with recompilations of 500+ files in a 2000+ .beam file Phoenix app. We learned things the hard way so that you don't have to.
In this talk we are going to take a deep dive into what happens when you type "mix compile", why and when modules need to be recompiled, and how compilation behavior interacts with umbrella apps. You will learn how to "debug" recompilation problems, which tools to use, and how to avoid common pitfalls.
I'm a Brazilian software developer focused on backend, operations and databases, working with Elixir since 2015. I worked in companies both very large and very small. I'm also a frequent speaker in technology events in Brazil, and have spoken numerous times about elixir, both locally and abroad.
Currently, I work remotely for Telnyx LLC, a Chicago based company whose mission is to democratize global comunications.
When I'm not talking about software, I like to cook, make cocktails and dance.
Growing an application is hard. We started our app with the best of intentions and promised ourselves we were going to “design it right". However as the app grew, complexity increased, dependencies piled up, and changes that were once small now felt like slogging through mud.
Driven by the need to keep our sanity, we decided to apply ideas from Phoenix’s contexts and Domain Driven Design with the hope that we could put boundaries around the complex parts of our system and keep the code from turning into a tangled rat’s nest. This talk covers many of the lessons we learned along the way, including:
After applying these ideas to our codebase for almost a year, we’re eager to share our experiences and provide strategies you can use to tame complexity in your own applications.
Aaron has been developing software professionally for 10+ years and has been writing Elixir full time since 2016. He has been the technical co-founder for multiple startups and can only imagine the money he would have saved on servers if he had found Elixir sooner. Aaron enjoys clean code, refactoring and studying application design. When he’s not in front of the computer, Aaron enjoys cycling, camping and family road trips.
Hex is one of the few tools that virtually every Elixir and Erlang developer relies on, yet many people never get past deps.get. Hex can do a lot more to make you more productive, and is taking steps to proactively prevent issues (like leftpad) from ever happening.
I want to take you on a journey through this incredible piece of software, including some interesting features, the security measures taking place behind the scenes, and other interesting nuances that live deep in the source code.
I am a reformed graphic designer that got my start in web development 15 years ago. I have made a career in front-end development, PHP, Rails, and for the last year or so, in Elixir.
I am a contributor to hex and hex.pm and in my spare time I tinker with hardware projects.
Living in a vibrant Asian city can have its downsides, especially with regards to air quality. While buying the Latest and Greatest IoIT air filter can help with particulate matter in the air, there is little help with increased CO2 levels in your home, except installing and taking care of lots and lots of plants - an interesting challenge if you live in a high rise apartment building.
Armed with The Nerves Project and available literature on growing algae to remove CO2 from air, this talk will summarize the process of building and testing a basic "breeder" bioreactor that uses algae to create more fresh oxygen in the home. The ultimate goal of this project is to build a reactor that can self-sustain an "optimzed" state of maximum CO2 removal for a given reactor vessel size, with the aid of artificial light, and electricity.
David is a software developer who has spent the past five years focusing on building pragmatically in the IoT, "Gig Economy", and Education industries. After building his first Phoenix project in 2016, he has been hooked on bringing more functional programming into his production environments and tending to his herb garden when he's not out hiking.
I wrote the Elixir Behavior Tree library. This talk explores what a behavior tree is, how it is used in AI and robotics, and how it differs from decision trees and state machines. I describe how it relies on the Zipper Tree, emphasizing the technique of encoding logic into declarative data structures, and I will contrast my design decisions and implementation in Elixir against other mutable, non-functional languages that behavior trees are usually written in. I will pull it all together with a cool demo, iterating on a behavior tree AI that plays Battleship.
I am a polyglot and functional programing enthusiast, with a background in screenwriting, and a hobby of making web games. I have lived and worked in Denver, LA, Bristol (UK), and Seattle.
Our client came to us wanting to build a real time auction application for supplying fuel to ships.
This was exciting! We were going to be auctioning upwards of 1000 metric tons of fuel using Elixir and Phoenix! What could go wrong?
From the beginning of the project there was a hard requirement for auditing. Anything that happened in the system needed to be recorded. This lead us to the idea of Event Sourcing.
Event Sourcing is a way of ensuring all changes to an application's state are stored as a sequence of events. Those events can be queried, logged and used to reconstruct past states.
In this talk I'll cover the benefits and challenges with Event Sourcing and the solutions we came up with.
This project was both fun and challenging. I want share the knowledge that we gained from it, as well as our mistakes.
James was so captivated by development that he worked his way through one of his high school’s only two programming books. It focused on Pascal, and since he didn’t have the expensive software necessary to make Pascal run on his computer, he’d write programs by hand on paper then go back through the book to double-check his syntax.
James is largely a self-taught developer and got his start in technology when he joined Cincinnati Christian University’s IT department while still a student. Around 2007, he discovered Ruby and spent six months learning the language as he discovered the Cincinnati Ruby community. Eventually, he landed a full-time Ruby job at Meyer Tool, an aerospace company. In 2010, James became employee number one (after the co-founders) at Gaslight.
He lives in Amelia, Ohio, with his wife, two sons, a red Australian cattle dog named Mila, and Mastiff named Honey. While he considers programming both a job and a hobby, James also describes himself as a serial gamer and outdoor lover.
The developer stared at the screen in frustration and grumbled, "Example-based testing is straightforward. I pick a few inputs, and verify the output. I don't get property-based testing. How can I write a test if I don't know what the inputs are?"
Maybe you're like this developer. Maybe you're sold on the value of property-based testing. Maybe you're convinced that it will help you write effective specs. But where do you go from here?
Identifying properties to test is your next step toward property-based testing greatness. You'll learn what properties are. You'll gain strategies to identify them in your code. You'll see practical examples using StreamData, a property-based testing library. You might even start to view code verification in a new light.
You'll get the most out of this presentation if you have used example-based testing in any language. You'll go from "property-based testing looks awesome" to "I can do it!"
Michael is a senior software engineer at RentPath, currently working with Elixir. He got into programming by dabbling in BASIC and writing games for his TI-82 calculator. Michael entered the world of web development in 2007. A few years afterward, he discovered the joy of testing and TDD.
Suppose you have a distributed system deployed in production and you are on the hook for its uptime metrics. Having been there ourselves, we have come to believe that it’s essential for software developers to understand what guarantees a system provides, and to have a good picture of *how* it will behave under unfavorable conditions.
In this talk, we’ll outline the basic theory of safety and liveness properties; the link between modeling properties in your head and converting them into working PropCheck code; and showcase the results of applying our philosophy to example applications. You’ll see how ETS-based, Mnesia-based, and Phoenix-PubSub-based Elixir apps fare when in dire straits.
We hope to convince you that getting from zero to one in property-based testing in not that hard, and show you how to gain confidence in your Elixir application’s performance in production.
Rafal and Simon have spent the last few years building and running distributed BEAM systems in production, in various professional roles.
So your project has gotten popular. More funding, more traffic, more developers contributing code. Just SSH'ing into your production server and running mix phx.server & isn't going to cut it. Now the business requirements need the application to integrate with Service A but possibly run a second, almost identical, deployment that integrates with Service B. And part of the current functionality is a candidate for being shaved off into a separate product in the future.
mix phx.server &
In this talk I'll give a few ideas for structuring your umbrella project, running lots of tests quickly, and building and deploying flexible releases.
Jerel worked for a number of years as an independent contractor building software in the public safety, medical research, and agriculture spaces. He now uses his Elixir skills at Toyota Connected building software for car sharing around the world.
The GraphQL query language has been growing in popularity since it's release by Facebook in 2015. It gives servers more flexibility than REST and Elixir already has an amazing library supporting the GraphQL Spec - Absinthe! If our API adapts, so should the way we access the database, that's where Dataloader makes writing Ecto queries easy and less repetitive.
See how we can make a simple graphQL server with as little code as possible.
- It will be helpful to have a basic understanding of Phoenix, Ecto, and the objective of GraphQL.
Aaron is an adventurer of all things software. He came to Elixir from a Java and Node background to fall in love with the community and the functional coding style. Currently working for Corvus Insurance, Aaron writes primarily in Elm and Elixir while experimenting with game development in his spare time. Often found in his natural habitat of soccer fields located near coffee shops.
In this talk, I will share my experience and learnings about how I built a production-grade video chat system with Elixir and Phoenix.
My video chat app makes use of following features of Elixir and Phoenix.
How a Video Chat benefits with real-time features of Phoenix framework. In a Video Chat app, there are so many interactions which happen in a group, so you need real-time capabilities on your server.
How I used Agents to wrap the state, I need to talk to a third party server, how I used Tasks to perform certain operations, how I used GenServers for long-running features like Cache servers and recorded media file uploaders.
Instead of crashing, how we gracefully stop services. When users close tabs, other users in video chat should be gracefully informed that users have quit. I will cover, how we make use of supervisors and GenServers for the use case.
Third party media server has API and continually sends different events such as network is slow, user's video is unpublished or audio went off etc. We will see how I make use of GenStage's event handling to show user's feedback interactively.
We will see how Erlang's debugging tools come in handy when there is something wrong.
Anil was a long time Ruby developer, then turned Polyglot developer to do Node.js, Java, and Scala. For last 1.5 years, he is writing an Elixir Phoenix web application to build a team collaboration product. This product involves WebRTC and chat taking full benefit of BEAM's way of concurrency and OTP abstractions.
Anil loves to listen to world music. He is an avid reader. Anil is interested in solving problems with better software architectures and learning distributed systems.
While porting a project from Ruby on Rails to Phoenix/React, I’ve realized just how deceiving looks can be. “Ticket to Fly” focuses on finding solutions to unexpected challenges along the way. Specifically, we’ll look into working with images, including svg file parsing, and converting ruby methods to elixir by taking advantage of recursion and function piping.
Catherine Zoller is a software engineer in Boulder at Mojotech. Lately she spends her days working with React and Elixir. On summer weekends you’ll find her in the garden building a habitat for birds, bees & butterflies. When the snow flies (winter is coming) she spins yarn, knits socks, and programs in Elixir.