Addressing Network Congestion in Riak Clusters
| In high-scale distributed systems like Riak, an open source distributed database written in Erlang, the network can make or break system reliability and availability. In this talk, Steve will discuss an experimental work-in-progress aimed at alleviating network congestion effects such as timeouts and throughput collapse for Riak clusters under extreme load. He will cover the basics of Riak, explain what features of Riak can cause networking problems at scale, and then discuss some results of using a new Erlang network driver to try to address those problems. Talk objectives: 1. Discuss problems with TCP in clustered systems under extreme load, and present alternatives 2. Explore the design of an Erlang network driver that provides a non-TCP reliable protocol Target audience: Erlang developers interested in distributed systems, particularly clustered systems featuring heavy TCP usage |
| Game Analytics is building the next-generation analytics platform for the gaming industry. We want to make advanced machine learning available to even the small studios with just three guys in a garage. We want to have all the analytics in real-time. We're building a real-time stream processing analytical engine in Erlang. As data comes in from our customers games, we process it and make it immediately available to our customers. In this presentation we will present the challenges we're facing, the architecture we have come up with and some really clever implementation details. We're preparing for massive volumes of data and need to be ready when big customers start using our product. Come see the challenges we're facing and how we're using Erlang to build the next-generation analytics platform. Talk objectives: Show how our system works Target audience: Engineers, Architects |
| OpenTechSchool is a community movement of programmers and tech enthusiasts, who organize and host free programming workshops and tech learning events for people of all genders, backgrounds, and experience levels. Since it was founded in Berlin in April 2012, it was also established in Stockholm, Melbourne, Zurich, Tel-Aviv, Ramallah, Dortmund and Hamburg. And though these teams run the workshops and event independently they all contribute to the OpenSource Learning materials to be reused globally. OpenTechSchool is always interested in exploring more language, technologies and formats in which learning in tech can happen. The latest experiment being a full-time self-directed peer-learning programme, called Hackership, taking place in November in Berlin for the first time. More about about OpenTechSchool on http://www.opentechschool.org and Hackership at http://www.hackership.org |
| The BEAM is the standard Erlang implementation in use today. It was specially designed just to run Erlang. We will make a quick tour of the BEAM visiting the major sights to see what it looks like internally and how it functions. There will be no need of a towel on this short tour. Target audience: Developers and system architects who want to get a better understanding of how their applications will run. |
Implementation and Verification of a Consensus Protocol in Erlang
| Read-your-writes consistency is difficult to achieve in distributed systems in the presence of crashing nodes and network partitions. Consensus algorithms are a way to establish linearizability of operations and allow safe access to your replicated data. This talk will briefly introduce the consistency problems that arise in systems that rely on asynchronous replication and compare a few different solutions to this problem. Of particular note will be availability and operational concerns. After the brief introduction to the subject, the Raft consensus algorithm will be discussed enough to understand the rest of the presentation and the Erlang implementation. Once Raft is explained, the approach taken to implement the protocol in Erlang will be described with a focus on the consensus fsm itself and the tradeoffs involved in this implementation. The remainder of the talk will be discussion about verification using the Erlang Quick-Check eqc_statem behaviour. Talk objectives: By the end of the talk the listeners should understand why consistency is a non-trivial problem in distributed systems and the basics of the raft consensus algorithm. They should also have gotten an introduction to building and testing stateful distributed systems with Erlang Quick Check. The listeners should come away knowing what types of problems property based testing can find, and what it actually did find in rafter. They should also have a grasp of the the strengths and limitations of this method of verification. Target audience: Distributed Systems Developers and Erlang Developers |
Project FiFo - Building an Infrastructure Cloud with Erlang and SmartOS
| Project FiFo is an open source cloud orchestrations suite for SmartOS written from the ground up in Erlang. The talk will be split into three segments. Starting with a short introduction of Project FiFo the first segment will cover things such as “What is FiFo exactly?”, “What can it do?” and “How does it look?”. After that Heinz will talk about his experience using Erlang in the development especially the advantages and disadvantages of using Erlang in the process of creating Project FiFo. After all that is covered, in the third part, he will take the time to give you a deeper insight into one of FiFo’s major components “Snarl” and show of some of the implementation details. Talk objectives: The goal of the talk is to give a quick introduction of project FiFo and its functionalities as well as an insight into the development process using Erlang. Heinz wants to give a feeling for why Erlang works so well for his case and where it’s benefits really start to shine. Finally he’ll go in depth with one of FiFo’s major features. Target audience: People interested in cloud computing, in distributed systems, riak_core & friends and/or SmartOS / Solaris |
Real-Time Card Payments in Erlang
| Card processing is an industry requiring backend systems of a certain type. Much like telecom infrastructure, it's expected to deliver 24/7 all days of the year. Response times, scalability and fault-tolerance are critical elements in a successful backend system supporting real-time card transactions. What could be a better choice than Erlang? At SumUp we enable card payments using mobile devices. When a purchase is made through our android or iOS apps, our Erlang backend handles the card processing. Fault-tolerance is our top priority. Downtime is out of the question. At the Munich Erlang Factory Lite 2013 we presented the first generation of the SumUp Erlang Payments backend. This talk continues where the previous talk ended, and presents SumUp’s second-generation Erlang Payments backend supporting both E-commerce and EMV (chip cards) payments. Enabling EMV transactions introduces new types of complexity at the server-side, which together with experiences from our first Erlang backend, resulted in a new design. We’ll discuss Erlang node & application design, financial protocol implementation in Erlang and fault-tolerance in context of real-time card payments. Talk objectives: Inspire use of Erlang in critical financial systems. Target audience: Developers and other professionals interested in mobile payments. |
Systems that run Forever Self-heal and Scale
| How can we build large self-healing scalable systems? In this talk I will outline the architectural principles needed for building scalable fault-tolerant systems. I'll talk about building systems from small isolated parallel components which communicate though well-defined protocols. Programs will have errors in them and will fail so I'll talk about detecting and correcting errors at run-time. Programs will evolve with time, so I'll talk about how they be changed while they are running. I'll talk about Erlang and how it relates to these architectural principles. |
Taking the printf out of printf Debugging
| Debugging a realtime system is hard, especially if the bugs only appear on a live system. Debuggers cannot be used, and printf debugging is often deemed too risky. The Erlang runtime offers a way to do on-the-fly instrumentation on the function level through the erlang:trace/3 function. This talk will discuss the trace BIF and how to use it. It will also describe redbug, a user-friendly and safe interface to the trace BIF. War stories will in all likelihood be offered. Talk objectives: Describe the Erlang tracing functions and how to use them. Target audience: Developers and ops people, especially those working on large, embedded, real-time systems. |
Travis CI: The Smallest Distributed System
| Even in its smallest incarnation, a distributed system is bound to fall prey to network partitions, data arriving out of order and eventual consistency. The more data pushed through the system, the more painful it gets to ignore these pitfalls. At Travis CI we had to learn the hard way that anything can fail at any time and that our chance of fixing it is to accept that and to rework our system to be more resilient to failure, going back to solutions that turn out to much simpler than our initial approaches but that required rethinking all parts of the application, from the code that runs tests up to the user interface that tails build logs as it's streamed from the build process. The lessons learned are surprisingly simple and they turned Travis CI into a system that we can grow with a lot more confidence than initially. We took it from a a single, monolithic application, to a distributed system. Talk objectives: This is the story of our failures and what we learned from them. Target audience: Distributed systems geeks |
What can Elixir do for writing DRY (Don't Repeat Yourself) Code for Beam VM?
| This talk will focus on the Elixir programming language and its new usages from the viewpoint of a one-year user. I used Elixir in university and personal projects as well as at work and discovered that Elixir as a language has more potential than it first meets the eye. It can be used as a new method to program for the Beam VM. This will not general be overview, but rather focussed on several strengths, which can be especially interesting for actual projects. I will demonstrate how we can simplify Erlang code and make it both more efficient and less boilerplate (more maintainable). For this purpose I will use code samples from the Erlang documentation, open source and actual projects. Talk objectives:
Target audience: Erlang beginner and intermedia developers |
| I claim we are evaluating systems based on the wrong metrics in general. We, as software programmers, forget to ask the right questions and thus we build systems wrongly. We focus on "queries" or "bandwidth", entirely. We benchmark without regard to statistics. And we pick tools based upon our flawed results. In this talk, I look at different metrics and tie them to Erlang. In particular, the crosshair is aimed at areas where Erlang excels. I touch upon how to quantify before we build systems. And I hope to spark a debate on other areas of writing performant programs. Talk objectives: The goal of the talk is to extend the vocabulary with which we speak of Erlang and what it is good for. In particular, I will touch on the concept of performant systems and what that means in practice. Target audience: The talk is suitable for beginners as well as intermediate programmers. More experienced people may learn a thing or two. |
