Wil - Interjected Future (Page 3)

Wil

Generating a histogram of all commits over time

Generating a histogram of all commits over time

👉This is a conversation with ChatGPT to ask it to help me with a task that I wouldn't have otherwise invested the time to figure out how to do. This was before ChatGPT let you share your conversations.> What would I use to generate a histogram of all the commits

Information-rich Cache

Information-rich Cache

I was surprised to learn that different stacks of software all do some type of computational analysis to better do its job. The CPU does it to figure out how to pipeline instructions. Compilers do it to feed CPUs better set of instructions. Front-end frameworks do it to figure out

Lab notes #017 Surveying Local-first Real-time Databases / Frameworks

Lab notes #017 Surveying Local-first Real-time Databases / Frameworks

One major thing I did in the last two weeks was to take a step back and review the current landscape of real-time databases and syncing frameworks. In my last essay [https://interjectedfuture.com/state-management-library-front-ends-are-looking-for-is-a-database/] , I came to the conclusion that for app architectures that want to retain state on

Imagining a sample TodoMVC with an immutable database

Imagining a sample TodoMVC with an immutable database

As an exercise to see what the developer experience might look like, I outlined what it might look like for a React-like single-page app. The app that's outlined below is a variation on the TodoMVC.

Lab notes #016 Computing deployed for operational efficiency

Lab notes #016 Computing deployed for operational efficiency

For any endeavor, there are two ends you can work on: deep technical work and finding the market. This past week was mostly spent on the latter. One of my unfair advantages is access to Bookface, where founders detail problems they face. Searching for posts on "no-code" or "internal tools"

The state management library front-ends are looking for is a database

programming Featured

The state management library front-ends are looking for is a database

State is a cross-cutting concern. Weak equivalence hinders re-rendering. Distance between code and data breeds complexity. State transitions need linear traces.

Lab notes #015 Writing about state management

Lab notes #015 Writing about state management

This past week was spent researching and reminding myself of the core problems of building interactive apps and addressing state management problems. * React I Love You, but You're Bringing Me Down [https://marmelab.com/blog/2022/09/20/react-i-love-you.html] * Get in Zoomer, We're saving React [https://acko.net/blog/

Lab notes #014 Revisiting Requirements

Lab notes #014 Revisiting Requirements

The persistent data structure in Datomic is used as a live index for querying. However, it's unique in that it saves itself to a storage-backed key/value store in segments–continuous pieces of data akin to the data in the leaf nodes of a trie. By fetching a key/value

Lab notes #013 Inserting keys beyond capacity

Lab notes #013 Inserting keys beyond capacity

Spent the week fixing issues with insertion, mostly with different edge cases. Was able to solve an issue with inserting at the beginning and the end of the trie. The edge case was that take_left and take_right should take into account when we take everything or take nothing.

Lab notes #012 Taking right and left and the case of the weird iterator

Lab notes #012 Taking right and left and the case of the weird iterator

After the iteration over values was done, it was quick work to write tests for concatenation and make sure that it was working correctly. Then the time thereafter was some cleanup and moving stuff out to their own files. The work this week to implement take_right and take_left,

Persistent Data Structure Redux

Persistent Data Structure Redux

This is a review of all the resources I found and learned about persistent data structures in the course of looking for a solution for maintaining state. Complexity from maintaining state One of the hard things about programming is how to maintain and manage state [https://interjectedfuture.com/the-broken-half-of-interactive-programs/], especially

Lab notes #011 value iteration and the LLM assistance problem

Lab notes #011 value iteration and the LLM assistance problem

This week was a little different. The implementation work was supposed to be fairly trivial, but in practice, it took a lot of time. The implementation was for an iterator that iterates over all the values in the RRBT in order. In theory, it's pretty trivial. The core concept is

Lab notes #010 4th time's the charm to rewrite append

Lab notes #010 4th time's the charm to rewrite append

Most of this week has been spent rewriting `append()`. This stemmed from mostly following the pseudocode from the L'Orange paper [https://hypirion.com/thesis.pdf] too closely. Excited about ChatGPT, I used it to convert the pseudocode to Rust code and tried to go from there. However, in the end,

Lab notes #009 Concatenation and Append

Lab notes #009 Concatenation and Append

Took a bit of a break, but have been back at it. The most involved part of implementing the relaxed radix balance trie is the concatenation. I had to consult three [https://hypirion.com/thesis.pdf] different [https://raw.githubusercontent.com/nicolasstucki/scala-rrb-vector/master/documents/Master%20Thesis%20-%20Nicolas%20Stucki%

Lab notes #008 Details are in the ID

Lab notes #008 Details are in the ID

I'm usually not hung up about the programming language I use, but given Jamie's take [https://www.scattered-thoughts.net/writing/assorted-thoughts-on-zig-and-rust/], I did some deliberation about whether to use Zig or Rust. I ended up going with Rust, because I'm not a seasoned systems programmer, so I figured having the

Lab notes #007 Reuse not possible

Lab notes #007 Reuse not possible

While moving forward through the implementation, it wasn't clear how the indexing worked in detail. How do you determine what segments were different between the live and storage-backed indices? By definition, aren't all segments in the live index novel? But more worryingly, what is the key used to store the

Lab notes #006 Categories redux

Lab notes #006 Categories redux

A good part of the week was spent reading and watching talks on "The simple essence of automatic differentiation". I got the gist the first go around but much of the details were opaque to me. Reading it this second time around and actually working through the examples helped with

Lab notes #005 Moving on from the low level

Lab notes #005 Moving on from the low level

Reading more papers, mostly focused on Relaxed Radix Balanced Trees, since other trees, such as B-trees, Finger Trees, and HAMT trees seem to predate the research on this one. The premise is generally pretty simple, but the devil is in the details. The papers on it are fairly clear. I

Lab notes #004 Index construction with trees

Lab notes #004 Index construction with trees

Watched lectures and read papers on persistent trees, and come away feeling like it's a rabbit hole. I initially found it difficult to implement a B+-tree in Rust, due to ownership rules, so I stopped. As much of an advantage it would be to have these things implemented, it's a commodity.

Lab notes #003 Database as Value in Depth

Lab notes #003 Database as Value in Depth

I spent a bunch of time mapping out the architecture of Datomic in detail. Diving into all the details revealed all the different places my knowledge was spotty, or where Rich Hickey glossed over the details. * Are the internal nodes of the storage-backed index only in memory, or are they

Lab Notes #002 Found embedded database

Lab Notes #002 Found embedded database

For the programming environment, I wanted a database embedded in it. I had stuided the architecture of Datomic, and it seems a convincing architecture to solve the problem of creating offline apps distributed online. However, Datomic is proprietary, and there isn't an official corresponding client side database either. I'm hesitant

Compiling Composable Reactivity

Compiling Composable Reactivity

What if the changes to the input result in state changes that can't be computed fast enough to keep the user interface snappy for an interactive program? Reactivity to the rescue. It's a way to drastically reduce the amount of computation required to compute an output given a change to the input.

The Broken Half of Interactive Programs

The Broken Half of Interactive Programs

While most front-ends today have largely agreed on the design of the rendering subsystem, we seem to be grappling with design of the interactive subsystem.

Destroyed at the Boundaries

Destroyed at the Boundaries

Shared mutable state invites complexity into our programs. Programming languages help with this complexity inside a program, but not across network boundaries between programs.

Year in Review

A review of the wanderings in 2021, and a focus for 2022.