# Andrea Leopardi

> Personal website of Andrea Leopardi, a platform software engineer and Elixir core team member since 2016. Contains blog posts about Elixir, system architecture, and software engineering, along with teaching materials, talks, and open-source work.

Andrea Leopardi is a software engineer from Italy working as a platform engineer at [Knock](https://knock.app). He has been a member of the Elixir programming language core team since 2016 and is an active contributor to the open-source community. His work focuses on Elixir, distributed systems, testing, and system architecture.

He is also a public speaker, trainer, co-author of "Testing Elixir" and author of "Network Programming in Elixir and Erlang" (both published by The Pragmatic Bookshelf). This site serves as his home on the web, featuring technical blog posts, teaching resources, and information about his work.

## Main Pages

- [Home](https://andrealeopardi.com/): Introduction and overview of the site
- [About](https://andrealeopardi.com/about/): Biography, career history, and open-source contributions
- [Blog](https://andrealeopardi.com/posts/): Technical writing about Elixir, system architecture, and software engineering
- [Teaching](https://andrealeopardi.com/teaching/): Educational materials including Livebooks, screencasts, and guides
- [Books](https://andrealeopardi.com/books/): Books authored by Andrea
- [Uses](https://andrealeopardi.com/uses/): Tech stack, tools, and software setup

## Key Open-Source Projects

- [Redix](https://github.com/whatyouhide/redix): Redis client for Elixir
- [Mint](https://github.com/elixir-mint/mint): Functional HTTP client for Elixir
- [Gettext](https://github.com/elixir-gettext/gettext): Internationalization library for Elixir
- [StreamData](https://github.com/whatyouhide/stream_data): Property-based testing library for Elixir

## Notable Content

- [Interactive Guide to Asynchronous Data Processing in Elixir](https://github.com/whatyouhide/guide_async_processing_in_elixir): Series of Livebooks covering async processing patterns
- [Protohackers in Elixir](https://www.youtube.com/playlist?list=PLd7I3U4fDsULTLqbRAkWzA002-IzMe8fl): Screencast series solving network programming puzzles
- [Conference Talks](https://youtube.com/playlist?list=PLd7I3U4fDsUJfNM-N7Kyss66gmml_OSDq): YouTube playlist of public speaking engagements
- [Testing Elixir Book](https://pragprog.com/titles/lmelixir/testing-elixir/): Co-authored book about testing practices in Elixir

## Blog Topics

The blog covers technical topics including:
- Elixir language features and patterns (macros, compilation, parsing)
- TCP and network programming in Elixir
- Property-based testing and library internals
- Using C from Elixir with NIFs
- Connection management with gen_statem
- Protocol Buffers and service architecture
- Process pools and Registry patterns
- Open-source library maintenance

## Contact

- Email: hi@andrealeopardi.com
- Twitter/X: @whatyouhide
- GitHub: @whatyouhide

## Optional

- RSS Feed: Available at https://andrealeopardi.com/feed.xml for blog updates
- Post index: Available at https://andrealeopardi.com/posts/llms.txt with direct links to portable Markdown
- AI resource catalog: Available at https://andrealeopardi.com/.well-known/ai-catalog.json
- Tags: Blog posts are categorized by tags, with individual tag feeds available

## All Blog Posts

- [Elixir's GenStage Demand (a Visual Explainer)](https://andrealeopardi.com/posts/genstage-demand-visualized/) — Concurrency gives us more workers; demand tells us when to stop sending them work. This is what I want to point people to when we talk about "demand".
- [Redis Cluster Support, Without Writing Code](https://andrealeopardi.com/posts/redis-cluster-without-writing-code/) — How I experimented with building support for Redis Cluster into Redix (Elixir's Redis client) without writing code, solely relying on AI tooling.
- [Counting Fast in Erlang with :counters and :atomics](https://andrealeopardi.com/posts/erlang-counters-and-atomics/) — Two BEAM escape hatches for counting fast—shared, mutable, off-heap integer arrays. How :atomics and :counters work, what they guarantee, and when to reach for each.
- [BEAM Metrics in ClickHouse](https://andrealeopardi.com/posts/beam-metrics-in-clickhouse/) — How we are periodically dumping metrics about our most demanding BEAM processes into an easy-to-query ClickHouse table.
- [Quantified Self • 2025](https://andrealeopardi.com/posts/quantified-self-2025/) — My own sort of "wrapped" for the 2025 year.
- [How to Async Tests in Elixir](https://andrealeopardi.com/posts/async-tests-in-elixir/) — It can be hard to keep tests asynchronous as Elixir applications grow in size and complexity. Let's see why, and explore fixes.
- [Tech I Use • 2024](https://andrealeopardi.com/posts/tech-i-use-2024/) — Inspired by others doing this, here's a writeup of the things I use—mostly tech—2024 edition.
- [Reducing Compile-Time Dependencies in Gettext for Elixir](https://andrealeopardi.com/posts/refactoring-gettext-to-speed-up-compilation/) — This is how we significantly improved compilation time for Elixir projects that use Gettext, using a few metaprogramming tricks and ten years of Elixir experience since we wrote the first version of this library.
- [Verifying JWTs from Apple's App Store](https://andrealeopardi.com/posts/verifying-apple-jwts/) — A quick walkthrough on how to verify JWTs coming from Apple's App Store APIs using Elixir.
- [A Breakdown of HTTP Clients in Elixir](https://andrealeopardi.com/posts/breakdown-of-http-clients-in-elixir/) — This is an overview of the HTTP clients we have available in Elixir, as well as when to use each one.
- [Protohackers in Elixir](https://andrealeopardi.com/posts/protohackers-in-elixir/) — I'm publishing a new video series about network programming in Elixir,
where I solve the networking puzzles on Protohackers.
- [Advent of Code 2022](https://andrealeopardi.com/posts/advent-of-code-2022/) — An experiment in solving AoC 2022 with Rust and some AI (GitHub Copilot and
OpenAI's ChatGPT).
- [Get Rid of Your Old Database Migrations](https://andrealeopardi.com/posts/get-rid-of-your-old-database-migrations/) — Are database migrations good? Probably, but are we using them in the right way? In this post, I write about how I think about migrations and what I'm doing to mitigate some of their shortcomings.
- [Testing AWS in Elixir](https://andrealeopardi.com/posts/testing-aws-in-elixir/) — An overview of how we test Elixir applications that interact with AWS.
- [Example-based Tests And Property-based Tests Are Good Friends](https://andrealeopardi.com/posts/example-based-tests-and-property-based-tests-are-best-friends/) — A short look at mixing property-based tests and example-based tests to get the best of both worlds.
- [RPC over RabbitMQ (with Elixir)](https://andrealeopardi.com/posts/rpc-over-rabbitmq-with-elixir/) — A look into the RabbitMQ topology (exchanges, queues, bindings) and Elixir architecture that we use to perform RPCs over RabbitMQ.
- [Process pools with Elixir's Registry](https://andrealeopardi.com/posts/process-pools-with-elixirs-registry/) — A look at process pools and how to build routing pools (as opposed to checkout pools) using Elixir's built-in Registry.
- [Sharing Protobuf schemas across services](https://andrealeopardi.com/posts/sharing-protobuf-schemas-across-services/) — How we're managing, evolving, and sharing Protobuf schemas across several services and programming languages.
- [Persistent connections with gen_statem](https://andrealeopardi.com/posts/connection-managers-with-gen_statem/) — How we can use the gen_statem behaviour to implement a resilient state machine that holds a connection to an external service.
- [A story of regret and retiring a library from Hex](https://andrealeopardi.com/posts/a-story-of-regret-and-retiring-a-library-from-hex/) — I'm retiring a library of mine from Hex. I want to explain why.
- [The guts of a property testing library](https://andrealeopardi.com/posts/the-guts-of-a-property-testing-library/) — A look at the design and mechanics of StreamData, a data generation and property testing library for Elixir.
- [Using C from Elixir with NIFs](https://andrealeopardi.com/posts/using-c-from-elixir-with-nifs/) — An in-depth look at how to use NIFs from Elixir to run native code in the Erlang VM.
- [Compile-time work with Elixir macros](https://andrealeopardi.com/posts/compile-time-work-with-elixir-macros/) — An overview of possible things to do through Elixir macros at compile time.
- [Handling TCP connections in Elixir](https://andrealeopardi.com/posts/handling-tcp-connections-in-elixir/) — A look at some strategies to handle TCP connections and data flowing through them.
- [Tokenizing and parsing in Elixir with yecc and leex](https://andrealeopardi.com/posts/tokenizing-and-parsing-in-elixir-using-leex-and-yecc/) — A showcase of these two Erlang builtin tools and how they can be used from Elixir.