Pages on Precomputing.com

About

Mon, 01 Jan 0001 00:00:00 +0000

Precomputing is a project at an early stage. Its code works on simulated data, and four live demos run it in your browser. The next step is real traffic. This site shows where the project stands, gaps included.

Why the Project Exists

Most systems that collect events ask the same questions of them again and again. How many requests did each endpoint get, and what was the p99? What does each customer owe this month? What does the dashboard show for the last hour? The usual answer is to keep every event and compute the answer each time someone asks. That means storing everything and scanning it on every question. For logs it also means paying a vendor by volume to hold it all.

Contact

Mon, 01 Jan 0001 00:00:00 +0000

The project would like to hear from:

Teams with a stream of events who would like to try Precomputing on their own data, or run a pilot after 0.2.
Engineers with a workload, a log format or a billing rule the project should test.
Anyone with a question about the language, the demos or the figures on this site.

Write to info@precomputing.com.

If you are writing about your own data, it helps to mention what the events are, how many arrive a second or a day, which answers you need ready, how long you keep the raw events today, and where the answers should end up: an application’s database, a dashboard, an invoice or a log platform.

Live Demo: Engine

Mon, 01 Jan 0001 00:00:00 +0000

A simulated trading day of about four million stock trades runs through the Precomputing Engine, right here in your browser. The Engine turns the trades into 1-second, 1-minute and 1-hour candles and a quote board, and writes them to its SQLite file five times a second. The chart is drawn from that file with SQL, as it is written. Pull the plug on the Engine whenever you like: the candles come back the same.

Live Demo: Logs

Mon, 01 Jan 0001 00:00:00 +0000

Two hours of an invented web shop’s logs run through the Precomputing log reducer, right here in your browser. The reducer learns each kind of line as it arrives, keeps every line in a local file, and sends upstream only what a six-panel dashboard needs, plus the errors and anything new. The dashboard is then drawn from what was sent alone, and every point is checked against the raw lines.

Live Demo: Meter

Mon, 01 Jan 0001 00:00:00 +0000

A month of usage from an invented AI writing product runs through the Precomputing Meter, inside SQLite, right here in your browser. Six customers call three models through two gateways, and every request is reported to one meter. Retries arrive twice. A link goes down for six hours, and a queue sticks at the month’s end. The meter counts each request once, in the hour it happened, and September’s invoices come out exact.

Live Demo: SQL

Mon, 01 Jan 0001 00:00:00 +0000

Three hours of API traffic for a small web service run through a compiled Precomputing policy, inside SQLite, right here in your browser. The same requests are kept two ways: every request in a plain table, and the answers in the precomputed file. Watch one grow with traffic and the other with time, then check that the answers stayed right.

Simulated traffic, real SQLite. The requests come from a fixed script. The policy is compiled by the real compiler, and the SQL runs in SQLite’s own WebAssembly build.

Live Demos

Mon, 01 Jan 0001 00:00:00 +0000

Four demos run the real Precomputing code right here in your browser, each on its own kind of data. They are open to everyone with no sign-up, and nothing you do here leaves the page. Each one takes about a minute to play and ends by checking every answer it kept ready against a recount made by separate code.

Simulated data, real code. The traffic, the trades, the usage and the log lines come from fixed scripts. The compiler, the Engine, the log reducer and SQLite are the real thing, built for WebAssembly.

Roadmap

Mon, 01 Jan 0001 00:00:00 +0000

Version 0.1 shows the idea working end to end on simulated data: one language, one file, two runtimes and two products, each with a live demo. What comes next takes it to real traffic, first by closing the gaps 0.1 left open and then through pilots with teams who try it, before a 1.0 that freezes the language and the file. Durations are estimates.

The Platform

Mon, 01 Jan 0001 00:00:00 +0000

Precomputing 0.1 is one policy language and one SQLite file format, with two runtimes that keep the file current and two products built on them. The SQL runtime compiles a policy into plain SQLite triggers. The Engine runs the same policy in a Go binary with SQLite built in. The Meter counts usage for billing, exactly, and Logs keeps a log dashboard’s answers ready while the raw lines stay on site.