This week I got type inference back into my editor and used it to demonstrate how the first class case statements in the language work. https://vimeo.com/823083943?share=copy#t=136

A different idea of what a “tool for thought” can be! This videos shows Sam’s work on Emmy, a computer algebra system ported from Sussman’s

scmutils

, embedded in our literate programming/moldable development environment, _Clerk_:

Finally fixed glitches in Lamdu’s resize, so we can showcase our automatic layout quite nicely!

I've been working on a talk summarizing my past year or so: http://akkartik.name/freewheeling

Future of Coding • Episode 64 Donald Woods & James Lyon • INTERCAL 𒂶 https://futureofcoding.org/episodes/064 A normal episode about a normal paper about a normal language. [Really, what else is there to say?]

Hey there, we started a project where we explore novel UI designs. We call it “Adjacent Possible” in reference to Kauffman’s idea. Do check it out if you get a chance and would love to know your feedback! https://prabros.com/adjacent-possible/

Hey FoC community! I wanted to share a project we’ve been working on that we’re starting to ship more publicly called Magnet. Magnet is an AI Coding Assistant that makes it easy to use GPT-4 & ChatGPT in the context of your own codebase. It’s a desktop application that runs for MacOS (Windows coming soon) 🧲 Download Magnet here https://ww.magnet.run Here’s a little video walkthrough of how the tool works today https://www.loom.com/share/a852a9ee3c224c879c490697f5bcd22f With the new coding capabilities of LLMs we wanted to start exploring what new AI tooling for building software might look like. We’re excited for some of what is coming up as well that tries to reimagine what some of the software dev workflows might look like when there’s an AI assistant along for the ride. This first version is pretty simple but we’ve already been finding it pretty useful. It’s free to use if you put in your own OpenAI API Key so feel free to give it a spin (the hosted version uses our GPT-4 API key in case you want to try out GPT-4 and don’t have access yet).

Magnet - 1 June 2023.mp4

Slides from a recent talk of mine (at a game engine/rendering conference, but is actually very much about programming language design/impl as it relates to game engines), video still forthcoming: https://twitter.com/mirror2mask/status/1667757561960103936

Not my main work, but a fun little programming project that's relevant in a number of ways, despite apparently being more about the Past of Coding, than the Future. I wrote a small (<500 lines of code) BASIC to JS compiler, that lets me run the programs from the class book 101 BASIC Computer Games from 1978. It's interesting for two reasons I think: 1. for those who want to learn about languages and compilers, this provides a very simple example 2. philosophically, I think BASIC really exemplifies the Worse is Better approach outlined by Richard Gabriel and covered in a FOC podcast. It is a terrible language in many ways, but it was small enough to be stored in a 4k ROM and be used to to useful things on an early microcomputer with only 4k of RAM. If we had waited for machines with enough memory to run Lisp, Smalltalk or Algol, the microcomputer revolution would have been delayed by a decade or more. Source: https://github.com/kgrgreer/foam3/tree/429f2fd2b4cef0e37996a4c4ad35cdf5f83a8b97/src/foam/demos/basic Online version: https://codepen.io/kgr/details/yLQyLjR

I’ve been sketching multiplayer UIs. Folks who came to the most recent London meet will recognise these from my demo. I’m trying not to converge on anything right now — how we interact with AI NPCs is still so open. I made a new one today, with spatial multiplayer chatrooms and an NPC inhabiting each. It’s on Twitter https://twitter.com/genmon/status/1668948562460266497 An archive of all of my sketches, including a bonus gesture-controlled lamp https://www.actsnotfacts.com/made/multiplayer

with encouragement from @Joe Grossberg, down to share what I’m doing… I make lintrule.com, a little CLI for having a language model do your code review. You write rules in plain text, and then it checks them against your code, like a test framework. Here’s an example rule that runs on SQL migrations:

---
include: ["migrations/*.sql"]
---

Make sure our postgres migrations follow these rules:

1. ensure new tables are at least 3NF (third normal form). If they're not, fail and give an example of what's wrong, assuming the reader does not know terms like "BNCF", "3NF", "BCNF", and so on.
2. make sure that all tables have a created_at and updated_at
3. make sure migrations don't have breaking changes. For example, removing a table, removing column, and so on.
   3.1 It's okay to have a breaking change if there's a comment on the migration that explains why it's safe to have that change.
4. prefer 'uuid' over 'serial' or 'int' for primary keys. Ignore this check if it's primary key made up of two columns.

I've been developing documentation for my language. The nice thing about it is that all the code snippets are embedded editor instances that allow you to run and play with the examples. This week I've been writing a page to document effect types. There one of the key features of it. I've made a video where I play around with them. https://vimeo.com/837681881 Let me know if this does a decent job of explaining effect types, and particularly effect handlers.

Future of Coding • Episode 65 Laurence Diver • Interpreting the Rule(s) of Code: Performance, Performativity, and Production 𒂶 https://futureofcoding.org/episodes/065 The execution of code, by its very nature, creates the conditions of a “strong legalism” in which you must unquestioningly obey laws produced without your say, invisibly, with no chance for appeal. This is a wild idea; today’s essay is packed with them. In drawing parallels between law and computing, it gives us a new skepticism about software and the effect it has on the world. It’s also full of challenges and benchmarks and ideas for ways that code can be reimagined. The conclusion of the essay is flush with inspiration, and the references are stellar. So while it might not look it at first, this is one of the most powerful works of FoC we’ve read.

Hiya - I've got a new article in my Object Network "Lab Notes" Substack: https://duncancragg.substack.com/p/a-3d-operating-system-without-apps It would be great if you find it a stimulating read and dropped in some comments on the page!

A 20-minute video on my lived experience with Freewheeling Apps

I’ve been working on a DSL for creating mixed media pages. Markdown meets YAML and we’re about to hire some real designers to make it look normal… however if anyone would like to play with it while it’s weird and wonky you can check it out at author.quickpoint.me

Hypercard lives? :^)

I'll try to make time to play this weekend.

I'm restarting my programming productivity blog, here's the latest on CLI tool design https://codefaster.substack.com/p/how-to-design-a-cli

I've had this idea rattling in my head to make a frontend framework that's only signals, and after almost a year of maturation I finally put down some code today. Genuinely surprised this works. I'm curious where it starts to break down. It's not like modern frameworks are unaware of signals, most feature them heavily, so there's probably some reason they haven't gone all-in on them too, right? I'm using tldraw's lovely

signia

for signals implementation, hence the first param of atoms being a 'name' and not meaningful for execution. This also gave me an excuse to read `signia`'s source and discover their clever trick for tracking atom inheritance which is pretty neat.

I've started to work on a structural editor for my language coil https://coil-editor.netlify.app/ It's still early & buggy, but the idea is to directly turn the AST into html with contenteditable for leaf attribute nodes. So an expression like:

document.body

which is the coil AST:

{type: :property_lookup, lhs: {type: :id_lookup, name: "document"}, property: "body"}

Turns into:

<div data-kind="property_lookup">
  <div data-attr="lhs">
    <div data-kind="id_lookup">
      <div data-attr="name" contenteditable>document</div>
    </div>
  </div>
  <div data-attr="property" contenteditable>body</div>
</div>

And now we can easily query this expression with css selectors. So all the syntax highlighting AND formatting is done in css. It also means that static analysis can be done using querySelector.

My latest Object Network Lab Note is out! https://duncancragg.substack.com/p/the-power-of-the-link Please feel free to comment either there or here!

Added some filters and shadows to QuickPoint. "We are mere shadows and filters Horatio"

Hey Guys I've been working on a way to code in VR in an effective way. The code is open source and is available here: https://github.com/felipereigosa/kairon, for the full video where I show how it works and build a few things with it, please see here: , let me know if you like it.

Hey folks, I've been working on "Tools for thought" based on GA for a while, and I'm going to start streaming development of my current one on Tuesday at 4pm. Here's the current back catalogue although my next one will be more about coding something new and (hopefully) answering GA audience questions 🙂 here's the link I'll be streaming to https://www.twitch.tv/hamish_todd

Hey folks, I’ve just launched the beta of the side project app I shared a video about a few months ago. I’ve settled on the name Riverbed. It allows you to create mini-apps to track your personal information on cards, including columns that automatically filter your cards and buttons that allow you to configure simple actions on them. It’s maybe an “almost-no-code” system? You can choose actions from a list instead of typing in scripts. Some of the things I’m exploring include: • How many types of app this card-and-column UX is helpful for, • How much we can accomplish in this domain in an “almost-no-code” approach, where instead of a scripting language we have a set of actions to choose from a dropdown, to make it more accessible to non-programmers, and • To what degree a focus on matching the UX of non-user-configurable apps is achievable or the best use of effort It’s free to use and OSS. More info and video here, including ideas for how I might develop it in the future; I would love any input folks in this community would like to provide! https://about.riverbed.app/

Today with @Patrick Dubroy we are officially launching the Early Access of our book WebAssembly from the Ground Up: https://wasmgroundup.com/ We decided to go "digital first" to support features like interactive inspectors, code highlight on hover, REPLs for examples and other ideas from the Explorable Explanation world. The book explores the fundamentals of WebAssembly by building a compiler for a simple programming language step by step using JavaScript and OhmJS We would love to get your feedback!

(I shared a very early version of Magnet when it was just a Mac Desktop app - but now it fully runs on the web) We just shipped a web version of 🧲 Magnet https://magnet.run - an AI coding assistant. The sign ups are growing pretty quickly and there’s a lot of love from the early users. We think you’ll like it too. It’s free to use if you put in your own OpenAI API key, and over time we’ll charge for more advanced features like integrations and access to the latest unreleased models. If you’re using ChatGPT to help with coding tasks, and finding yourself copying and pasting, Magnet is similar, but built specifically for working with code. You can open local code repos, connect GitHub issues, and pick files and issues as context of for the task at hand. Try it at: https://magnet.run https://www.loom.com/share/3c5563abb08c454fabfa51ba8fcce139?sid=685cd391-86d1-49ee-ae7a-8b1dc9e9afc1 There are lots of interesting future of programming explorations we’re thinking about in the context of Magnet, and hoping to write more about it soon. Would love feedback from folks / suggestions on what you would like us to build next!