List of videos

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/

This talk will be an overview of recently conducted small research projects related to Erlang, such as Erlang in robotics. Here Natalia will talk about scalability and fault tolerance capabilities of the most popular Robot Operating System (ROS) and potential for Erlang to enable reliable and fault tolerant performance in sophisticated packs of robots. Erlang performance in comparison with Go and Scala/Akka. OBJECTIVES The aim is to share findings and attract collaborations. More details here: https://codesync.global/speaker/natalia-chechina/

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.