Welcome to GigaElixir Gazette, your 5-minute digest of Elixir ecosystem news that actually matters 👋.

At Gigalixir, we're the only platform built specifically for Elixir/Phoenix apps. Our goal is to give you distributed clustering, remote console, and production news without the DevOps nightmare.

. WEEKLY PICKS .

📚 Phoenix Context Confusion Finally Dies: The endless debates about Phoenix contexts stem from developers overthinking what should be obvious. ArrowSmith Labs cuts through the confusion: contexts are just modules that group related functions. That's it. The lib/app vs lib/app_web split isn't revolutionary architecture - it's basic separation of concerns.

Everyone gets paralyzed trying to design perfect context boundaries while their features sit unbuilt. Start with simple names, refactor later. The productivity lost to context anxiety far exceeds any architectural purity gains.

Stop overthinking contexts

⚡ Elixir 1.19 RC Exposes Your Build Inefficiency: Up to 4x faster compilation reveals how poorly most teams utilize their hardware. Lazy module loading eliminates the code server bottleneck that's been choking large projects, while MIX_OS_DEPS_COMPILE_PARTITION_COUNT finally lets you use all your CPU cores for dependency compilation.

If your CI pipeline takes 10+ minutes to build, you've been accepting terrible developer experience because "compilation is slow." Smart teams are already testing this RC and discovering their build problems were self-inflicted.

Benchmark the RC locally

🔒 OTP Patch 26.2.5.13 Fixes Critical Zip Vulnerability:

CVE-2025-4748 in :zip.unzip/1,2 allows absolute path traversal, letting attackers extract files anywhere on your server. This is the Erlang Ecosystem Foundation's first CVE as the new numbering authority - a wake-up call about how many teams run vulnerable OTP versions without knowing it.

Most teams discover they're affected only after checking their dependencies. The EEF becoming a CVE authority means coordinated disclosure, but it's worthless if you're still running last year's OTP because "it works fine."

Update your OTP now

🎯 BEAM History Lesson From the Architect:

Björn Gustavsson's three-decade journey building BEAM reveals the decisions that make your Elixir apps resilient. This isn't nostalgia - it's understanding why BEAM handles failures gracefully while other platforms crash spectacularly under pressure.

Teams building distributed systems without understanding their runtime foundation are flying blind. The fault tolerance you take for granted didn't happen by accident.

Watch the keynote

🧪 Testing Orthodoxy Gets Challenged:

The "Beyond Mocks" presentation introduces nullable patterns as an alternative to the brittle mocking that breaks every refactor. While most teams accept test fragility as inevitable, this experimental approach suggests infrastructure wrappers that don't require constant maintenance.

Testing strategies haven't evolved much in Elixir because "mocks work fine" - until they don't. Smart teams experiment with alternatives before their test suite becomes a maintenance nightmare.

Explore nullable testing

. PRO TIPS .

Stop Using GenServers for Read-Heavy State - ETS Eliminates the Bottleneck

Here's what everyone gets wrong: they use GenServers for everything because the tutorials say they're "safe." Your user lookups, feature flags, and configuration data don't need message-passing safety - they need concurrent access speed. That GenServer holding your session data is a single-threaded bottleneck destroying your response times.

Everyone accepts queuing thousands of read requests through GenServer message boxes while ETS tables with read_concurrency: true handle unlimited concurrent reads with O(1) performance. Duffel's feature flag system went from forming queues under load to handling concurrent access without bottlenecks. The Registry module scales to 40+ cores using GenServer + ETS, proving the hybrid approach works.

Smart teams use GenServers for complex state coordination and ETS for data access. While everyone else sends messages and waits in line, ETS lookups happen in microseconds with true parallelism. The performance gap isn't marginal - it's the difference between your app crawling under load and scaling effortlessly.

The key insight most teams miss: GenServers excel at serializing complex operations, but they're terrible for simple data access. Use each tool for what it does best instead of forcing everything through message-passing bottlenecks.

Remember, for high-performance state access:

1. ETS for read-heavy patterns - user sessions, feature flags, caching, configuration

2. GenServers for coordination - complex state changes, business logic, write serialization

3. Always use read_concurrency: true - optimize tables for concurrent access patterns

4. Measure the difference - profile your bottlenecks before and after the switch

. NO OPS. JUST ELIXIR .

Deploy your next Elixir app hassle-free with Gigalixir and focus more on coding, less on ops.

We're specifically designed to support all the features that make Elixir special, so you can keep building amazing things without becoming a DevOps expert.

See you next week,

Michael

P.S. Forward this to a friend who loves Elixir as much as you do 💜