From ea2d644940193823eaa8b23670b43fffe633d834 Mon Sep 17 00:00:00 2001 From: Aaron Stainback Date: Sat, 18 Apr 2026 22:25:04 -0400 Subject: [PATCH] =?UTF-8?q?round=2033:=20VISION=20v7=20=E2=80=94=20DX=20no?= =?UTF-8?q?rth=20star=20(ASP.NET=20DI=20=E2=86=92=20distributed=20DB=20?= =?UTF-8?q?=E2=86=92=20test=20on=20Kind)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Aaron round 33: "at the end of this any ASP.NET application should just be able to DI setup a db and boom they have a distributed database if they install on Kafka and we can test all this locally with Kind. Can you imagine how many things that could light up for any dotnet project. Your application just IS a database and your code IS stored procedures, plus LINQ and regular SQL." This is the one-sentence pitch the entire stack serves. New "Developer-experience north star" section added above Product 1 with: - services.AddZeta(...) one-liner - Kafka (or NATS/Arrow Flight/gRPC) as pluggable log back-end — events-as-truth maps cleanly to "the log IS the source of truth" - Kind for local multi-node testing (test parity with prod) - Code IS stored procedures — C#/F# methods as durable-Rx subscriptions, checkpointed, restart-safe, sharing DI with the rest of the app - LINQ + SQL + F# DSL on the same IR "What lights up" consumer-segment list: mainstream .NET (replace DbContext + Redis + cache with one Zeta), event- sourcing (SQL-speaking event store), real-time analytics (incremental plans, no Flink rewrite), audit/compliance (bitemporal for free), distributed-systems research (reference events-as-truth at scale). Co-Authored-By: Claude Opus 4.7 (1M context) --- docs/VISION.md | 56 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/docs/VISION.md b/docs/VISION.md index e093f9672..0fb084146 100644 --- a/docs/VISION.md +++ b/docs/VISION.md @@ -1,6 +1,6 @@ # Zeta — Long-Term Vision -> **Status:** round 33 v6 after Aaron's fifth pass of edits. +> **Status:** round 33 v7 after Aaron's sixth pass of edits. > Aaron is the source of truth; this document changes freely. > The `product-visionary` role (to be spawned, see > `docs/BACKLOG.md`) will steward it once it exists. @@ -51,6 +51,60 @@ This is load-bearing and worth stating first. Zeta is: Both are first-class. A decision that optimises (1) at the cost of (2) — or vice versa — is a design-doc event. +## The developer-experience north star + +Aaron round 33: *"at the end of this any ASP.NET application +should just be able to DI setup a db and boom they have a +distributed database if they install on Kafka and we can +test all this locally with Kind. Can you imagine how many +things that could light up for any dotnet project. Your +application just IS a database and your code IS stored +procedures, plus LINQ and regular SQL."* + +This is the one-sentence pitch that the whole stack serves. +Concretely: + +- **DI one-liner spin-up.** Something like + `services.AddZeta(opts => opts.UseKafkaLog(...))` → + ASP.NET app now has a distributed retraction-native + database. No separate server to run, no separate schema + migration pipeline, no separate client library. Zeta is + a NuGet package the app embeds. +- **Kafka as the distribution substrate (option).** Aaron's + preferred multi-node shape: Kafka holds the log of + events; Zeta nodes read/write to it; the `events-as- + source-of-truth` principle maps cleanly to "the Kafka + log IS the source of truth." Kafka is one option among + several — NATS JetStream, raw Arrow Flight, gRPC, + bespoke — the design round picks. Pluggable log back- + end per §Foundational Principle. +- **Kind for local testing.** A Kubernetes-in-Docker + local cluster validates multi-node Zeta + Kafka + (or chosen log back-end) end-to-end without cloud + dependencies. Test parity: same topology locally and + in production. +- **Code IS stored procedures.** C# + F# methods decorated + as durable-Rx-style subscriptions (see Reaqtor-niche + entry) run inside Zeta, checkpointed, restart-safe. + Application logic and database logic live in the + same codebase, the same types, the same DI container. +- **LINQ + SQL + F# DSL all on the same surface.** Consumers + pick their front-end per-query; Zeta routes everything + through the shared IR + operator algebra. + +What lights up for .NET consumers: + +- **Mainstream stack** — replace DbContext + Redis/Kafka + + cache + read-model projections with one Zeta. +- **Event-sourcing crowd** — finally an event store that + speaks SQL when you want it to. +- **Real-time analytics** — incremental plans over + continuously-updated tables without rewriting in Flink. +- **Audit + compliance** — append-dated history + time- + travel queries for free, not bolted on. +- **Distributed-systems research** — a reference + implementation of events-as-truth at scale. + ## Product 1 — Zeta the database ### North star