❓This is a Deep Research report with GPT o3-mini💭<goal> If I wanted to build and design an algebraic effect system in a language that didn't support delimited continuations (like python), but I wanted multi-resumption, I wouldn't be able to use generators. So how
Underlying great creations that you love—be it music, art, or technology—its form (what it looks like) is driven by an underpinning internal logic (how it works). I noticed this pattern while watching a talk on cellular automaton and realized it's "form follows function" paraphrased
I spent a good part of this week writing and rewriting a blog post, as part of my commitment to publish more this year. I wrote about 10k words, only to keep about 4k of them. Must be the sunk cost fallacy, because it feels bad to delete entire pages
With the release of OpenAI's Deep Research and its testimonies on Twitter, I finally slapped down $200/month for Pro subscription. Deep research is what I do all the time by hand anyway, I figured I'd get a lot of mileage out of it. The second
❓This was a report from GPT3o-mini with Deep Research💭What are the different ways to do handler look up in programming languages that support algebraic effects? I know sometimes, they're also called "abilities" in some languages. A starting point of languages that I know support algebraic
useEffects have a lot of footguns, especially with the dependency list. This is one of them. If I have a web worker that I need to communicate with, I need to have a message handler. The message handler needs to change the state of my frontend application. It's
I'd finished up looking into reactivity (with the exception of data type enforced reactivity, like differential dataflow), and I pulled out code with pedagogical sample code implementing signals and autotracking. * iamwilhelm/pedago_signals: A pedagogical implementation of hybrid push-pull signals in Python * iamwilhelm/pedago_autotracking: A pedagogical implementation
❓This is post is the result of a Socratic conversation I had with GPT-4o about what "syntax represented by the free monad for a functor that provides a signature." meant. After the question and answering, I asked it to write an outline of all that I learned and
I almost never remember what I did in a year. Having written reviews for 2021 and 2023, I've found it helpful to both have a record to look back on as well as a point to review and reflect. I think this should be a habit every quarter,
❓Oleg Kiselyov has a post and corresponding talk, "Having an Effect", about how to represent side effects in a language. While I watched the talk, I conversed with GPT4o about any questions I had. At the end, I had it write a blog post summarizing our conversation, with
I'm a little indisposed this week, but I did find some time here and there to do research into effects. I spent the time reading and watching a talk about effects by Oleg Kiselyov. The short version is that side-effects can be formulated as a communication protocol between
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 notes
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
Essays
🔰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 notes
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
startups
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 notes
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)
lab notes
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 notes
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 notes
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 notes
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&
lab notes
My progress on Crafting Interpreters halted when I was researching how Algebraic Effects were implemented, once I realized that I might not need all the gory details. The part I wanted to get to was understanding how closures were implemented, especially if they were relevant to getting Algebraic Effects to
OpenAI Deep Research Chats
❓Prompt: teach me the difference between yield and yield from in python. I understand yield from can replace the iterative nature of reading from a generator to get all the results. But as I understand it, it also covers a lot of other edges too, when you send stuff into
lab notes
The notebook that I want to build and use has pure functional cells. Functional cells are where the output only depends on the input. * No need to figure out the correct execution order for the notebook cells to get it in a working state. * For any change, only dependent cells