From Unit Tests to Whole Universe Tests (with Will Wilson)

Building a Modern Cloud Platform (with Anurag Goel)

InfluxDB: The Evolution of a Time Series Database (with Paul Dix)

Beyond AI Hype, What Will Developers Actually Use? (with Zach Lloyd)

The $500 Billion Integration Problem, And One Possible Solution (with Marty Pitt)

Why Software Should Crash Before It Breaks (with Isaac Van Doren)

Making Kafka Cloud-Native: Object Storage Instead of Disks (with Filip Yonov & Josep Prat)

Java’s Cutting Edge Comeback (with Josh Long)

The State & Future of Apache Kafka (with Anatoly Zelenin)

DataFusion - The Database Building Toolkit (with Andrew Lamb)

Jupyter’s Architecture Unpacked (with Afshin Darian & Sylvain Corlay)

Nix, The Build Everything Language (with Julian Arni)

Rust-Powered Graphics Editor: How Graphite's Syntax Trees Revolutionize Image Editing

ReScript: A Better Typed JavaScript? (with Gabriel Nordeborn)

A Universal Query Engine in Rust (with Predrag Gruevski)

Music with Raspberry Pi Hardware & A Lisp Brain (with Dimitris Kyriakoudis)

Software Systems Aren’t Just Software (with Diana Montalion)

Building Fyrox: A Rust Game Engine (with Dmitry Stepanov)

Using Elixir to Test TVs At Scale (with Dave Lucia)

Sonic Pi: Programming As An Expressive Instrument (with Sam Aaron)

Elm & The Future of Open Source (with Evan Czaplicki)

How ADHD Affects Programmers - Management Strategies That Actually Work (with Chris Ferdinandi)

MicroServices For Better And Worse (with Ian Cooper and James Lewis)

Pony: High-Performance, Memory-Safe Actors (with Sean Allen)

Architecting Bevy - A Rust Game Engine (with Alice Cecile)

Writing a CAD Language in Rust (with Adam Chalmers)

Ratatui: Building Text User Interfaces in Rust (with Orhun Parmaksız)

Designing The Lustre Web Framework (with Hayleigh Thompson)

Faust: A Programming Language For Sound (with Romain Michon)

GPUs, from Simulation to Encryption (with Agnès Leroy)

The State of Full-Stack OCaml (with António Monteiro)

Multiplatform Maps Built As Layers on Rust (with Ian Wagner)

Warp: Building a New Terminal App (with Zach Lloyd)

Building A Programming Language From Its Core (with Peter Saxton)

Practical Applications for DuckDB (with Simon Aubury & Ned Letcher)

Recording and Replaying the Browser (with Justin Halsall)

Zig as a Multi-OS Build System (with Loris Cro)

Creating and Evolving Elixir (with José Valim)

PyO3: From Python to Rust and Back Again (with David Hewitt)

Inter-System Messaging with NATS & Jetstream (with Jeremy Saenz)

Cuis Smalltalk and the History of Computing’s Future (with Juan Vuletich)

The Inko Programming Language, and Life as a Language Designer (with Yorick Peterse)

Building the Zed Text Editor (with Nathan Sobo)

How Warpstream Reimplemented Apache Kafka with Golang and S3

Extending Postgres for High Performance Analytics (with Philippe Noël)

Actor Model Programming: Building Resilient Distributed Systems (with Hugh McKee)

ByteWax: Rust's Research Meets Python's Practicalities (with Dan Herrera)

Mojo Lang - Tomorrow's High Performance Python? (with Chris Lattner)

Batch Data & Streaming Data in one Atom (with Jove Zhong)

Advanced Memory Management in Vale (with Evan Ovadia)

Bringing Pure Python to Apache Kafka (with Tomáš Neubauer)

Developing a Neovim Docker Plugin from Scratch

Taking Erlang to OCaml 5 (with Leandro Ostera)

How Apache Pinot Achieves 200,000 Queries per Second (with Tim Berglund)

Neovim: Creating, Curating and Customising Your Ideal Editor (with TJ DeVries)

The Magic of Property Testing

Creating Hackathons that Work (with Jon Gottfried)

Automate Your Way to Better Code: Advanced Property Testing (with Oskar Wickström)

Bridging the Gap Between Languages (with Martin Johansen)

How do refactoring tools work? (with Jonathan Schneider)