Hi everyone!

I'm surprised by how much can happen in just three months; below is an update of what I've been up to, random thoughts, and things worth checking out.

I finished my contract with MakeSpace in February, I can't wait for the project to become public so you can play with it — it's so much fun to meet in a space, bring notes and images with you, and see what others are looking at. The project reminds me a lot of the original Engelbartian vision of collaboration — a multiplayer Canvas for Thinking.

I worked on a couple of things with the team — starting with helping figure out some of the main questions for the product, that would guide the technology choices. Next big one was figuring out the actual engineering needed to bring that vision to the web. I've built four different rendering backend prototypes, so we'd be able to compare the performance and their advantages/disadvantages — from basic DOM rendering, through 2D <canvas>, to WebGL — including tricks like culling the viewport while still using the native browser scrollbars for accessibility. Quick, and quite unsurprising realisation is, that as difficulty grows, we can get more performance out of the web stack (we got to 10.000 items on a 5000x3000px canvas at 60FPS, without going to WASM).

We also had fun in the space itself, one of the experiments with biggest impact-to-implementation-difficulty ratio was a styling block, echoing how customisation was done in the MySpace times — by injecting snippets of global CSS. Task-Oriented End-User Programming at its finest. Since MakeSpace is built on top of CRDT, these changes propagate to all users in a given space, which allowed us to live-code the UI from within MakeSpace itself, or have each users' notes styled differently (by adding a .user-${username} CSS class so it can be targeted with a custom selector).

At flow/control, we finished a bit more conceptual consulting project with Clay. We worked on exploratory research on integrations and enrichments — basically how to make Clay a central point for connecting various web applications through a end-user programmable spreadsheet.

As for what's next? I'm going to spend a couple of months with Ink&Switch as a principal investigator. I'm excited for the opportunity to lead research projects aligned with my personal agenda.

I've had an urge to make some new music software for a while, and the idea of granular looper has been going through my head since Nótt (which featured a custom granulation mode). I grabbed Midi Fighter Twister and Norns and wrote some Lua and SuperCollider code to make Haze:

I wouldn't be myself if, along the way, I didn't build some helper tools. maiden-remote-repl is an extremely simple remote REPL connection to Maiden (a process that provides Lua REPL on Norns). Combining it with file watch script and rsync allowed me to live reload Haze on the hardware — which sped up the actual work by a lot. It's also fun to see the UI refresh almost immediately after saving a file on my laptop. In my experience, spending time on making the project development feedback loop as short and frictionless as possible always pays out.

If all goes well, I should have some exciting music news to share soon.

I've been working on Freezeframe together with Jason Yuan and Tyler Angert in hiding for a while now. We decided to tease it a bit in February:

Freezeframe is a way to capture and restore your workspaces — opened applications, windows with tabs and documents (where possible), including their spatial layout. I've wished for something like this to exist for a while, and I used to create various crutches to make parts of it happen: from writing AppleScripts to capture Safari tabs to a markdown file, through shell scripts to open multiple applications based on specific project. I'm excited for a unified interface that replaces all of this for me.

This project grew in part out of my experiments with making a tiling window manager for macOS, and trying to bend the OS to my will with my over-engineered Hammerspoon config. I have at least one friend who would ask if I was "playing around" or doing "actual work" — turns out I was doing both.

We're currently working towards an alpha release.

Finally, something a bit less technical, still nerdy, just on another axis. For almost a year now, I've been running "personal experiments" on myself. I actually used to say I'm experimenting with ... for a long time, but it was more of a figure of speech than anything else. My main issues were:

• forgetting that what I'm doing is temporary and that I can change my mind later
• forgetting to systematically review and make decisions based on the "experiments"

Luckily I didn't have to look for new software to solve my problems, but I had to devise an algorithm (an Executable Strategy after Andy Matuschak). I started creating special notes which contain:

• the main idea that I'm experimenting with
• the goals — why am I doing this, what do I hope to achieve/change, what's the ideal outcome
• scheduled checkpoints

With checkpoints, I usually leave some questions for myself, so I can compare my previous thinking with my current one. So far I've "completed" about ten experiments, and have a couple currently running (with these regular newsletters being one of them).

I backtracked on some (like not using an alarm clock in the morning), paused two (because my situation has changed), and overall allowed myself to try, what feels to me as "wilder", things out — like capping the amount of hours I'm allowed to work daily, or not allowing myself on the internet before spending some time on Doing My Own Thinking.

This is yet another application of Self-Cybernetics on myself — making my experiments visible to me, reminding myself to reflect on them, and presenting them to myself in a way that works around my psychology.

Running experiments this way was an experiment in itself (tracked within the system; so meta). I concluded it works for me, for now.

Books I've enjoyed over these last three months:

• The Dream Machine — history of computing, from invention of binary logic, Turing machine and stored procedure, up until the internet; it's probably not the only history of computing book that you should read (I have A People’s History of Computing waiting for me, that everyone recommends) but it was a fun, informative read
• A Small Matter of Programming which would be one of my recommendations for anyone interested in End-User Programming (hat tip to Adam Wiggins)
• How to Take Smart Notes which describes infamous Luhmann's Zettelkasten system in detail, and also touches on interesting topics like Where Do Ideas Come From?
• Tools for Conviviality — super dense but extremely interesting take on why modern tools might not be the best thing ever, I could draw some hand-wavy similarities to Seeing Like a State, so if you enjoyed this one it's worth checking the other one out
• About Face — an overview of the whole field of interaction design, I have a couple of other HCI classics waiting for me, so more to come
• I read The Visual Display Of Quantitative Information a long time ago, and with Tufte's new Seeing With Fresh Eyes, I've decided to grab the whole set — it's worth getting for the typesetting and layout alone, not to mention the actual contents
• I've finally finished A New History of Western Philosophy, taking detours on reading some of the original cited works, and I'm excited to dig into more specific topics next

On the web:

• Systems design explains the world
• Rasmus Andersson is working on a new thing which looks like modern take on Plan 9 (and more)
• How NASA Designed a Helicopter That Could Fly Autonomously on Mars

  We use a cellphone-grade IMU, a laser altimeter (from SparkFun), and a downward-pointing VGA camera for monocular feature tracking.

• A tour of Self
• A redditor is working on a ZUI WM
• What even is code?

Let me know what you think, and see you in a couple of months!