Lab note #056 Using version vectors

I'm back, after a little hiatus from writing the notes. Last time, I discovered that I should have been looking more deeply into other reactive models before I embarked on a functional component (React-like) model to model data pipelines. The impedance mismatch should have been indicative that something

Lab note #055 Rabbit holes leave project in shambles

Last week, I started looking at Signals. When I stepped back and looked at the entire front-end ecosystem, it seemed like many of them outside of React (Solid, Vue, Svelte, Preact), converged on some variation of Signals. There is even a Javascript proposal to include Signals in the language. Given

Lab note #054 Visualizing Execution

One of my main goals is to make non-CRUD backend pipelines more visible. I didn't think nodes and wires programming was the way to go, but unconsciously, I envisioned just showing the results of a cell next to the cell, like regular computational notebooks. But my underlying assumption

A simple way to understand CRDTs

🔰If CRDTs (Conflict-free Replicated Data Types) are new to you, check out this previous post. There's a simple way to understand CRDTs: It leverages algebra to unmix the inevitable mixing of data when syncing over an unreliable network. Why are networks unreliable? For one, it'd be

Lab note #053 Breaking from structured programming

I've been a bit anxious about the pace of progress these last three weeks. I wanted to strike a balance between making practical progress and having a sound basis. This last week, I struggled with breaking from structured programming. * What do algebraic effects buy you? * What is the

The moats are in the GPT-wrappers

Despite the disdain for "GPT-wrappers," it's currently where the value is accruing in the supply chain of value to the end-user with LLM-driven apps. Unless something changes with the foundational model companies approach the market, the GPT-wrapper application layer is where the value accrues, hence where

Lab note #052 Epx for everything

This past week, I worked through more confusion on my part. * Consolidated the representation of an algebraic effect with the React-like components (Fibers) * Worked out a solution for resuming fibers after getting a result back from from the algebraic effect. (Then block) * Use a data description of all cells (Epx)

TIL Poor man's quoting in Python

In Lisp, you can quote an expression to delay its evaluation while passing it around as a value. In Python, this means in practice, I want a function that looks like it's executing, but reality, I'm delaying its actual execution. I can use decorators to achieve

Lab note #051 Cell composition and lazy evaluation

Last week, I merged the runtime worker into the kernel worker. Originally, I wanted that to run multiple kernels at once, so users can run languages in a mix of cells, or they can run more than one cell in parallel. It was too hard to trace execution over a

Lab note #050 Prior art of a React-like runtime

I fell short this week in that I didn't do what I said I was going to do. Instead, of writing code, I went down the incremental rabbit hole. It was innocuous at first, but ended up being a full deep dive, mostly into the work of Steven

Lab note #049 Survey of Reactive and Incremental Programming

For a while now, I've been circling the drain on the Tools for Thought space and all the topics related to it. One large topic is reactivity, and not too far behind is incremental computation. They're two sides to a coin, so it's hard

Lab note #048 Basic Effects Done, Reactivity Next

I spent most of the week getting a basic algebraic effects runtime working. The initial version is single-threaded, synchronous, no typing, with a single yield from handlers. For now, it's good enough for building the proverbial skateboard. Only during implementation did I run into design questions I wouldn&