Code BEAM STO 2018

At WhatsApp, Erlang has been our biggest technical “secret sauce” for building and scaling a very robust server system. In this talk, we go over remarkable benefits of using Erlang and speculate on what could bring Erlang superpowers to the next level. More details on website: http://codesync.global/speaker/anton-lavrik/

ForgETS is a globally distributed, replicated in-memory, database collocated with business logic. It allows WhatsApp to have globally replicated datasets with optional disk persistence collocated with our business logic, which provides zero latency data access allowing WhatsApp to sustain temporary network and server outages. ForgETS' design is based on Mnesia with additional support for: 1) network blips and subsequent auto reconciliation 2) explicit support for globally replicated datasets which enforces different replication/reconciliation rules across different regions 3) easier schema management allowing to user to add more servers into the cluster by means of configuration files updates More details on website here: http://codesync.global/speaker/mikhail-vorontsov/

Members of the Erlang and Elixir communities often receive the question: "why should I use this language?" The answer to this nuanced question remains elusive, because the answer is not primarily technical. This talk provides a history of functional programming, of Erlang and Elixir more specifically. It begins with Lambda Calculus, and charts a path to the present moment. This talk argues that the future success of Erlang and Elixir will be marked by how we learn from the history of functional programming. More importantly, this talk presents a strategy for increasing language adoption, which centers around community-building, based on real-world experiences and historical analysis. Osa's profile can be viewed here: http://codesync.global/speaker/osa-gaius/ Join us for our next functional and non-mainstream conference, Code Mesh LDN 2018 https://codesync.global/conferences/code-mesh-2018/

An update from the OTP team. More information can be found on the website: https://codesync.global/conferences/code-beam-sto-2018/

Automatic Packet Reporting System (APRS) is a world-wide messaging and telemetry system based on amateur radio stations and other volunteer activities including weather station reporting. This talk presents how to build basic servers for APRS Internet System (APRS-IS), the backbone network of APRS, with Erlang and Elixir to demonstrate the language systems' advantage on writing concurrent messaging systems. More details on website: http://codesync.global/speaker/kenji-rikitake/

Distribution has always been a strong side of Erlang, but it has its own limitations. Projects with specific requirements often resort to external or application-level workarounds to circumvent them. As we want to keep using Erlang distribution even in extreme use-cases, we are focusing on fixing these issues. We explain how the new API for custom distribution in Erlang 21 lets you build your own distribution protocol. This helps us especially to prototype our extensions to Erlang distribution to scale it better and make it more universally usable. A well-known limitation is Head-of-Line blocking. It makes the latency of messages unpredictable and it gets even worse with mesh networks. We show the results of our prototype to fix this problem. This prototype also is the first step to more scalability by enabling message routing between nodes. We explain how link state routing protocols work and show how one of them which is very extensibe and which we plan to use for solve routing, discovery and maybe even global process registry. More details here: http://codesync.global/speaker/peer-stritzinger/

Cisco is shipping Erlang code in its flagship routers and in the leading network automation solution, NSO. This talk describes the role Erlang play in the products, how it is integrated with the rest of the environment, and the scaling approaches taken.

Summarising what you will learn if you watch Peer Stritzinger and Adam Lindberg talk from Code BEAM STO on 'Fixing Erlang distribution problems in the core.' The full conference presentation can be viewed here: https://youtu.be/0E49Q5fbs5g

Put some more advanced features of Erlang to work by implementing lazy evaluation. First we find a way of being non-strict, so we only evaluate things by need, and then we find a way of memoising the results. We show how to build infinite, graphical and indeed cyclic data structures, using higher-order functions, macros and ETS tables. OBJECTIVES Learn some advanced functional programming techniques and see how they can be implemented in Erlang. AUDIENCE Anyone who would like to learn some neat functional programming tricks to use in Erlang or Elixir. More details here: https://codesync.global/speaker/simon-thompson/

Simon Thompson, Co-author of Erlang Programming (School of Computing, University of Kent) introduces his talk 'Making It Lazy: never evaluate anything more than once' and explains what its about. The talk can be viewed here: https://youtu.be/QWm_ekBUKYI

The cloud, everyone is talking about it. Most of the cloud providers give you a very capable platform to build your applications on. But what can you do if your cloud provider only gets you 90% of the way for your platform? You could just leave the missing pieces to the different teams in your organisation. That just requires every team to have an expert in how your chosen cloud platform works. Not only are those individuals hard to find, you also end up implementing things multiple times. The answer? Pull the cloud experts together and have them deliver a platform on top of the chosen cloud platform. A platform that makes it easy for your application developers to get the 100% without having to resort to deep knowledge about the cloud platform you are using. This is what we have done at Alert Logic. We call it EEE. This talk will go through the architecture of EEE and show how it provides a version of AWS Lambda that covers all our needs. More details here: https://codesync.global/speaker/torben-hoffmann/

In microservices architectures, it is difficult to understand how services use resources across shared infrastructure. In monolithic systems, we depend on traditional tools that report per-process resource usage and latency characteristics that are limited to a single process. In order to be able to collect and analyze resource utilization and performance characteristics of distributed systems, OpenCensus tracks resource utilization through the chain of services processing a user request. OBJECTIVES Provide an overview of distributed tracing; Provide an overview of metrics collection; Introduce OpenCensus and why choose it over competitors ; Have audience members coming away knowing how to get started tracing, instrumenting and reporting from their Erlang applications. More details here: https://codesync.global/speaker/iliia-khaprov/

The upcoming Erlang/OTP 21 release will come packed with exciting features. One of them is the long awaited improvement of IO scalability (think of network sockets and file descriptors). This talk will describe what a poll set is and how it can be a bottleneck. We will see how to measure the impact of the upcoming improvements with an example on a real-world system and discover what scenarios one might benefit from them. OBJECTIVES Get a better understanding of poll sets. More details here: https://codesync.global/speaker/peter-goemoeri/

Clojure is a powerful language. The BEAM is a powerful virtual machine. Combining the two seemed only logical… thus Clojerl was born. In this talk, Juan will explain the process of implementing a language on the BEAM. Follow juan as he walks us through the steps to take, explains the challenges this involves and review the results he has achieved. He will also show the reasons why he considers Clojure a powerful language and what does it have to offer the BEAM community. OBJECTIVES Language implementation on the BEAM. Share Clojure with the BEAM community. More details here: https://codesync.global/speaker/juan-facorro/

Using Erlang to create a language for the BEAM is well-modeled, with projects like Elixir, LFE, and Alpaca growing in popularity and maturity. There are several benefits to leveraging the Erlang toolchain; however, one restriction screams out: your compiler has to be written in Erlang! (*Yes, technically your compiler could also be self-hosted). But what if, despite conventional models, the BEAM itself is a friendly, open compilation target? Are there benefits to sidestepping the Erlang toolchain altogether? In this talk, we'll discuss the making of a compile-to-BEAM language, from scratch. You will have a guided tour through codec-beam, a BEAM assembler written in Haskell, which provides an explicit model for the BEAM's semantics. Finally we'll compare that project to the Erlang compiler's assembler, and see if we can beat OTP at it's own game! OBJECTIVES Introduce the audience to the BEAM file format and some of the decisions encoded into the Erlang compiler. Audience members should leave knowing why BEAM may or may not be a great candidate platform for their next language project. More details: https://codesync.global/speaker/kofi-gumbs/

Documentation, pattern matching, and OTP are big things on the BEAM. What about the humble module? We’ll talk about how to exploit arguably simpler constructs, like the module, to their fullest extent! More details: https://codesync.global/speaker/joseph-yiasemides/

Autonomous robots have the potential to change the world as we know it, freeing up humans from mundane tasks (or as we like to term them, "jobs"). But how do we know that the robots will do what we want them to do, and how can we ensure that they will not misbehave in unexpected ways? This talk will explore some new ideas around understanding the plans that are used to control robotics systems, using the power of functional programming and high-level functional abstractions to ensure that the actions that a robot carries out do what was originally intended, even in the presence of unexpected situations or unpredictable events. No actual robots will be hurt in the course of the talk. More details: https://codesync.global/speaker/kevin-hammond/

This talk will breifly look at the problem of implementing languages on top of the Erlang system. It will briefly describe the properties of the BEAM and how how they affect languages running on top of it. We will describe three different ways of "adding" languages to the BEAM and Erlang/OTP system and the different properties they have. More details: https://codesync.global/speaker/robert-virding/

he BEAM is a wonderful piece of technology that we all love and use daily when writing our programs - no matter the language! For the past year, Mikhal has worked on optimising a couple of open source libraries, building performance-focused applications and contributing several optimisations to the Erlang compiler and the BEAM runtime. During this presentation, he'll share his discoveries and what he has learned. He'll explore some common techniques for optimising programs running on the BEAM, applicable to Erlang, Elixir and LFE. He'll show us what tools can be used to evaluate performance and discover bottlenecks. He'll then talk both about how these problems can be solved - both by optimising the pure functional parts, leveraging the knowledge of BEAM innards, and by optimising concurrent programs around processes. More details: https://codesync.global/speaker/michal-muskala52/

Ecto is the most popular database library for Elixir and one of the first major libraries written in Elixir. In this practical talk, you will learn of Ecto's capabilities, driven by code examples, and discover what sets Ecto apart from traditional ORMs and database frameworks. We will look at what drove some of the design decisions in Ecto and where the contributors got their inspirations from while delving into some of its inner workings. After the talk you will have a better understand of Ecto and have a basis on which you can build your own applications using Elixir. Want more Elixir content? Attend Code Elixir LDN 16 Aug: https://codesync.global/conferences/code-elixir-2018/#Register

Andrea gave updates on what the Elixir team has done in the last few months, what are the projects they're working on, what's going on on the research side, and what features will be in the next release? Want more Elixir content, attend Code ELixir LDN 2018: https://codesync.global/conferences/code-elixir-2018/#Register

Development teams and and DevOps engineers frequently get tasked with providing corporate-level security of an application after the fact. Either in a startup mode or as a corporate side-project experiment, applications are frequently built without security and compliance in mind. Only later, when the application is successful or the Chief Security Office learns of the application, is security and compliance required and the team is frequently left scrambling on how to achieve this. This talk will demystify some of the common experiences everyone goes through in this process and how to ease your transition into a compliant environment. More details here: https://codesync.global/speaker/chad-gibbons/

Ukrainian Digital Health Services is one of the biggest open-source Elixir projects in the world. Alex will talk about how Elixir is used to tackle complexity and deliver a better product. This talk will also delve into all of the caveats behind large-scale development with Elixir. OBJECTIVES To release Edenlab's experience of building large-scale projects with Elixir Describe all problems and solutions for which they came across Show their library toolset to encourge attendees to give it a go. More details here: https://codesync.global/speaker/alex-troush/

One of the key components of the infrastructure architecture at Issuu is the Thin Layer. The little piece of Erlang code allowed us complete freedom in creating a microservice-oriented architecture. By converting HTTP requests to AMQP messages it allows anyone to create a microservice at any moment and not worry about routing or load balancing. We believe others would benefit from such architecture and would like to present it to the BEAM community. OBJECTIVES Present the Thin Layer to the community as we are planning to open source it. Gather feedback and ideas for possible improvements. More details here: https://codesync.global/speaker/pawel-antemijczuk/

One of the problems that development tools had was that each editor and IDE had its own implementation of functionality that could have been common: parsing the code, understanding project structure, etc. Microsoft has specified an open protocol that allows separating language-specific backends from generic editing clients. I will describe an implementation for a LSP server for Erlang (sourcer) and show how it can be used for more than editor support. OBJECTIVES Describe an infrastructure that provides Erlang support for developer tools, editors, IDEs and others. More details here: https://codesync.global/speaker/vlad-dumitrescu/

An important design principle in Erlang is the integration of domain models as OTP behaviours. Services managing session state, resource allocation, or service start order are often modeled as state machines. And several OTP behaviours around state machines have been conceived for Erlang. However, plain state machines often suffer from the explosion of the state space as soon as multiple state variables appear in combination. Also some applications have only an infinite representation, if modeled as a state machine. We address these challenges by introducing gen_pnet, a new OTP behaviour based on Petri nets. Petri nets are a class of transition systems generalising service state by representing state as tokens produced and consumed by transitions. We consider several examples for Petri nets in gen_pnet such as a worker pool, a scheduler, as well as a distributed programming language. We also discuss how Erlang error handling facilities play with gen_pnet and how unit testing works. More details here: https://codesync.global/speaker/joergen-brandt/

Barrel is a database Benoit wrote from scratch over the past two years that can be embedded in an Erlang or Elixir application like Mnesia. With Barrel, you can easily bring and keep a view (complete or partial) of your data inside your application and replicate it between your different machines. This talk will describe how you can use Barrel to quickly create your own peer-to-peer data platform with different storage and replication strategies. It will also shows the different tools supported by Barrel, to operate and monitor your cluster on premise or on the "cloud". Different examples, codes and patterns will be presented. More details on website here: https://codesync.global/speaker/benoit-chesneau/

Starting in 2016, PagerDuty started replacing a lot of its in-house custom monitoring tools and SLA calculators with off-the-shelf software. However, one critical piece of monitoring involving 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 simpler and more reliable/scalable one all by using Elixir/OTP. OBJECTIVES This talk demonstrates how the message based paradigm championed by Erlang and adopted in Elixir helped address PagerDuty's scalibility woes, all while keeping the codebase minimal and maintainable. More details on website here: https://codesync.global/speaker/aish-dahal/

This talk introduces a new type system for Erlang based on Gradual Typing. The principles of Gradual Typing has emerged in the type system research community over the last decade and has, amongst other things, resulted in TypeScript, a typed dialect of JavaScript. Gradual Typing is tailored to mix static and dynamic code. The type system provides pay-as-you-go static checking: the more type annotation in the program, the more static checking will be performed. The tool we've developed uses Erlang's current syntax for specs, and it works on existing code bases without change. Dialyzer is currently the most popular tool for the static checking of Erlang. Our gradual type system turns out to be somewhat complementary to Dialyzer. While Dialyzer aims to give no false positives, our type system always reports an error whenever a type spec doesn't match the code. We'll provide an in-depth comparison of the two tools. OBJECTIVES Present our new type checking tool for Erlang. More details here: https://codesync.global/speaker/josef-svenningsson/

Distributed Erlang makes writing distributed applications a breeze. However, setting up distributed Erlang is not always as easy in local (Nerves) or containered (Docker) environments. We explore how Erlang distribution is started by a node. After starting Erlang distribution usually nothing happens until the user requests to connect to another node. The other node has then to be discovered in order to be able to connect to it. Currently only DNS is supported to find other nodes and EPMD to discover the correct port. Alternative discovery mechanisms exist but are not (yet) natively supported by Erlang distribution. This talk will cover a new feature that will add native support and the road to merging it into Erlang/OTP. OBJECTIVES Spread knowledge about a new feature coming to Erlang and how you can add new features yourself. It is not hard! More details here: https://codesync.global/speaker/timmo-verlaan/

In Erlang/OTP 19.0 a new gen_* behaviour targeted at writing state machines was introduced - gen_statem. With its much richer feature set and a more general event model it was intended to replace the gen_fsm behaviour. This talk goes through the gen_statem features, how they differ from gen_fsm and plain gen_server, and why they make gen_statem a better tool for writing any state machine except possibly the simplest. More details here: https://codesync.global/speaker/raimo-niskanen/

In distributed databases, data will be stored in multiple machines across multiple locations - but when changes could be passed to any of those machines how should one confirm that not only has all data reached all locations, but that the data is still there later? Work is underway for Riak KV 3.0, the first major release of Riak KV since the project went fully open-source, to try and improve the efficiency of how the entropy problem is addressed. The talk should explain why and how this issue is to be handled, and what feature enhancements this will allow going forward. The improvements are focused on re-designing Riak’s use of Merkle Trees, a data structure recently popularised though its use in Blockchain systems. The redesign changes how Merkle Trees are stored and calculated, and includes a mechanism for aligning the querying of data in Log-Structured Merge Trees with the Merkle Trees that represent the data. More details on website here: https://codesync.global/speaker/martin-sumner/

With Erliot, we test the relevance of a design pattern for IoT applications, where every communicating ‘thing’ in the real world is twined with a live ‘object’ in the virtual world. This dedicated agent is in charge of tracking the most recent history of the device in particularly. Implemented as a lightweight process at the edge or in the cloud, it allows for translating, filtering, downsampling, fusion of information and triggering alerts on upstream flows. It serves as a proxy for all other interactions. The flow to monitor is thus dispatched to a sea of processes, prior to reaching a datalake (if required). Although natural to an Erlang trained mind, this solution comes as an alternative to most present reference architectures for the Internet of Things. We’ll report on first experiments with a smart building application. More details on website: https://codesync.global/speaker/guy-a-narboni/

In this talk, we'll explore some of the history of the Erlang language's garbage collection from one of the earliest releases in 1999 to the current version. Also, we will try to understand GC problems in general and look into the algorithms that were developed to solve that problem in more detail. OBJECTIVES To publish the result's of Boris' research and give an insight into the history of Erlang.

In this talk Erik and Tobias will present a new blockchain built in Erlang and Elixir to run on top of the BEAM. They will give a brief introduction to blockchain technology and then present the AEternity project and some of its features, such as State Channels and Oracles. They will also talk about the execution of smart contracts on the blockchain, the whys and hows. The AEternity smart contracts can be written in a functional programming language. They will conclude by explaining how it is currently implemented and some of the highlights they have plan for smart contracts in the future. More details on website: https://codesync.global/speaker/erik-stenman/

Andrew will present a talk on a new open source package - Sage, explaining what use cases it covers. He will also discuss approaches for dealing with distributed transactions generally. More details on website: https://codesync.global/speaker/andrew-dryga/

As it turns out, Erlang or Elixir aren't the fastest kid on the block. And while raw CPU speed matters little for most applications, there does exist a couple reasons you might want want to reach for tools that give you access to native power. In this talk we will discuss Native Implemented Functions (NIFs) - Erlang's Foreign Function Interface (FFI). NIFs are normally implemented in C and are considered dangerous. But we're going to explore writing safer NIFs in Rust - a new systems programming language developed by Mozilla, that focuses on memory safety. We'll talk about the pitfalls with writing NIFs and how Rust can make this process easier and safer. More details on website: https://codesync.global/speaker/sonny-scroggin/

The main goal with "logger" is to standardise an API for logging, allowing the application implementer to use this API without making any assumptions about the logging backend that will be used in the final system. That is, we want to remove the dependency, between applications and logging facility. The main goal is not to remove the need for good logging applications like Lager, but to lift the decision about logging from the low level application implementer to the high level system architect. This will also make it easier to combine applications from different providers - since the same API is always used. Thus, individual applications don't need a dependency to a logging backend such as Lager. That dependency is decided on system level instead. We want a built-in logging feature which is "good" by default, but which can be customized and extended if needed. The talk will tell you how it works and explain the design decisions. More details on website: https://codesync.global/speaker/kenneth-lundin/

Twenty years after the Open Source Initiative was created, open source has grown from a disruptive idea to a default approach to software. This talk will review the first twenty years of open source and suggest some trends for the next ten. More details on website: https://codesync.global/speaker/simon-phipps/

Raxx can be used to build web applications much like Plug. However that is where the similarities end. Raxx aims to simplify web applications by promoting simple concepts like functional purity and message passing. I started the project in 2016. Since then, it has matured to the point where it has been used in several production services. This talk will cover an introduction to the project; an overview of the rationale behind it, and finally a vision of what comes next. More details here: https://codesync.global/speaker/peter-saxton/

In this talk, I'll explain how the current web applications are no more simple DB projections but more complex and distributed applications that require technologies and architectures different from the past. We start with a simple & classic application to move to a more complex and feature-rich application that need a more advanced architecture. More details here: https://codesync.global/speaker/gianluca-padovani/

Webhooks are super powerful to connect desperate services and what can we do when webhook functions have memory? How does one persist state in a distributed webhooks system? Let's walk through some examples and then build a game live. More details here: https://codesync.global/speaker/nathan-herald/

There are women –rarely known– who have had a massive impact in the Erlang & Elixir community. We wouldn’t even be here in this conference if it wasn’t for some of them. Their achievements and stories are known only in small circles because often their protagonists have been humble and discreet. But these heroines have done and are still doing amazing things for our community. It is high time we gave them the recognition they deserve and celebrate their contributions together. Who knows? Maybe this talk will plant the seed of the next generation of Erlang & Elixir role models. More details here: https://codesync.global/speaker/miriam-pena/

The talk will explain one of MongooseIM's new features - Global Distribution. What is the use case it implements? How does it compare with standard XMPP intercluster routing? And most importantly - why does this extension work so well, thanks to Erlang! More details here: https://codesync.global/speaker/piotr-nosek/

Nerves makes it very easy to leverage the BEAM in an embedded device using readily-available and low-cost hardware like the Raspberry Pi family of single-board computers. In this talk, we will cover the basics of what Nerves is and how to structure your application for easier testing without needing real hardware. More details on website: https://codesync.global/speaker/greg-mefford/

Some of the earliest Erlang adopters were Universities, using the language semantics to teach aspects of computer science. This resulted in research projects and collaboration focusing on type systems, tooling, static analysis, property-based testing, all overlapping with classic themes such as VM enhancements, concurrency, distribution, scalability, reliability and multi-core. Whilst lots has been achieved, the challenges faced by the software industry keeps on evolving, as does the hardware and infrastructure they run our systems on. In this panel, Torben Hoffmann leads a discussion with Kostis Sagonas, Kevin Hammond, Natalia Chechina, and Simon Thompson on how the industry and universities can work together to keep research thriving, accessible, cutting-edge and relevant.

There are quite a few IDEs that provide a certain amount of support for Erlang programming. These include text editors such as Vim and Emacs, and proper IDEs such as Eclipse, IntelliJ IDEA and Visual Studio Code. Most people pick an IDE and stick to it, maybe switch once after looking enviously to a fellow programmer's toolset. In this talk, we will expore the world of IDEs from the perspective of an Erlang developer. What are the features that we can expect from an IDE? How different are the feature sets provided by different IDEs? How easy is it to extend these IDEs with custom features? What can the Erlang plugins of the IDEs learn from each other? More details on website: https://codesync.global/speaker/csaba-hoch/

THANKS TO ALL WHO ATTENDED CODE BEAM STO 2018! Learn about Code BEAM STO 2019: https://codesync.global/conferences/code-beam-sto-2019/AMSTO Code BEAM STO 2018 brought together over 50 speakers across two-days. It focused on real-world applications of BEAM languages, concurrency, distributed computing and scalability. It strived to bring together people passionate about the Erlang Ecosystem and high-performance, massively scalable distributed systems. Code BEAM STO conference is all about discovering the future of the Erlang Ecosystem and bringing together developers as a community to share knowledge & ideas, learn from each other and inspire to invent the future. An action-packed two-day conference fused with a mix of talks on innovation and open-source applications based on Erlang, OTP, Elixir, LFE, BEAM and other emerging technologies! --- CODE SYNC & CODE BEAM STO 18 Code BEAM STO is powered by Code Sync. Code BEAM STO 18 was sponsored by WhatsApp, Klarna, CoinGaming, DEK Technologies, Kivra, Ericsson, Erlang Solutions, ShopGun, and aeternity. CODE SYNC Website: www.codesync.global Twitter: www.twitter.com/CodeBEAMio Facebook: https://www.facebook.com/CodeSyncGlobal LinkedIn: https://www.linkedin.com/company/code... Mail: info at codesync.global