Code BEAM SF 2018

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 this talk, we describe some of the best tools we use for developing reliable and scalable servers in Erlang. Some of these tools and approaches may not be widely known in a broader Erlang community. Others may be considered controversial and going against more conventional Erlang practices. OBJECTIVES The goal of this talk is to share some of best practices of using Erlang at WhatsApp. More details here: https://codesync.global/speaker/anton-lavrik/

More details here: https://codesync.global/speaker/james-fish/

Industrial IoT has been around for a lot longer than most people think, predating the consumer internet of things. Its early incarnations were originally called M2M, or machine-to-machine, networks. These early systems were always networks of wired machines communicating via Ethernet, Fiber, DSL or even twisted copper pair landlines over a modem. Wired systems require a significant infrastructure to be in place, which is why most modern-day systems are centered around manufacturing or industrial automation. What about remote facilities that are not connected to a fiber network, or where a communication network is prohibitively expensive? What about things that are in motion, like automobiles, freight trucks and rail? What about small sensor devices that are battery-powered and now being deployed for asset tracking, or for environmental and agricultural needs? In this talk, Brian will explain the differences between Low Power Wide Area Networks and Cellular IoT, and how to use them when deploying a real-world IoT solution in the wild, whether it is for remote wind and solar farms, rail, smart power poles, or real-time asset tracking for supply chain. More details here: https://codesync.global/speaker/bryan-hughes/

The buzz about quantum computing has been rapidly increasing lately, and a growing number of developers have been looking into the subject. Concepts that developers typically find challenging after a cursory investigation of quantum computing include: superpositions of quantum bits (qubits), quantum gates, quantum entanglement (Einstein’s “spooky actions at a distance”), and the relevance of Schrödinger’s famous cat. In this session, James Weaver will give a gentle introduction to quantum computing, including: A brief history of quantum computers, visualizing superpositions, composing quantum algorithms with quantum gates, understanding Shor’s potentially RSA encryption busting algorithm, and current status of quantum computers. More details here: https://codesync.global/speaker/james-weaver/

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.

The final step in any successful release of Erlang (or Elixir) software is getting the release artifact(s) onto production machines. There are currently many ways this can be accomplished. This talk investigates some of the current approaches I've encountered, addresses some of the ways I've gone about this over the last 10 years, and introduces the different tools used. The primary focus will be on creating system packages (e.g. deb or rpm packages), but will touch on other packaging techniques. More details here: https://codesync.global/speaker/anthony-molinaro/

Where is Erlang when we move from the cloud towards the edge? Its traditional use case in telecom equipment has always been in larger embedded systems, which were always reaching towards the edge of the network. With our GRiSP project and evaluation board we push to get Erlang's advantages into smaller devices in IoT, home automation, manufacturing and automotive systems. To extend this reach of the Erlang VM even further we are not only building boards and software that run Erlang directly on the hardware but also extending the capabilities of the Erlang VM towards a more scalable, heterogeneous, Erlang distribution protocol supporting hard realtime Erlang processes. In this talk we will give an overview of our progress so far and will demonstrate use cases in home automation and robotics. Our work for improving Erlang distribution for our Industrial and IoT applications will bring improvements for cloud based solutions too, like a remedy for head of line blocking and better scalability. More details here: https://codesync.global/speaker/sebastien-merle/

Members of the Elixir community often receive the question: "why should I use Elixir?" 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. This talk argues that the success of Elixir will be marked by how we learn from the mistakes historically made by the functional programming community. More importantly, this talk presents a strategy for the Elixir community, which centers around community-building, based on real-world experiences and historical analysis. More details here: https://codesync.global/speaker/osa-gaius/

Last year, Benoit and others were busy integrating and customising Barrel, a modern and opensource data platform with master-master replication written in Erlang. This talk will describe the different challenge we faced in building a P2P middle-tier platform in Erlang to persist the data and “actors” states from micro-services in different levels of storage and replicate them between different locations. This talk will also describe the different patterns used for Reads and Writes concurrency but also continuous automated indexation of the data and “actors.” More details here: https://codesync.global/speaker/benoit-chesneau/

Supervisory control and data acquisition (SCADA) is a control system architecture that uses computers, networking, and graphical user interfaces for process monitoring and control, operating in conjunction with peripheral devices such as programmable logic controllers, sensors, and actuators to interface with plant and machinery. The SCADA model was originally developed as a universal means of remotely accessing control modules, which could be from different manufacturers, allowing access through standard automation protocols. The Internet of Things is now redefining the role and architecture of SCADA systems, with modern SCADA systems leveraging Internet protocols and cloud services for interaction with connected devices, and controlling environments ranging from smart homes to large-scale processes spanning multiple geographically disperse sites. In this talk, we will discuss this evolution and will describe a novel next-generation SCADA solution that utilizes the capabilities of Erlang to monitor and control a growing network of industrial-scale energy-efficient temperature management systems. The architecture and design of the system with be discussed, along with future plans to expand the role played by Erlang in the overall end-to-end solution and the use of the OpenVMS operating system on embedded devices to optimize reliability and security. Other possible uses for this solution and future enhancements will be considered, including making it more generic and more applicable to a range of Internet of Things scenarios. More details here: https://codesync.global/speaker/brett-cameron/

Opaque Data Structures provide a very nice technique to structure systems and they are particularly useful within the functional programming paradigm. With the addition of maps and the opaque attribute for modules, Erlang is now perfectly suited to get the best of these structures, if you use it properly. In this talk, Brujo will show what opaque data structures are, how to use them and why they are so useful, even more so if you're developing an open-source library. This talk will be conceptual, but it won't be 100% theoretical. Brujo will also present examples and tools that assist us in making better use of these techiques. More details here: https://codesync.global/speaker/brujo-benavides/

Dependency graphs are a useful representation for exploring opportunities to introduce concurrency in a larger system. They are hidden all over computing (compilers, build systems) and everyday life (to-do lists, cooking recipes). Users can define a set of tasks, as well as dependencies between them, and wrek will execute the resulting graph as concurrently as possible. OBJECTIVES Introduce/refamiliarize the audience with dependency graphs, explore the conception and design of wrek, showcase how wrek can be used and integrated into larger projects, demonstrate wrek's broad applicability. AUDIENCE Developers interested in seeing where mathematics and everyday life collide. Developers interested in new Erlang/OTP libraries. More details on website: https://codesync.global/speaker/richard-kallos/

Programs that write programs are called metaprograms. They occupy the space between your problem and its solution. When used haphazardly the results can be confusing and cryptic. But when used wisely, they simplify that space and make it possible to solve hard problems in elegant ways. Elixir embraces metaprogramming. In fact, it's fundamental to the implementation of the language itself. This talk will answer questions for you such as: "When should I write a macro?" "What is quote and unquote and when do I use them?" "When and where does this macro code execute?" "Macro.prewalk? What does this have to do with macros?" Along with some practical examples. What's more astonishing is how approachable (and safe!) Elixir makes this complex subject. With this solid foundation, your code will be writing itself in no time! More details here: https://codesync.global/speaker/jay-hayes/

Learning a new programming language can be intimidating and it doesn’t take too long before impostor syndrome can kick in. Things can even get more challenging if you’re learning includes being exposed to a new programming paradigm. This talk discusses about ways through which the journey of learning Elixir can be made more fulfilling and worthwhile through collaboration. We will explore how the better usage of mediums like Exercism, Slack etc., not only help us identify different ways of getting unstuck as we work towards getting a clearer understanding of the functional concepts in Elixir but also how they empower us to be better programmers in general through thoughtful conversations about code. We will also see how this journey of learning Elixir gives us opportunities through which we can contribute back to the language and community. Slides can be viewed here: https://speakerdeck.com/boddhisattva/learning-elixir-better-through-collaboration-and-giving-back-2 More details here: https://codesync.global/speaker/mohnish-jadwani/

Erlang variables are immutable. But what happens when we do `Map2 = maps:put(Key, Value, Map1)`? Surely the VM doesn't copy all of Map1 to a new Map2 in memory just to add that new Key-Value pair? But then how does it give us the illusion that Map1 still exists, without the new pair? How does it keep track of which erlang map contains which pairs? And which performance costs do our applications pay for that magic? More details here: https://codesync.global/speaker/jean-rouge/

Cyber-attacks are increasing in terms of sophistication, speed and dynamics. Defenses are not keeping up. Why does the attacker have such an advantage? Because most software is not designed with 'let it fail' in mind. Our community has a significant advantage in the area and we should capitalize on it. The talk will start with some cybersecurity fundamentals. I'll explain the advantages of OTP from a cybersecurity perspective. There are still pitfalls and I'll cover some of them as well as present some best practices to help your code be more secure. I'll do a survey of the open source software available as well as touch on areas where work is needed. The goal is to promote the "let it be hacked" mentality - which will both promote erlang/elixir and be good for cybersecurity. OBJECTIVES This talk aims to: educate everyone (at least a little bit) in cybersecurity explain why beam/erlang/elixir are great for developing cybersecurity software give some ptifalls to avoid and best practices to follow present a survey of cybersecurity open source software from a BEAM perspective (ie both what is there, and what is needed) an unabashed plea for helping promote beam for cybersecurity

Explore the basics of machine learning, deep learning, and neural networks. Discover how to use Elixir to teach your computer how to learn and solve problems with data you already have. No math degree (or previous experience) required! OBJECTIVES Teach the basics of machine learning, including how to build an effective neural network in Elixir. AUDIENCE Beginner/intermediate mostly unfamiliar with machine learning. More details here: https://codesync.global/speaker/jesse-j-anderson/

Help me HTTPS, you’re my only hope! Then again, maybe not. In this presentation I’ll show an iPad app that communicates with three Raspberry Pi 3 devices, each controlling a stop light via Elixir and Nerves. So how do we secure the communication such that only the iOS app controls the lights? We'll look at three RPi3 setups, each identical save one very important, security related difference: no security (http), TLS based security (https), and application layer security (srpc). We'll discuss why systems based on RSA, initially designed to solve an open system problem, should not be applied in a rote manner to closed system problems. And we'll look at how the Secure Remote Password (SRP) protocol can offer mutually authenticated application layer security that leaves no room for Man-in-the-Middle issues and attacks. More details here: https://codesync.global/speaker/paul-rogers/

In this talk I will tell you about a new blockchain that is built in Erlang and Elixir to run on top of BEAM. I will give you a brief introduction to blockchain technology and then present the AEternity project and some of the features of AEternity, such as State Channels and Oracles. I 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, and I will explain how it currently is implemented in and some of the things we plan to do in the future with smart contracts. More details here: https://codesync.global/speaker/erik-stenman/

Talk about design and motivation for high performance metrics library in Erlang developed by Xaptum using mutable counters -- based on and inspired by oneup app. OBJECTIVES Introduce new Erlang library AUDIENCE Erlang developers working with high throughput applications. More details here: https://codesync.global/speaker/irina-guberman/

Bugs you know you will happen in production are usually easy to handle since you know about them. The problem is that we, as humans, have limited knowledge and understanding about the problem domains we write programs for and very often about our programs themselves. This is at the root of all the surprising unexpected bugs that we actually encounter all the time. While we can become experts at being careful and well-equipped in tooling and just knowing all kinds of weird situations that can arise from code and computers being a thing that we all have to live with, there are some other approaches that can prove helpful as well. In this talk, we'll see some broad and diverse approaches to handling the unexpected, but will keep a specific focus on how building the proper supervision structures lets us encode predefined failure semantics into our programs so that we know how most errors will be handled, without even knowing what they are. More details here: https://codesync.global/speaker/fred-hebert/

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 real time crypto-currency exchange, and then adding load to the exchange to see OTP at work in real time. More details here: https://codesync.global/speaker/anna-neyzberg/

For over a decade, Erlang's cross-platform GUI interface, wxErlang, has sat dormant without a meaningful & practical guide. This talk is wxErlang's long-awaited tutorial. As one of the first presentations on the subject, we have an opportunity to discuss best-practices surrounding the understandability & comparability of the code we shall ultimately write for each other. To do so, we draw on knowledge from the accounting profession, in particular Conceptual Statement 8 (CON 8). CON 8 is the central framework in the worldwide 'Harmonization' effort: principles set forth by the FASB¹ & IASB² to guide the internationalization of accounting standards. Whether you find this surprising or not, Accountants and Erlangers both deal with very similar issues; such as what, where, and when to log information, and in our case of WxErlang, how to ultimately present data to the user. From there we shall promptly delve into the gears of wxErlang. By the end of this talk, not only will you be able to craft a basic wxErlang application, but also be well equipped to participate in writing code that can help harmonize the community. FASB¹ Financial Accounting Standards Board IASB² International Accounting Standards Board More details here: https://codesync.global/speaker/robert-carbone/

As Erlang & Elixir/OTP programmers, the actor model of computation sits comfortably in our minds. Processes that communicate only by message passing makes building concurrent applications easy. It feels natural. We take it for granted. The Pony language started with the same foundation as Erlang: the actor model of message passing and independent, concurrent computing units. But Pony is a very different beast. Pony uses a strong static type system to create crash-free, concurrency-safe access to sharable, garbage-collected memory without running in a virtual machine. To begin, Scott will review the actor model's definition and history. He will then discuss the design trade-offs that took Erlang/OTP's and Pony's implementations down very different paths. As an example, Erlang/Elixir's "selective receive" feature allows message handling in any order. Pony's message receiving is strictly first-in first-out (FIFO) order only. What good comes from that difference?

Elixir is a great choice for most applications. It's powered by the battle-tested Erlang VM know as the BEAM. It allows programmers to build incredibly fast, efficient, scalable, and fault-tolerant distributed systems. What more could you ask for? As it turns out, Elixir isn'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're going to 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 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 here: https://codesync.global/speaker/sonny-scroggin/

The talk will go through different categories and patterns in distributed systems, compare them and explore them applying each to the case of a distributed key value store. OBJECTIVES Get an high level picture of the different aspects in distributed systems and how they apply to a real use case. AUDIENCE People interested in architecture, patterns and distributed systems. More details here: https://codesync.global/speaker/mariano-guerra/

It is cliche to say that we live in the age of information, but it is also profoundly true. Information (and access to it) shapes our thoughts and actions as a society, now more than ever. Control and political censorship of that information poses a systemic risk to democratic societies worldwide. In this talk we will present the Archain project: a system of permanent data storage aiming to democratise the control and accessibility of information. As well as detailing the aims of the system, its technical implementation and potential effects, we will also discuss the use of Erlang as its base. Archain is a decentralised permanent information storage system, open to all, forever. Built on a novel blockchain-like data structure (a 'blockweave') that shards across many computers, the Archain is a public library and archive inside a cryptocurrency. As well as taking a peek inside the Archain infrastructure itself, we will explore how Archain-based Erlang apps can be used to build incontrovertible election/voting systems, automated traders, and decentralised social media systems, among many other uses. More details here: https://codesync.global/speaker/sam-williams/

The hex.pm service is a fantastic tool and fills a huge need in the Elixir and Erlang community. But what if you wanted to run your own private package service behind your own firewall? This talk explores what it takes to get up and running a hex-like service both from the server and client sides. In doing so, will allow the same convenient methods to deploy your private code as you use to pull open source code into your projects. More details here: https://codesync.global/speaker/mark-allen/

Firmata is a binary protocol that extends the MIDI protocol. It is used by many languages to talk to microcontrollers from any host machine (https://github.com/firmata/protocol). This talk will go over the details of implementing the protocol in Elixir and have some live demos of communicating from a Nerves based host machine to an Arduino Uno. Details will include: implementing I2C sensors, ultra-sonic distance sensors analog sensors. Christopher is one of the maintainers of the Elixir Firmata library (https://github.com/entone/firmata) and a Core member of the Nerves development team (http://nerves-project.org/).

In this talk I am going to share how Elixir's deployment tooling has gotten to where it is today, what problems we've addressed, what problems remain, and going into the future, how we're planning to evolve and improve. The practical problems the tools aimed to address early on have been largely resolved. However, as Elixir draws more developers from other languages, we've had to face the fact that we have not only a perception problem, but a variety of usability issues that early adopters have largely not noticed or cared about. Addressing these problems is the primary goal of the next stage of evolution in these tools, as well as making releases part of the core Elixir toolchain. If you are currently deploying Elixir in production, or are looking to do so, you will be interested in this talk. More details here: https://codesync.global/speaker/paul-schoenfelder/

GraphQL, a data query language released by Facebook in 2015, has been growing steadily in popularity, with GraphQL APIs supplementing (and in many cases supplanting) REST APIs for use in modern client-side web and mobile applications. In this talk you'll learn the fundamentals of GraphQL—how its types model your domain for use in queries, mutations, and live-data subscriptions—and how you can use Absinthe GraphQL toolkit to add rich, flexible GraphQL API to Elixir-based applications within minutes. More details here: https://codesync.global/speaker/bruce-williams/

Entrigna’s data scientists had an idea to create an IoT software platform that could process large amounts of data and scale while living on the edge. They evaluated several different technologies, however, Erlang was the best fit for their needs. In this presentation, we will speak about Entrigna’s needs, how we evaluated the different languages, why we chose Erlang and then demo how an Erlang solution can run and scale through a cluster of Raspberry Pis. More details here: https://codesync.global/speaker/murali-kashaboina/

Smaller teams are easier to manage just as simpler systems are easier to manage. As your team grows, your system inevitably becomes more complex. Without a clear vision, software quality can decline and, likewise, developers happiness can wane. At Bleacher Report, as we've grown our team, we've put in place standards and systems that help maintain software quality, keep developers engaged and independent and evaluate and incorporate new technology. Learn how we've managed to do that in this 20 minute talk. More details here: https://codesync.global/speaker/ben-marx/

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. More details here: https://codesync.global/speaker/simon-thompson/

Search is one of the toughest problems in computer science. This talk will discuss the challenges we've gone through at Teachers Pay Teachers while adopting Elixir as our new go-to language. Adrian will discuss some problems they discovered while building out search and more specifically how they are now using Elixir to build out tools to power search analytics. OBJECTIVES This talk will point out some of the discoveries they've made while porting the search page from their old stack (PHP). He will also exemplify Elixir, as their go-to language for building out tools on the Search team and how these tools help them move faster with choosing the right decisions when it comes to search algorithm tweaks. More details here: https://codesync.global/speaker/adrian-cruz/

We slashed our Amazon DynamoDB costs by over 75% using Kinesis, DynamoDB streams, and Erlang/OTP to implement a global cache warming system for advertising profile data. Using Elixir and the Flow framework, we subsequently doubled the performance of that system with only minor modifications. This talk will describe our motivation, some pitfalls we encountered, and how Erlang and now Elixir ultimately led to the success of this project. More details here: https://codesync.global/speaker/mike-watters/

There's an Erlang/Elixir myth that tail-recursive functions are much faster than body-recursive functions. In this talk we will first explore how Erlang terms are represented in bit level, and then take a closer look at this myth to understand what really happens with tail-recursive functions vs body-recursive functions. You will understand more about BEAM internals and Erlang's Efficiency Guide. More details here: https://codesync.global/speaker/boshan-sun/

RabbitMQ is a popular 100% Erlang-based Open Source message queuing system that implements the Advanced Message Queuing Protocol (AMQP). It was been estimated that there are 50,000+ production deployments of RabbitMQ across the globe, and this number is continuing to grow. Most of these deployments are business-critical, underpinning everything from internet-based pizza ordering systems through to providing the central nervous system for large scale cloud-based application deployments. One of the reasons for RabbitMQ's popularity is that it is easy to install and to start doing something useful with it; however despite this apparent ease of use, RabbitMQ is a complex software product that is highly flexible in terms of the use-cases that it can support and highly configurable, with a large number of tuneable parameters (many courtesy of Erlang). Accordingly, specialist skills and knowledge are often required in order to obtain best results in terms of scalability, reliability, security, application design, and performance. In this short talk, Brett will provide a brief overview of RabbitMQ in terms of its history and general capabilities, and will discuss options available to RabbitMQ users (or prospective users) requiring assistance in terms of product support, training, and consulting services. More details here: https://codesync.global/speaker/brett-cameron/

Although Elixir has been rapidly adopted in the past few years, it still lacks a general guide and practices on releasing, deploying and upgrading (maintaining) the elixir services in a production environment. Issues around this subject include: How can Elixir release be integrated with github release? How can Elixir service deployment and upgrade be integrated with devOps tools (like ansible)? How can we quickly respond to failures and anomaly behavior of running Elixir services? This talk shares the discoveries we have made at Tubi TV for the whole process. Including: Using distillery to generate the release and hot upgrade release. Building our own tool to make the artifacts once a github release is created. Building ansible script to do rolling upgrade or hot upgrade, enabling engineers to run one command to deploy a release without disrupting the production service. Using sentry logger for error logging and integrating datadog for monitoring and alerting. OBJECTIVES Share our experience and discoveries on how to release, deploy and upgrade Elixir services. More details here: https://codesync.global/speaker/tian-chen/

In this talk we will present two testing tools for Erlang, focusing on recent additions to their features and capabilities that were developed and motivated by industrial case studies and applications. The first tool, Proper (http://proper.softlab.ntua.gr/), has been extended to support targeted property-based testing, a powerful extension of property-based testing (PBT) that adds a search-based component to input generation. We will present how targeted PBT can be made automatic and how it can be applied to application areas such as sensor networks and security. The second tool, Concuerror (http://concuerror.com/), has recently seen significant improvements to its underlying technology that allowed it to test and verify protocols for chain repair for CORFU, a distributed shared log which aims to be scalable and reliable in the presence of failures and asynchrony.

Elixir provides the concept of enumerables, allowing you to transform, sort, group, filter and retrieve items using functions in the enum module. As an alternative to Enum, Elixir provides the Stream module which supports lazy operations. This talk will give an overview of the Stream module. We'll go into depth with some examples of when to and when not to use Stream over Enum. This talk may go into some code diving to explore how Stream does it's thing. Elixir provides the concept of enumerables, allowing you to transform, sort, group, filter and retrieve items using functions in the enum module. As an alternative to Enum, Elixir provides the Stream module which supports lazy operations. This talk will give an overview of the Stream module. We'll go into depth with some examples of when to and when not to use Stream over Enum. This talk may go into some code diving to explore how Stream does it's thing. More details here: https://codesync.global/speaker/geoffrey-lessel/

Many APIs are defined as RESTful resources, represented in JSON, and accessed via HTTP. While it's possible to make raw HTTP calls from your program, an API client library can provide significant benefits in safety, security, and readability. This session discusses how Google designs client libraries, covering common design challenges and best practices. You’ll also learn how Google uses code generation to produce clients for hundreds of APIs, across numerous programming languages—including, most recently, Elixir. This talk will also cover OpenAPI, which is how we've chosen to scale to languages not normally associated with Google. Target audience: Developers interested in producing or consuming APIs. More details here: https://codesync.global/speaker/jeff-ching/

Why LFE is not just Common Lisp on the BEAM, why Elixir is not just Ruby, why Efene is not just Python? In this talk we will explore the ressons why BEAM languages are the way they are, which things the BEAM makes easy and which makes... complicated. We will explore what's involved in developing a language on the BEAM that's actually useful and share experiences and tips. More details here: https://codesync.global/speaker/robert-virding/