content.md

Table of Contents

• Why Erlang?
• Introduction
• Learning Erlang
• Advanced Erlang
• Erlang design choices and BEAM Internals
• Useful tools and libraries
• Testing
• Debugging, tracing and logging
• Profiling
• Performance
• Erlang wants to talk to the outside world!
• Parsing
• Learn through reading some awesome code!
• Community
• Other BEAM languages

Why Erlang?

• The Zen of Erlang - Fred Hebert - Explains why "let it crash" works by showing how supervision trees turn failures into reliability
• Where Erlang Blooms - Fred Hebert - Real-world use cases where Erlang excels, drawn from the real-time bidding industry
• When would you choose Erlang? - Brian L. Troutwine - Practical decision criteria for when Erlang is the right tool for the job
• Erlang is not a Concurrent Functional Programming Language - Kresten Krab - Argues Erlang is better understood as a language for building reliable distributed systems, not just a functional language
• Erlangs parallelism is not parallelism! - Jesper L. Andersen - Clarifies the distinction between concurrency and parallelism in the context of Erlang's process model
• Reliability Features of Erlang - LambdaLounge Krakow 2013 - Walkthrough of Erlang's core reliability mechanisms including supervision, process isolation, and hot code loading
• What can I only do in Erlang? - Craig Everett - Mailing list discussion on unique Erlang capabilities like hot code upgrades and soft real-time guarantees
• A response to "Erlang - overhyped or underestimated" - Jesper L. Andersen - Defends Erlang's value proposition by addressing common criticisms about syntax, performance, and ecosystem
• Adopting Erlang - Practical guide to introducing Erlang in an organization, covering team building, code writing, and production deployment

Introduction

• Learn X in Y minutes Where X=erlang - Quick-reference cheatsheet covering Erlang syntax and core concepts in a single page
• Erlang Tic Tac Toe - 99s - Hands-on beginner tutorial building a tic-tac-toe game to learn Erlang basics
• An Open Letter to the Erlang Beginner (or Onlooker) - Fred Hebert - Encouraging advice for newcomers on what to expect and how to approach learning Erlang
• The Joy of Erlang; Or, How To Ride A Toruk - Evan Miller - Gentle introduction to Erlang for programmers coming from imperative languages
• On Erlang's Syntax - Fred Hebert - Explains the rationale behind Erlang's unusual syntax choices and why they make sense
• Erlang syntax again - Robert Virding - Co-creator of Erlang discusses why the syntax is the way it is and addresses common complaints
• Parallelism /= Concurrency - Simon Marlow - Foundational explanation of the difference between parallelism and concurrency, essential for understanding BEAM
• Making reliable distributed systems in the presence of software errors - Joe Armstrong - Joe Armstrong's PhD thesis that defines the philosophy behind Erlang and OTP, a must-read for serious practitioners

Learning Erlang

• Learn you some Erlang - Fred Hebert - The most popular free online Erlang tutorial, covers everything from basics to OTP with humor
• Functional Programming with Erlang - Simon Thompson - University lecture series teaching functional programming fundamentals through Erlang
• Curso Erlang en Español - Rodrigo Dominguez - Spanish-language video course covering Erlang from beginner to intermediate
• Erlang Master Class 1: Functional Programming - University of Kent video series on Erlang fundamentals: pattern matching, recursion, and higher-order functions
• Erlang Master Class 2: Concurrent Programming - University of Kent video series on Erlang processes, message passing, and concurrent design
• Erlang Master Class 3: OTP Behaviours and Releases - University of Kent video series on gen_server, supervisors, applications, and releases
• Some Erlang Magic for Beginners - Brujo Benavides - Tips and tricks for beginners including useful shell commands and lesser-known language features
• My favorite Erlang program - Joe Armstrong - Joe Armstrong shows a tiny universal server that demonstrates Erlang's power of hot code swapping
• Build an FTP Server with Ranch in 30 Minutes - 99s - Step-by-step tutorial building a working FTP server using the Ranch socket acceptor library
• Canillita: Your First Erlang Server - Brujo Benavides - Walkthrough of building a complete Erlang REST API from scratch using standard OTP
• Extending OTP - Robert Virding - How to write custom OTP behaviours and extend the framework beyond the built-in gen_server and supervisor

Advanced Erlang

• Erlang Patterns - Catalog of common Erlang design patterns with code examples for solving recurring problems
• 10 Essential Erlang Tools for Erlang Developers - Brujo Benavides - Overview of must-know tools including rebar3, dialyzer, observer, and common_test
• On Erlang, State and Crashes - Jesper L. Andersen - How to think about state management and recovery in crash-oriented Erlang design
• Error Kernels, What are they? - Jesper L. Andersen - Explains the error kernel pattern: separating the part of your system that must not crash from the part that can
• Every-day Erlang: Handling Crashes in Erlang - Marcelo Gornstein - Practical guide to handling process crashes, linking, monitoring, and supervision in daily Erlang work
• Let it crash the right way - MazenHarake - Clarifies common misunderstandings about "let it crash" and when you should actually handle errors
• 9 Erlang pitfalls you should know about - MazenHarake - Common mistakes experienced Erlang developers make, from atom table leaks to blocking schedulers
• The Erlang shell. Your secret weapon - Jesper L. Andersen - Advanced shell techniques for debugging and introspecting live Erlang systems
• REPL? A bit more (and less) than that - Fred Hebert - How the Erlang shell differs from typical REPLs and why that matters for development workflows
• Code Janitor: nobody's dream, everyone's job (and how Erlang can help) - Fred Hebert - Techniques for refactoring and maintaining large Erlang codebases using Erlang's own tooling
• The Hitchhiker's Guide to the Unexpected - Fred Hebert - Talk on handling unexpected failures in production systems and building resilient Erlang applications
• Garrett Smith - Writing Beautiful Code - Talk on writing clean, readable, and idiomatic Erlang code with practical style guidelines
• Beyond OTP - Loic Hoguin - Talk on building systems that go beyond standard OTP patterns, from the creator of Cowboy
• Writing Quality Code in Erlang - Garrett Smith - Talk on best practices for writing maintainable and high-quality Erlang code
• Can you hear the drums, Erlando? - Matthew Sackman - How the RabbitMQ team uses parse transforms to bring monadic syntax and list comprehensions to Erlang
• Inaka's Erlang Coding Guidelines - Comprehensive style guide and coding conventions used at Inaka for production Erlang projects
• Programming Rules and Conventions - The original Ericsson Erlang programming rules covering naming, structure, and error handling conventions
• Erlang and code style - Jesper L. Andersen - Opinionated take on Erlang code style covering module structure, naming, and documentation practices

Erlang design choices and BEAM Internals

• It's About the Guarantees - Fred Hebert - Explains why Erlang's value lies in its guarantees about isolation, fault tolerance, and distribution
• Stacking Theory for Systems Design - Jesper L. Andersen - How to reason about system correctness by stacking layers of guarantees on top of each other
• Sequence and Order in Erlang - Dennis Byrne - Explains message ordering guarantees between Erlang processes and what you can and cannot assume
• The Road we didn't go down - Joe Armstrong - Discussion about RPC
• The BEAM Dispatcher - Happi Blogging - Deep dive into how the BEAM virtual machine dispatches and executes bytecode instructions
• The Erlang Tagging Scheme - Happi Blogging - Explains how the BEAM uses tagged pointers to represent different data types at the memory level
• How Erlang does scheduling - Jesper L. Andersen - Detailed explanation of the BEAM's preemptive scheduler, reduction counting, and fairness guarantees
• Understanding the Erlang Scheduler - Video explanation of how the BEAM scheduler works, including run queues and load balancing across cores
• Erlang Scheduler Details and Why It Matters - Hamidreza Soleimani - In-depth article on scheduler internals including work stealing, migration logic, and real-time properties
• Hitchhiker's Tour of the BEAM - Robert Virding - Co-creator of Erlang walks through the BEAM VM architecture from bytecode to execution
• Tackling Dirty Jobs with Erlang's Schedulers - Steve Vinoski - Talk on dirty schedulers, how to handle long-running NIFs and I/O without blocking normal scheduling
• Live Podcast on VM - Mostly Erlang - Podcast discussion about BEAM VM internals, design trade-offs, and implementation details
• The Beam Book - Comprehensive open-source book covering BEAM VM internals including instruction set, memory, and processes
• OTP internal documentation - Official internal docs from the OTP team explaining BEAM implementation details like GC, scheduling, and NIFs
• Interview with Jesper Louis Andersen about Erlang - Wide-ranging interview comparing Erlang with Haskell, OCaml, Go, and discussing type systems and software design
• Erlang Garbage Collection Details and Why It Matters - Hamidreza Soleimani - Explains per-process generational GC, heap layout, and why it enables soft real-time guarantees
• Erlang 19.0 Garbage Collector - Lukas Larsson - Details the generational GC improvements in OTP 19 including the new young and old heap strategy
• BEAM VM Wisdoms - Collection of easy to read articles - Dmytro Lytovchenko - Community wiki covering BEAM internals, data types, memory layout, and instruction set in accessible language
• The Erlang Runtime System - Online version of the BEAM book covering the runtime system architecture in depth

Useful tools and libraries

• Dialyzer: A static analysis tool for finding type errors and discrepancies - Uses success typing to find type errors, unreachable code, and spec violations without requiring annotations
• Xref: A cross reference tool for analyzing dependencies - Finds unused functions, undefined calls, and circular dependencies between modules and applications
• sync: On-the-fly recompiling and reloading in Erlang - Watches source files and automatically recompiles and hot-loads changed modules during development
• erlang.mk: Build tool for Erlang that just works - Makefile-based build system by the Cowboy author, supports fetching deps, compiling, testing, and releasing
• rebar3: Build tool - The standard Erlang build tool handling compilation, dependency management, testing, and releases
• hex.pm: Package manager for the BEAM ecosystem - Central package repository shared by Erlang, Elixir, and other BEAM languages
• rebar: Old rebar build tool (archived) - The predecessor to rebar3, no longer maintained but found in many legacy projects
• mixer: Mix in functions from other modules - Allows importing and re-exporting functions from other modules, useful for composing module interfaces
• relx: Sane, simple release creation for Erlang - Generates OTP releases from your applications with minimal configuration, now integrated into rebar3
• lager: A logging framework for Erlang/OTP (unmaintained) - Feature-rich logging library with log levels, multiple backends, and runtime log level switching
• elvis: The king of code style - Erlang code style reviewer that enforces configurable coding standards via command line or CI
• erlando: Set of syntax extensions for Erlang - Parse transforms from RabbitMQ adding do-notation, cut, and import_as to Erlang
• sheriff: Check values against their type as defined through typespecs (archived) - Runtime type validation that checks values against typespec definitions for input validation
• gproc: Extended process registry for Erlang - Rich process registry supporting named processes, properties, counters, and pub/sub across nodes
• cuttlefish: sysctl-like syntax config for your apps (unmaintained) - Translates human-friendly config files into Erlang app config, used by Riak and other Basho projects
• clique: Opinionated framework for building command line interfaces (unmaintained) - Framework for adding admin CLIs to Erlang nodes, originally built for Riak's riak-admin tool
• riak core: Distributed systems framework - Library for building distributed, scalable, fault-tolerant applications using consistent hashing and vnodes
• riak_core tutorial - Step-by-step tutorial for building a distributed key-value store on top of riak_core
• Building on top of riak core - Mark Allen - Talk on practical experience building distributed applications using riak_core as a foundation
• Little Riak Core Book - Mariano Guerra - Free online book that walks through building a distributed system from scratch using riak_core

Testing

• Eunit - Official documentation for Erlang's lightweight unit testing framework with assertion macros and test generators
• Common Test Basics - Introduction to Erlang's integration and system testing framework, suited for larger tests with setup/teardown
• Erlang Meta Testing - Brujo Benavides - Technique for testing that all modules in an application have proper test coverage and follow conventions
• Testing Erlang - Zachary Kessin - Free open-source book covering EUnit, Common Test, PropEr, and testing strategies for Erlang applications
• PropEr User Guide - Official guide to the PropEr property-based testing library for generating random test cases from specifications
• triq: Trifork QuickCheck - Free Apache-licensed QuickCheck implementation for property-based testing in Erlang
• PropEr Testing - Fred Hebert's free online book teaching property-based testing with PropEr through practical examples

Debugging, tracing and logging

• Debugging with the Debug Helper - Guide to using the dbg module helper functions for quick debugging sessions in the Erlang shell
• A GUI tool for observing an erlang system - Documentation for Observer, the GUI tool for inspecting processes, ETS tables, memory, and application trees
• observer: Erlang Debugger - Official guide to the graphical Erlang debugger for setting breakpoints and stepping through code
• Taking the printf out of printf Debugging - Mats Cronqvist - Talk on using Erlang's tracing infrastructure instead of print statements for debugging production systems
• eper: restricted debugging utility - Collection of debugging tools including dtop (like top for Erlang) and ntop for distributed node monitoring
• recon: Diagnose problems in production nodes - Production-safe debugging library for inspecting processes, memory, and scheduling without crashing the node
• erlyberly: Debugger, tracer with GUI in Java - Desktop GUI application for tracing function calls, viewing process state, and debugging live Erlang nodes

Profiling

• cprof: A simple Call Count Profiling Tool - Lightweight profiler that counts function calls with minimal overhead, good for finding hot code paths
• eprof: A Time Profiling Tool for Erlang - Time-based profiler that measures wall-clock time spent in each function, useful for finding bottlenecks
• fprof: The File Trace Profiler - Detailed profiler using file-based tracing to measure time including call graphs and per-process breakdowns
• eep: Erlang Easy Profiling - Generates flame graphs and call-time analysis from Erlang trace output for visual performance profiling
• Percept 2 - an enhanced version of the Percept profiling tool from the Erlang/OTP distribution - Concurrency profiler that visualizes process activity, scheduling, and communication patterns over time
• Profiling Erlang programs using Percept2 - Video tutorial demonstrating how to use Percept2 to find concurrency bottlenecks in Erlang programs
• Profiling with Percept2 - Huiqing Li - Conference talk showing advanced Percept2 features for profiling multi-core Erlang applications
• Multicore Profiling for Erlang Programs Using Percept2 - Academic paper describing the design and implementation of Percept2's multicore profiling capabilities
• Multi-level Visualization of Concurrent and Distributed Computation in Erlang - Research paper on visualizing concurrent Erlang systems across multiple abstraction levels

Performance

• Stuff Goes Bad. Erlang in anger - Fred Hebert - Free book on diagnosing and fixing issues in production Erlang systems, from memory leaks to message queues
• Scaling Erlang - Brujo Benavides - How to design and execute a load test plan for an Erlang application using Tsung
• Worker Pool - Brujo Benavides - Introduction to the worker_pool library for managing a pool of gen_server workers for parallel task execution
• Planning for Overload - Fred Hebert - Talk on designing Erlang systems that degrade gracefully under load instead of cascading failures
• Lessons Learned while Working on Large-Scale Server Software - Fred Hebert - Hard-won insights on operating large Erlang systems including monitoring, debugging, and capacity planning
• Queues Don't Fix Overload - Fred Hebert - Explains why adding queues to overloaded systems makes things worse and what to do instead
• dispcount: task dispatcher based on ETS counters - High-performance resource pool using ETS counters to avoid single-process bottlenecks
• pobox: External buffer processes to protect against mailbox overflow - Library that protects processes from mailbox overflow by providing bounded buffering with backpressure
• On Scalability, Capacity, and Sensitivity - Jesper L. Andersen - Theory and practice of understanding system capacity limits and how to measure them
• fuse: Circuit Breaker - Circuit breaker library that prevents cascading failures by temporarily cutting off failing subsystems
• safetyvalve: Safety valve for your erlang node - Load regulation library using queue theory to reject work before the system becomes overloaded
• epocxy: Erlang patterns of Concurrency - Library of concurrency patterns including concurrent maps, fan-out, and batch processing utilities
• Everyday Erlang: Quick and effective caching using ETS - Marcelo Gornstein - Practical guide to building a simple but effective cache layer using ETS tables
• Erlang Factory 2014 - That's 'Billion' with a 'B': Scaling to the Next Level at WhatsApp - Talk on how WhatsApp scaled Erlang to handle billions of messages with a small engineering team
• Realtime performance at scale - Fredrik Linder - Talk on achieving consistent low-latency performance in large-scale Erlang systems
• Scalable is Awesome, Literally! - Garrett Smith - Talk demonstrating Erlang's natural scalability properties through live coding and system design
• Keeping a System Running Forever - Fred Hebert - Talk on operational practices for maintaining long-running Erlang systems in production
• System Limits - Erlang - Official reference for BEAM system limits including max processes, atoms, ETS tables, and message sizes
• Erlang String Handling - How to be efficient at handling string data in Erlang - Jesper L. Andersen - Guide to choosing between lists, binaries, and iolists for efficient string processing in Erlang
• How WhatsApp Grew To Nearly 500 Million Users, 11,000 Cores, And 70 Million Messages A Second - High Scalability - Architectural overview of WhatsApp's Erlang-powered infrastructure and the engineering decisions behind it
• Tales of a Former Disassembly Addict - Reflections on when low-level optimization matters and when high-level language performance is good enough
• A Deeper Look at Tails Recursion in Erlang - Programming in the 21st Century - Explains when tail recursion actually matters for performance in Erlang and when it does not
• Why Garbage Collection Paranoia is Still (sometimes) Justified - Programming in the 21st Century - When GC-related performance concerns in Erlang are legitimate and how to identify real problems
• Erlang, Binaries, and Garbage Collection (Sigh) - Explains the tricky interaction between reference-counted binaries and per-process GC that can cause memory leaks
• Social Platforms in Erlang - Lessons Learned - Slide deck sharing production lessons from building social platforms in Erlang including scaling and architecture
• Eliminating Single Process Bottlenecks with ETS Concurrency Patterns - Jay Nelson - Talk on using ETS concurrent access patterns to remove single-process bottlenecks in hot paths
• Erlang Web Server Benchmarking - Steve Vinoski - Benchmark comparison of Erlang web servers with methodology discussion on how to measure HTTP server performance

Erlang wants to talk to the outside world!

• Getting Erlang to talk to the outside world - Joe Armstrong - Joe Armstrong's paper on Erlang's port mechanism and strategies for interfacing with external programs
• erl_nif - Official documentation for writing Native Implemented Functions (NIFs) in C to extend Erlang with native code
• Writing an Erlang port using OTP principles - Erlang Central - Tutorial on building an OTP-compliant port for safe communication between Erlang and external OS processes
• How to implement a driver - Official guide to writing linked-in port drivers for high-performance C integration with the BEAM
• Ports and Port Drivers - Reference manual section explaining the port mechanism for communicating with external programs via stdin/stdout
• Ports - Step-by-step tutorial on creating a C port to call C functions from Erlang through byte-stream communication
• Port drivers - Tutorial on writing linked-in port drivers that run inside the BEAM VM for lower-latency C integration
• From Erlang to Java and Back Again: Part 1 - Brujo Benavides - How to establish bidirectional communication between Erlang nodes and Java applications using JInterface
• Haskell - Interfacing Erlang - Guide to connecting Haskell programs with Erlang using the Haskell-Erlang interoperability libraries
• Rustler - Safe Rust bridge for creating Erlang NIF functions - Write NIFs in Rust with safety guarantees that prevent segfaults from crashing the BEAM VM
• erlport - Connect Erlang to Ruby and Python
• JavaErlang - Facilitate the communication between Java and Erlang nodes
• erlang_js - A linked-in driver for Erlang to Mozilla's Spidermonkey Javascript runtime
• cl - OpenCL binding for Erlang
• exe - Erlang Shell Executor

Parsing

• Parsing in Erlang - Tutorial on building an expression parser in Erlang using recursive descent techniques
• Making Parsers with Yecc - Wikibooks - Guide to using Erlang's built-in LALR parser generator Yecc, similar to Yacc for C
• Write a Template Compiler for Erlang - Evan Miller - Tutorial on building a Django-style template compiler that generates BEAM bytecode
• Building a Parser Generator in Erlang - Sean Cribbs, Part 2, Part 3, Part 4, Part 5 - Five-part series building a PEG parser generator from scratch, which became the Neotoma library
• Neotoma: Erlang library and packrat parser-generator for parsing expression grammars - PEG-based parser generator that compiles grammar definitions into efficient Erlang parsing modules

Learn through reading some awesome code!

• ranch: socket acceptor pool for TCP protocols - Clean, well-documented TCP connection pool used by Cowboy, great example of OTP design patterns
• cowboy: small, fast, modular HTTP server - The most popular Erlang HTTP server, excellent example of protocol parsing and Ranch integration
• riak: distributed, decentralized data storage system - Dynamo-inspired distributed database showcasing consistent hashing, vnodes, and eventual consistency in Erlang
• rabbitmq: feature rich, multi-protocol messaging broker - Production-grade AMQP message broker, great example of plugin architecture and protocol handling in Erlang
• ejabberd: massively scalable XMPP server - One of the oldest and largest Erlang projects, demonstrates building extensible real-time communication servers
• vernemq: distributed MQTT message broker - Clustered MQTT broker built on LevelDB and Plumtree, good example of distributed pub/sub in Erlang

Community

• Awesome Erlang: curated list of awesome Erlang libraries, resources and shiny things - Community-maintained directory of the best Erlang libraries organized by category
• Erlang Bookmarks: Collection of links - Categorized collection of Erlang learning resources, tools, and libraries
• Erlang Forums - Official community discussion forum for Erlang questions, announcements, and ecosystem news
• Mailing list - The long-running erlang-questions mailing list, the traditional place for Erlang community discussion
• Erlang Slack - Real-time chat community for Erlang developers hosted by the Erlang Ecosystem Foundation
• IRC channel on Libera.Chat - The #erlang IRC channel for real-time help and discussion with Erlang developers

Other BEAM languages

• Elixir - Dynamic, functional language with Ruby-inspired syntax, the most popular BEAM language after Erlang
• LFE - Lisp Flavoured Erlang, a Lisp syntax frontend for the BEAM with full Erlang interoperability
• Purerl - PureScript backend that compiles to Erlang, bringing strong static typing and type classes to the BEAM
• Luerl - Lua interpreter implemented in Erlang, useful for embedding scripting in BEAM applications
• Erlog - Prolog interpreter in Erlang, allows embedding logic programming within BEAM applications
• Clojerl - Clojure implementation on the BEAM, bringing persistent data structures and Clojure's philosophy to Erlang
• Gleam - Statically typed language for the BEAM with type-safe OTP bindings and no runtime exceptions
• Caramel (unmaintained) - OCaml-inspired language targeting the BEAM, aimed at bringing ML-style types to Erlang
• Fez (unmaintained) - F# to BEAM compiler, an experiment in running .NET-style functional code on the BEAM
• Alpaca (unmaintained) - ML-style statically typed language for the BEAM with type inference and pattern matching
• Efene (unmaintained) - Python and JavaScript inspired syntax for the BEAM, aimed at lowering the barrier to entry

Not yet reviewed

These resources were recently found and have not been reviewed yet.

Erlang/OTP Releases

• Erlang/OTP 25 Highlights - ARM64 JIT, type-based native code optimizations, maybe expression
• Type-Based Optimizations in the JIT - Bjorn Gustavsson (2023) - How the JIT eliminates redundant type checks
• Erlang/OTP 27 Highlights - Safe destructive tuple update, native JIT coverage, quantum-resistant TLS

Gleam

• Gleam Version 1 - Louis Pilfold (March 2024) - Statically typed language compiling to Erlang or JavaScript on the BEAM
• The Gleam Language Tour - Browser-based interactive tour via WebAssembly
• Gleam on Exercism - 33 concepts and 122 exercises with mentoring

BEAM Performance

• Performance Testing the JIT Compiler - Lukas Larsson (Erlang Solutions, 2024) - 30-50% more RabbitMQ throughput, 30-130% CPU-bound improvements

Talks & Articles

• My Favorite Erlang Container - Fred Hebert (2022) - Shipping Erlang in containers with live code upgrades via K8s sidecar
• A Distributed Systems Reading List - Fred Hebert (2024) - Annotated reading list connecting distributed systems papers to BEAM/OTP design
• Problem Solving with Erlang and the BEAM - Virding & Cesarini (GOTO 2023) - Original design motivations and Erlang's future

Elixir Ecosystem

• Hugging Face Arrives in the Elixir Community (Bumblebee) - GPT-2, Stable Diffusion in pure Elixir via Nx
• Programming Phoenix LiveView - Tate & DeBenedetto (Pragmatic, 2023) - Definitive LiveView book
• Machine Learning in Elixir - Sean Moriarity (Pragmatic, 2024) - Neural networks, CV, NLP using Elixir's Nx stack

Books

• Elixir in Action, Third Edition - Sasa Juric (Manning, 2024) - Updated to Elixir 1.15 and current OTP
• Concurrent Data Processing in Elixir - Svilen Gospodinov (Pragmatic, 2021) - GenStage, Flow, and Broadway for data pipelines

Erlang/OTP 28 & Language Features (New)

• Erlang/OTP 28 Highlights (May 2025) - Priority messages, zip generators, nominal types (EEP 69), PCRE2, smarter compiler error suggestions
• EEP 69: Nominal Types in Erlang - Nominal types (-nominal meter() :: integer()) to prevent accidental misuse of structurally identical types; shipped in OTP 28
• Gradual Set-Theoretic Types in Elixir - Elixir's new gradual type system using unions, intersections, and negations; rolled out incrementally 1.18-1.20 (2024-2026)

BEAM Internals & Research (New)

• The BEAM Book: Understanding the Erlang Runtime System - Stenman (2025) - Definitive published book on BEAM internals: schedulers, process memory, GC, compiler pipeline, performance tuning
• Why I Wrote the BEAM Book - Stenman (2025) - Motivation and decade-long journey behind the comprehensive BEAM internals reference
• A Stop-the-World Debugger for Erlang - Gorin, Gustavsson & Aloi (24th Erlang Workshop, 2025) - Novel stop-the-world debugging approach for BEAM systems

Embedded BEAM & IoT (New)

• AtomVM 2025 Year in Review - Bettio (2026) - JIT/AoT compiler in Erlang, distributed Erlang for microcontroller clusters, four execution modes
• Evaluating AtomVM for Fault-Tolerant ESP32-Based Systems - Ferenczi et al. (24th Erlang Workshop, 2025) - Measures cost of fault tolerance on ESP32-based AtomVM systems

New Books 2025 (New)

• Network Programming in Elixir and Erlang - Leopardi (PragProg, 2025) - TCP, UDP, DNS, HTTP, WebSockets on BEAM; builds chat server and Redis client
• Elixir Patterns: The Essential BEAM Handbook - Koutmos (PragProg, 2025) - Supervision trees, ETS, persistent_term, leveraging Erlang stdlib from Elixir; includes Livebook notebooks
• Engineering Elixir Applications - Fairholm & Giralt D'Lacoste (PragProg, 2025) - BEAMOps paradigm: Terraform, Docker, GitHub Actions CI/CD, and AWS deployment for Phoenix LiveView
• Ash Framework: Create Declarative Elixir Web Apps - Le & Daniel (PragProg, 2025) - Official guide to building declarative, resource-oriented Elixir applications
• Real-World Event Sourcing - Hoffman (PragProg, 2025) - Event-sourcing patterns in Elixir: aggregates, projectors, process managers, schema evolution

Gleam Ecosystem (New)

• Gleam v1.7-v1.14 Release Notes (2025) - 8 releases in 2025: fault-tolerant compilation, auto-imports, zip generators, language server improvements

Conferences (New)

• Keynote: The AtomVM and New Horizons for Elixir - Bettio & Front (ElixirConf EU 2025) - Running Elixir, Erlang, and Gleam on microcontrollers via AtomVM
• Keynote: Gang of None? Design Patterns in Elixir - Jose Valim (ElixirConf EU 2024) - How Gang of Four patterns map (or don't) to idiomatic Elixir on the BEAM