A month after building that construction SaaS prototype, I found myself working on something completely different: reimagining distributed programming paradigms in Java. Context: Building Wavefront taught me the value of solid infrastructure foundations. We chose FoundationDB as our key-value store, and over the years I became fascinated by what made it so remarkably reliable. The answer wasn't just the ACID guarantees or the distributed architecture - it was Flow, their internal actor framework that enables single-threaded, cooperative multitasking with deterministic simulation. Flow lets you write code like this: ACTOR Future<int> processRequest() { state int value = wait(readDatabase()); wait(delay(1.0)); // Non-blocking delay return value * 2; } Sequential-looking code that's actually asynchronous. No callbacks, no complex threading, just cooperative yielding with full determinism for testing. The Java Reality: Meanwhile, we're still wrestling with CompletableFuture chains that look like this: service.getData() .thenCompose(data -> processData(data)) .thenCompose(result -> saveResult(result)) .whenComplete((value, error) -> handleCompletion(value, error)); Reactive streams offer power but complexity. Virtual threads from Project Loom are impressive, yet they lack task prioritization and the deterministic execution that makes distributed system testing tractable. Enter JavaFlow: I spent the last few months reimagining Flow's core ideas in idiomatic Java, leveraging JDK 21's continuations. The goal: cooperative multitasking with deterministic simulation, but without requiring a custom compiler. FlowFuture<String> result = startActor(() -> { String data = await(fetchData()); await(delay(1.0)); // Cooperative yield for 1 second return processData(data); }); What's implemented: actors, cooperative scheduling, timers, async file I/O, and an RPC framework. All operations integrate seamlessly with the event loop, maintaining deterministic execution. The key insight from FoundationDB holds: when you can simulate your entire distributed system in a single thread with controllable time, you can test scenarios that would be impossible in production. I put Claude Code through its paces on this project. Still requires significant supervision, but Opus 4 shows meaningful improvements. The trajectory is promising. Why this matters: Modern distributed systems are inherently asynchronous, yet our programming models often fight against this reality. JavaFlow attempts to bridge that gap - maintaining the performance benefits of event-driven systems while preserving the readability of sequential code. The project is on Maven Central (io.github.panghy:javaflow) and fully open source: github.com/panghy/javaflow This is experimental work - I don't yet know if it solves real problems or remains an interesting academic exercise. #DistributedSystems #AsyncProgramming #Java #FoundationDB #EIR #TechInnovation