GenStage and Flow
José will explore the rationale and design decisions behind GenStage and Flow, two abstractions
that have been researched and now implemented for Elixir with a focus on parallelism and data processing.
The Evolution of a Chatbot
When he first started building chatbots, Elixir looked like a natural fit.
He was not disappointed.
What was going to start as a port of node's botkit turned into an up and down journey into finding the right abstractions.
This talk is about that journey and what has made jim adopt Elixir as his go to language for most of his current dev work.
Everyone's least favorite part -
how to pimp Elixir app releasing model?
Very few of us like to even touch deployment & release tooling - it has nothing in common with creating new, exciting functionality users are waiting for & it's getting dangerously close to usual border of developers' comfort zone: kingdom of infrastructure & sysadmins. Elixir conveniently provides us with a simple but sufficient toolset, so we don't have to torment ourselves too much,
but ... it appears that with some limited effort we can tune it up significantly, remove some limitations,
make it more fit for large data-centers (or cloud) & improve its overall flexibility & automation-friendliness.
Presentation will cover (but is not limited to) following topics:
- Dealing with deployment configuration (with Conform)
- Release packaging made better (with Distillery)
- Canning your Elixir app (with Docker)
- Dynamic clustering & service discovery for Elixir apps (with Consul)
Very basic design in
functional programming languages
Functional programming languages promise to be easier to test and easier to debug.
However, when learning the functional way we often try to translate our current techniques to another language.
This is usually not easy and the end result is far from those promises we've heard.
Early frustrations might even discourage from further learning.
In this talk Tomasz will show you two very simple patterns:
- Designing code around single data structure
- Dealing with impure parts of program like DBs, external services or IO
This should give beginners jump start for their first toy projects and further exploration.
What’s in your mixture?
Overview of Tracing Techniques for Elixir
The Erlang VM, that Elixir runs on, comes with very good support for tracing that is essential in the Elixir developer’s toolkit. However, people new into the world of the BEAM may be unconscious of what it has to offer in terms of tracing and it’s not that straightforward to use even for those of us who are somewhat experienced.
The presentation starts with a general introduction to tracing techniques available on the Erlang VM including so-called “run-time” and “internal” approaches. The main part of it, however, focuses on examples showing how to apply these various techniques to trace Elixir applications. Firstly, low-level techniques (BIFs, LTTng) are demonstrated as they form foundation of the other tools. At the end of the talk, higher level tracing tools are mentioned as well (Dbg, Visualixir).
All the examples are based on the Elixir application that one builds while going through the “Mix and OTP” tutorial that can be found on the official Elixir website so that this new know-how can be easily applied.
Extending OTP with custom behaviours
OTP is a wonderful tool that allows us all to develop robust, fault-tolerant applications. The standard behaviours like gen_server or supervisor are bread and butter of Elixir programmers. But what's beyond that?
This talk will explore the world where we need something more than a plain gen_server and a better abstraction is hiding right behind the corner. You will learn about special processes and the concepts of behaviours. Together, we're going to look into how a gen_server works and analyse couple custom OTP behaviours used in popular libraries to finally build one of our own.
How fast is it really?
Benchmarking in practice
“What’s the fastest way of doing this?” - you might ask yourself during development. Sure, you can guess what’s fastest or how long something will take, but do you know? How long does it take to sort a list of 1 Million elements? Are tail-recursive functions always the fastest?
Benchmarking is here to answer these questions. However, there are many pitfalls around setting up a good benchmark and interpreting the results. This talk will guide you through, introduce best practices and show you some surprising benchmarking results along the way.
Introduction to APIs.
Headers, authentication, gotchas
(json vs form encoded etc.) with examples in Elixir
Heard of APIs? Perhaps used one or two?
This introduction in to the world of apis & Elixir, is for you!
- Learn about different headers and how to set headers in Elixir
- Examples of potential gotcha's when working with ex: api's: versioning and data format
- Make a call to a real api, and authenticate yourself with basic auth, in Elixir