MIXED ONLY VIDEOS ONLY ARTICLES

ALL VIDEOS

Think in Erlang! ///

Docker Images a la carte with Elixir and RabbitMQ ///

What are the best tools for browser testing? Click to find out ///

Your Erlang graph fix ///

(Un)Learning Elixir ///

Levelling up at Bleacher Report: A cautionary tale ///

The Yin and Yang of mutability ///

Riak KV 3 0 - worth the wait ? ///

Instrumenting and monitoring stateless Erlang today ///

Coding for global languages Unicode, charsets, strings and binaries ///

Monkey, take the wheel ///

Tactics and strategies for scalable robust intelligent systems ///

Customer retention and how to avoid double billing ///

Playing with Lambda Calculus ///

Updates from the Erlang Ecosystem Foundation working groups ///

GeoRacer: Building a real-time multiplayer mobile game in Elixir in 6 weeks. ///

Building an IDE, compiler and runtime for a graphical distributed data flow language in Erlang ///

Pivot! How to handle change ///

It's time to embrace Erlang ///

Making IoT safer with BEAM OTP ///

KAZOO the VOIP cloud platform: A retrospective ///

Erlang is getting pretty! ///

OTP Team update ///

Elixir ecosystem/Elixir core team updates ///

Diffing Hex packages ///

Bring on the worker bees (Designing Elixir systems with OTP) ///

BEAM and Kubernetes: Better together? ///

Macros in Elixir: Responsible code generation ///

Old ideas made new ///

Lucet: Safe WebAssembly Outside the Browser ///

Write your own container, for fun and no profit! ///

Capability Driven Requirements Engineering ///

Your Brain on Software Development ///

Do fish have legs: language design for the commercial coder ///

Can you make that smaller? An introduction to test-case reduction ///

Visualising concurrency with Kotlin ///

want don't You consistency no stinking ///

What is a computer program? Historical and philosophical reflections ///

In defence of uncertainty ///

What you needa know about Yoneda ///

Purescript on the BEAM; Typed OTP for greatness ///

Data pipelines à la mode ///

The Yin and Yang of mutability ///

Revisiting pattern match overlap checks in Haskell ///

SimGen - a new simulation language ///

String processing optimisation ///

Meta-programming in Erlang: Zotonic's template and dispatch compilers ///

From Legacy To Event Sourcing ///

Abstract data types in the region of abysmal pain, and how to navigate them ///

The Tyranny of Structurelessness ///

The art of challenging assumptions ///

Bare Metal from a Hardware Perspective: Embedded Frameworks & Build Systems ///

Misadventures with Terraform ///

Lumen - Bringing the BEAM to WebAssembly and Beyond ///

Bourdieu's social theory applied to tech ///

Quantitative program reasoning in Granule via graded modal types ///

Marlowe: financial contracts on Blockchain ///

Microservices with Elixir ///

How to specify it! A guide to writing properties of pure functions ///

Gleam: Lean BEAM typing machine ///

Let's get more women into computer science ///

A landscape of unintended consequences ///

Breaking black-box AI ///

Literary Theory looks at readable code ///

Decomposing container tools - about Swiss Army Knives and containers ///

Correctness proofs of distributed systems with Isabelle ///

AI for social responsibility: embedding principled guidelines into AI systems ///

The revolution in computing education at school: opportunity and challenge ///

Concurrency before Erlang ///

Unsung Heroes of the BEAM ///

gen_persistence: persist the state of your processes ///

Elixir Core team update (June 2019) ///

Bruce Tate | The River | Code Elixir LDN 19 ///

Osa Gaius - Resisting Object-Oriented Programming | Code Elixir LDN 19 ///

Typeclasses: the value of programming vocabulary ///

The Alchemist's Code: Bringing More Value with Less Magic ///

Keynote - Confident Elixir ///

Building an IoT Demand Response solution with Elixir ///

An event-driven approach to building Elixir applications ///

Boosting reinforcement learning with Elixir ///

Tortoise evolved: MQTT 5 support in the Tortoise MQTT client ///

Trust issues: trouble in package paradise ///

Exop on StreamData ///

XMPP/UDP Realtime service bus ///

PowerUp the BEAM with Kubernetes and Riak Core ///

Make a distributed toolbox with Ra ///

Opencensus: A stats collection and distributed tracing framework - an update ///

Your monolith, Elixir and you ///

Structs for order ///

Stateful property-based testing: with a game logic case study ///

Ra: a Raft implementation ///

Inch: How Elixir 1.7 changed the rules for documentation analysis ///

How to teach Elixir to non-functional developers ///

Getting distributed with Firenest ///

Functional APIs with GraphQL & Elixir ///

Erlang scales robots ///

Digging through the garbage ///

Innovative unorthodox design patterns used in RabbitMQ ///

Testing in an Elixir world ///

Implementing long running business processes ///

Buildings start-ups with Elixir ///

BEAM for smart energy ///

Think in Erlang! ///

Taming side effects ///

Scalable MQTT messaging platform for IoT in 5G era ///

PHP over Erlang: how and why? ///

TDD is not about testing ///

Raxx.Kit - Lean mean web development for Elixir ///

Introduction to a type system: session types ///

Riak's rebound ///

Evolution of Riak: resolving problems in distributed systems ///

Eir: Infrastructure for working with BEAM code ///

Continuous tracing in production (without Erlang's trace module) ///

Working with legacy code ///

The wide world of almost-actors: comparing the Pony language to BEAM languages ///

Pyrlang: Python meets Erlang ///

Just delete it! ///

How Erlang got its name ///

ErlangRT, a BEAM VM reimplementation in Rust ///

BEAM + Rust: A match made in heaven ///

Using formal methods to eliminate exploitable bugs ///

Eta: The rise of pure FP on the JVM ///

Co-operative robots sharing the load ///

Adding kind-polymorphism to the Scala programming language ///

Abstract nonsense ///

What does Dialyzer think about me? ///

Security versus interoperability ///

BEAM extreme; don't try this at home! ///

Useless performance optimisations on the BEAM for fun and... fun? ///

The BEAM programming paradigm ///

PureScript spirographs ///

The art of the BEAM: How to replace the JVM and not get fired ///

Natively Functional UI with Scenic ///

Can you teach a school class functional programming? ///

OTP team update - May 2019 ///

OTP behaviours and how to behave around them ///

Why time is evil in distributed systems ///

Building a highly scalable service that survived a Super Bowl ///

Using Distillery: understanding OTP releases ///

Erlang Distribution via UDP combined with Ethernet TSN ///

How WhatsApp moved 1.5B users across data centers ///

Create a decentralized database with ExAbci and Tendermint ///

Building a credit card issuer with Elixir ///

The evolution of a language ///

Monitoring environment stability with Erlang ///

Properties for all ///

Update: Elixir core dev team - March 2019 ///

Erlang logging for the 21st OTP ///

Chemanalysis: Dialyzing Elixir ///

Pretty state machine ///

FIPS 140-2 in BEAM apps ///

Fantastic Voyage III: Destination BEAM ///

Server-side network protocol ///

Process signals in OTP 21 ///

ZenMonitor: Scaling Distributed Monitoring at Discord ///

Membrane framework - bringing BEAM into world of multimedia and streaming ///

Clixir - mixing C and Elixir code ///

Containers & Orchestration: The Elixir way ///

Refactoring Elixir for maintainability ///

The art of the live upgrade - lessons from 10 years of evolving a live system ///

Functional farming with Nerves ///

Understanding Erlang kernel ///

Mid-air airplane repair: troubleshooting at WhatsApp ///

Operable Erlang and Elixir ///

Designing an engineering org for SaaS and on-prem delivery models ///

Are programmers heading towards another bursting bubble? ///

Announcing Broadway ///

Scaling Erlang cluster to 10,000 nodes ///

Verifying a distributed system with combinatorial topology ///

Programmation en Logique ///

Life of a distributed graph database query ///

Infosec, AI and ethics – new models for a secure future ///

Applying principles of chaos engineering to serverless ///

Understanding gossip protocols ///

Towards specifications of robustness - the things that programs do _not_ do ///

Towards language support for distributed systems ///

The life, times & thinking of Dr. Claude Shannon ///

Secure isolation in Rust: hypervisors, containers, and the future of composable infrastructure ///

Property based tests for the masses ///

Parsing safely, from 500MB/S to 2GB/s ///

Message passing for actors and humans with Raxx ///

Introduction to AI engineering ///

Interactive GPU programming with ClojureCUDA & ClojureCL ///

Implementing Raft in RabbitMQ ///

Idris 2: Type-driven development of Idris ///

Finite of sense and infinite of thought: a history of computation, logic and algebra ///

F# Code I love ///

Everything about distributed systems is terrible ///

Ethics in Tech: a psychological perspective ///

Ethics and AI: Identifying and preventing bias in predictive models ///

Do calculating machines like drawing? And if so, why? Considerations from media archaeology ///

CRDTs: From sequential to concurrent executions ///

Coroutines Explained ///

Building a Billion Dollar Cryptocurrency with Haskell ///

Breaking changes ///

A PostScript to functional geometry ///

What are poll sets and why they matter - Code BEAM STO 2018 ///

The Robots are Coming: Failure is not an Option! - Code BEAM STO 2018 ///

Optimising for the BEAM - Code BEAM STO 2018 ///

Implementing Languages on the BEAM - Code BEAM STO 2018 ///

Global scale messaging - MongooseIM - Code BEAM STO 2018 ///

Getting to the BEAM, without going through Erlang - Code BEAM STO 2018 ///

Expressive Power on the BEAM - Code BEAM STO 2018 ///

Clojure on the BEAM - Code BEAM STO 2018 ///

Prototyping with new OTP 21 API - Code BEAM STO 2018 ///

Opencensus - Code BEAM STO 2018 ///

News from the OTP team - Code BEAM STO 2018 ///

Making It Lazy: never evaluate anything more than once - Code BEAM STO 2018 ///

How Cisco is using Erlang for intent-based networking - Code BEAM STO 2018 ///

ForgETS: a globally distributed database - Code BEAM STO 2018 ///

Erlang in the sky with diamonds - Code BEAM STO 2018 ///

Boosting Erlang superpowers at WhatsApp - Code BEAM STO 2018 ///

APRS-IS servers on the BEAM - amateur radio - Code BEAM STO 2018 ///

A genealogy of Functional Programming - Code BEAM STO 2018 ///

CQRS and Event Sourcing ///

Building a Blockchain in Erlang ///

Using Erlang in Blockchain Development ///

Property-Based Testing in Blockchain and P2P Networks ///

wxErlang & Faithful Representation - Code BEAM SF 2018 ///

Wide World of Actors - Code BEAM SF 2018 ///

Unreachable Code: A Conversation about Safety and Human Factors - Code BEAM SF ///

Understanding Erlang Term - Code BEAM SF 2018 ///

Trusted Autonomy - Code BEAM SF 2018 ///

The Hitchhiker's Guide to the Unexpected - Code BEAM SF 2018 ///

Testing Tools for the Erlang Ecosystem - Code BEAM SF 2018 ///

Taking Erlang Elixir to the Metal - Code BEAM SF 2018 ///

Spells, Hexes, and Charms Running your Own Private Package Service - Code BEAM SF 2018 ///

Releases and Elixir: Envisioning a more perfect union - Code BEAM SF 2018 ///

Release, Deploy, Monitor and Upgrade Elixir Services in Real World - Code BEAM SF 2018 ///

Quaff that potion saving $millions - Code BEAM SF 2018 ///

Mixing in Elixir to Build Search - Code BEAM SF 2018 ///

Making It Lazy Never Evaluate Anything More Than Once - Code BEAM SF 2018 ///

Is Security on Your Nerves - Code BEAM SF 2018 ///

Intro to Machine Learning - Code Beam SF 2018 ///

Implementing Languages on the BEAM - Code BEAM SF 2018 ///

Hype For Types - Code Beam SF 2018 ///

High Performance Metrics Through Mutable Counters - Code BEAM SF 2018 ///

Getting to Know Your Rabbit - Code BEAM SF 2018 ///

Gently Down the Stream - Code BEAM SF 2018 ///

Fighting Authoritarianism With Blockchain And Blockweaves ///

Erlang In Action: Creating Scalable Edge Based Iot Solution - Code BEAM SF 2018 ///

Designing Rich API Clients at Scale - Code BEAM SF 2018 ///

Crypto + Concurrency ///

CQRS and Event Sourcing - Code Beam SF 2018 ///

Bridging The Physical and Blockchain World With Erlang ///

Arduino, Elixir And Nerves: A Deep Dive Into... - Code BEAM SF 2018 ///

Aeternity: Scalable Smart Contracts - Code BEAM SF 2018 ///

A Tour Through the Distributed System Zoo - Code BEAM SF 2018 ///

A GraphQL-on-Elixir Primer - Code Beam SF 2018 ///

Why Elixir Matters: A Genealogy of Functional Programming - Code BEAM SF 2018 ///

Update OTP Team - Code BEAM SF 2018 ///

Update Elixir Core Dev Team - Code BEAM SF 2018 ///

The Magic Behind Immutable Maps - Code BEAM SF 2018 ///

Quantum Computing Exposed -Schrödinger's Grumpy Cat - Code BEAM SF 2018 ///

Packaging for Production - Code BEAM SF 2018 ///

Opaque Structures and Other Yerbas - Code BEAM SF2018 ///

Next Generation SCADA - Code BEAM SF 2018 ///

Metaprogramming - Programs that Write Programs - Code BEAM SF 2018 ///

LPWAN and Cellular IoT Explained - Code BEAM SF 2018 ///

Let it Be Hacked - Code Beam SF 2018 ///

Learning Elixir Better through Collaboration and Giving Back - Code BEAM SF 2018 ///

Keynote: Unsung Heroes of the BEAM - Code BEAM SF 2018 ///

Introducing Wrek; A Library For Executing Dependency Graphs - Code BEAM SF 2018 ///

gen_statem - The Tool You Never Knew You Always Wanted - Code BEAM SF 2018 ///

From Cloud to Edge Networks - Code BEAM SF 2018 ///

Building and Integrating A Data Platform - Code BEAM SF 2018 ///

A Reflection on Building the WhatsApp Server - Code BEAM 2018 ///

si