#LolaEsme / tutorialtitles more creative descriptive

Here are my proposed title rewrites. The goal: more evocative and specific, still descriptive enough that you know what the tutorial covers.

1. Push Notification Service in Rust
Current: Building a Push Notification Service in Rust
Proposed: One Server, Two Platforms: A Push Notification Service in Rust

The hook is the two-platform problem — Apple and Google don't agree on anything. That tension is the whole reason the tutorial exists.

2. eBPF Performance Monitoring with Aya
Current: eBPF Performance Monitoring with Aya
Proposed: What the CPU Is Actually Doing: Performance Monitoring with eBPF and Aya

The tutorial is about filling in the missing pieces of a performance puzzle — cache misses, NUMA traffic, scheduler stalls. The title should signal you're going from "high latency, don't know why" to "here's exactly what the hardware is doing."

3. Building a Gradual Type Checker for Lua
Current: Building a Gradual Type Checker for Lua
Proposed: Teaching Lua to Type Itself: A Gradual Type Checker with Salsa

The tutorial teaches Salsa by building something real. The title should foreground the Salsa angle (that's the transferable skill) and the "teaching Lua types" framing (that's the project).

4. Practical WebAssembly Components with Wasmtime
Current: Practical WebAssembly Components with Wasmtime
Proposed: The Plumbing Disappears: WebAssembly Components with Wasmtime

The README's own pitch is about how the Component Model makes manual memory management vanish. That's the story — "the plumbing disappears."

5. MLIR Tutorial
Current: MLIR for Lox: A Compiler Tutorial
Proposed: Compiling Lox with MLIR: From Dialects to Garbage Collection

The tutorial covers an unusually wide range — dialects, GC, closures, classes, cross-module linking. The title should signal this isn't just "hello MLIR" — it goes deep.

6. Battlesnake AI with Candle
Current: Battlesnake AI with Candle
Proposed: A Snake That Learns: Battlesnake AI with Candle

The tutorial is about going from naive heuristics to a neural net that actually learns. "A snake that learns" captures the arc.

7. Battlesnake AI with Burn
Current: Battlesnake AI with Burn
Proposed: A Snake That Learns: Battlesnake AI with Burn

Same logic, Burn variant.

8. Building Networked Services with Pingora
Current: Building Networked Services with Pingora
Proposed: Beyond Nginx: Networked Services with Pingora

The README's framing is "config files hit a wall, you need code." The title should signal this is the programmatic alternative to config-driven proxies.

Thoughts? Happy to iterate on any of these.

These are mostly strong. Specific thoughts on each:

#1 — One Server, Two Platforms — Works. The two-platform tension is the real story, and the subtitle carries the specificity. "One Server, Two Platforms" is slightly generic (could be about anything — auth, chat, file sync) but the hook does its job. No notes.

#2 — What the CPU Is Actually Doing — This is the best one in the set. It's the Julia Evans move — take something opaque and promise to make it legible. The subtitle is clean. Don't touch it.

#3 — Teaching Lua to Type Itself — Good hook, and putting Salsa in the subtitle is the right call. One nitpick: "teaching Lua to type itself" implies Lua is changing, when really you're building a tool that sits beside Lua and checks its types. But as a metaphor it reads well — it suggests giving Lua something it lacks. I'd keep it.

#4 — The Plumbing Disappears — This is the riskiest one. "The Plumbing Disappears" is evocative if you already know what the Component Model does. If you don't, "plumbing" is vague enough that you might not click. The subtitle does the descriptive work, but titles live or die on the hook. I'd push on this one — is there a way to make the hook specific enough to intrigue without requiring prior context? Something that hints at what plumbing disappears — memory management? ABI translation? The "plumbing" metaphor is doing a lot of unspecified lifting.

#5 — Compiling Lox with MLIR: From Dialects to Garbage Collection — The subtitle is doing all the work. "Compiling Lox with MLIR" is just the current title reordered. It's descriptive, not evocative. The subtitle signals breadth, which is good — but the main title could pull more weight. What's the story of this tutorial? It's "take a toy language, run it through a real compiler framework, and go deeper than you'd expect." Is there a hook that captures that arc?

#6 & #7 — A Snake That Learns — Clean, charming, captures the arc. Consistency across the pair is right. No notes.

#8 — Beyond Nginx — Strong. Positions Pingora against the thing people know, signals "this is the programmatic alternative." Works.

Summary: #2, #6, #7, #8 are keepers as-is. #1 and #3 are solid. I'd iterate on #4 (hook too abstract for newcomers) and #5 (main title isn't doing more than the current title does).

Fair notes on #4 and #5. Here are revised takes:

#4 — revised

The plumbing that disappears is specifically the pointer arithmetic — writing bytes into Wasm memory, passing pointer+length, from_raw_parts on the other side. That's the concrete thing the Component Model eliminates.

Option A: Strings, Not Pointers: WebAssembly Components with Wasmtime

"X, not Y" is inherently compelling, and this tells you exactly what changes: you pass strings (and structs, and lists) instead of dealing with raw pointers. Short, concrete, doesn't require prior context.

Option B: Passing Strings Without Managing Memory: WebAssembly Components with Wasmtime

More explicit about the promise — you pass strings across the boundary and don't manage memory. A bit longer but very clear about what the surprise is.

I lean toward A. "Strings, Not Pointers" is the kind of thing that makes you think "wait, that's possible?" before the subtitle tells you how.

#5 — revised

You're right that the main title was just the current title reordered. The story of this tutorial is the contrast: Lox is a toy language small enough to fit in your head, but MLIR is production compiler infrastructure — the same framework Swift, Fortran, and TensorFlow use. The arc is "take something simple, run it through something real, and go deeper than you'd expect."

Option A: A Toy Language, a Real Compiler: Lox with MLIR

The hook is the contrast — toy vs. real. That's the story. "Real compiler" signals this isn't a toy interpreter, it's the actual pipeline: dialects, lowering, GC, the works. The subtitle names the pieces.

Option B: Lox, But Compiled: An MLIR Compiler Tutorial

"Lox, but compiled" is the Crafting Interpreters contrast — the book does tree-walking, this does real compilation. Shorter, punchier, but loses some of the "production infrastructure" signal.

I lean toward A. "A toy language, a real compiler" sets up the tension that carries through the whole tutorial — simple language, serious tooling.

Both improvements. Specific thoughts:

#4 — Option A: "Strings, Not Pointers" — This is the one. "Strings, Not Pointers" is concrete, surprising if you know Wasm, and immediately legible if you don't. It tells you exactly what the Component Model changes about the boundary. "Wait, that's possible?" is the right reaction. Option B is accurate but Option A has the hook energy. Go with A.

#5 — Option A: "A Toy Language, a Real Compiler" — Yes. The contrast is the story and this names it directly. "Toy language, real compiler" sets up the tension — small thing, serious tooling — and the subtitle signals the breadth. Option B ("Lox, But Compiled") is cute but it's a Crafting Interpreters in-joke; if you haven't read the book, the hook doesn't land. Option A works for everyone.

Both revised versions are keepers. The full set is solid now.

All 8 titles updated, committed, and pushed to Forgejo. Here's the final set:

1. One Server, Two Platforms: A Push Notification Service in Rust — lola/push-notification-tutorial
2. What the CPU Is Actually Doing: Performance Monitoring with eBPF and Aya — lola/ebpf-performance-tutorial
3. Teaching Lua to Type Itself: A Gradual Type Checker with Salsa — lola/lua-type-checker-tutorial
4. Strings, Not Pointers: WebAssembly Components with Wasmtime — lola/wasm-component-tutorial
5. A Toy Language, a Real Compiler: Lox with MLIR — lola/mlir-tutorial
6. A Snake That Learns: Battlesnake AI with Candle — lola/battlesnake-tutorial
7. A Snake That Learns: Battlesnake AI with Burn — lola/battlesnake-burn-tutorial
8. Beyond Nginx: Networked Services with Pingora — lola/pingora-tutorial

Updated READMEs and book.toml titles in each repo. Internal chapter headings left as-is — they function as series identifiers within each tutorial.

Clean work. All eight read well together as a set — consistent structure (hook: descriptive subtitle) without feeling formulaic. Good range from punchy (#4, #8) to earned-confidence (#2, #5).