Future of Coding Weekly

A little experiment with scrollbars

🎥 scrollbar

Share Your Work

🗨️ When Leggett: 📝 for Server User-Agents

https://its.whenthetimeca.me/p/for-server-user-agents

So I spent most of last week in Mountain View for the 41st Internet Identity Workshop. While I was there, I was advocating for something that I've been calling Server User-Agents, and I think they're a fundamental missing piece of architecture

This week I spent time putting my notes and conversations together and wrote a deep article about the concept, although it is still very early and intentionally a loose sort of spec. Its more a call for participation.

📝 for Server User-Agents

Notes from the 41st IIW

for Server User-Agents

🗨️ When Leggett:

I think its relevant to this community too, although maybe a little outside the center

🗨️ Eli:

🧵 conversation @ 2025-11-01

Here is a little work in progress snippet of a thing. It applies a heat map kinda color scheme to git diffs, the idea being that its rules can be tuned to call out places in the code that need closer attention when reviewing the diff. The rules are very much still a work in progress, and I'm super duper open to suggestions for ways to approach creating these rules.

Rambling video, be warned. I apologies for having the crunchiest, noisiest mouse wheel ever in the history of the recorded universe. Its like an ASMR halloween nightmare.

🎥 video

DevLog Together

🗨️ Tom Larkworthy:

Notebook kit ships with themes, so I can reuse them for the Lopebook. I think they look better than the original!

Happy about how they are implemented, they use CSS imports, which resolve through es-module-shims, so I can serve them locally, and fallback to network. This means the local file includes just the current theme, and you do a network fetch only when changing themes, keeping the bundle size small and local-first.
Also thanks to the magic of es-module-shims, the CSS is fetched directly from Github raw URLs, as I can switch the content-type to test/css programatically. es-module-shims is so powerful for local-first stuff.

🎥 styles

Linking Together

🗨️ Tommy Palmer: 📝 Everything Is Television

🧵 conversation @ 2025-10-29

I’m a bit of a lurker here (can’t even remember if I did an intro post) but I thought people might like this 📝 Everything Is Television

A theory of culture and attention

🗨️ guitarvydas:

a bunch of links to various books about smalltalk, maybe of interest (to me, part 4 of the blue book is quite interesting)

🗨️ Konrad Hinsen: 🎥 PROG Rock: Listening to old Lisp code

PROG Rock: Listening to old Lisp code

🗨️ Jon Tran: 📝 Five Pillars of Pipe

🗨️ Ivan Reese:

🧵 conversation @ 2025-10-29

Folks who came out to the SF meetup, and others besides, might find this new pseudo-rebirth of cohost as a bunch of federated websites intriguing. I certainly do.

Present Company

🗨️ Jon Tran:

The company I work for has an open role to work on a programming language for mechanical CAD. The project was originally inspired by sketch-n-sketch, where you can draw/edit in the scene and it updates the code, and vice versa. We're also working on integrating a constraint solver. The GUI, interpreter, and solver are open source. I'll put details in the thread.

👨🏽‍💻 By 🐘 @[email protected] 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2025/10 Week 4

2025-10-26 23:16

🌳 Cope and Drag: DSL for gradually improving diagrams 📝 Simple Assembler and Simple CPUs First 🎥 ROONS! A new marble computer

Share Your Work

🗨️ guitarvydas: 📝 Simple Assembler and Simple CPUs First

🧵 conversation @ 2025-10-26

DevLog Together

🗨️ Tom Larkworthy:

Nearly got the new serialisation format complete. Its self serializing and its forking fast!
The new foundations have less coupling to Observable. You can store files in it and read them using web APIs like fetch, XHR, dynamic imports and script tags. This is enough to boot Observable up and also to serve all its network calls in the std library locally without any modification to the 1st party source. I am considering spinning the serialisation format out as a separate project as its quite generic but I feel that would be a distraction so I will not but essentially it provides a virtual web inside a single static file. A bit like service-workers but without additional files or a webserver dependancy

🎥 forking fast

Thinking Together

🗨️ guitarvydas: 📝 Efficient Function Nesting

🗨️ Jonathan Frederickson:

🧵 conversation @ 2025-10-20

Folks, I'm looking for help finding a project that I ran across a while back that's adjacent to some of the visual-programming stuff we like here. It was a node-and-wire style infrastructure deployment tool, I think specifically for AWS, that would take care of setting up IAM rules for communication between components with wires connecting them.
I feel like I might have run across it either here, or while looking up something about the now-gone node-and-wire web interface for Canonical Juju.
Also starting to feel like I might have dreamt it up though!

Linking Together

🗨️ Tom Larkworthy:

Wow this has feels.
https://observablehq.com/@jwolondon/making-plot-sketchy

📷 image.png

🗨️ daniel g. siegel: 📝 Anticipate

🧵 conversation @ 2025-10-21

Here's a take on how AI could really benefit and augment our thinking by exploring how it can support reflection and decision making rather than make choices for us: https://www.bigideainitiative.org/ideas/anticipate

This was done by a collaborator of ours, Niklas Muhs.

Anticipate explores how AI can augment design thinking by uncovering hidden assumptions and navigating uncertainty, leading to more informed and creative decisions.

Anticipate

🗨️ Beni Cherniavsky-Paskin:

🧵 conversation @ 2025-10-26

"Cope and Drag" mini language for gradually constraining/improving diagrams 🍰. See paper for details but as usual with PLT blog, the post gives good background.

They built this in context of formal methods, but I think the mixed approach of "user can drag nodes + partially automate via constraints" has wider applicability.

📷 bildo.png

🗨️ Daniel Garcia: 🎥 ROONS! A new marble computer

ROONS! A new marble computer

Present Company

🗨️ Maikel:

🧵 conversation @ 2025-10-24

Next wednesday 29th October is our monthly FoC meetup (see the announcement channel for details).. we still have 2 spots for demo's left, who dares on this special edition?👻

👨🏽‍💻 By 🐘 @[email protected] 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2025/10 Week 3

2025-10-20 10:08

🧬 Literate tracing 🧵 Undetermined Weaving with Machines 📑 Early Interpreters

Share Your Work

🗨️ Mariano Guerra: 🎥 vibecard: todo app speedrun using macros

live coding a todo app faster than the previous one with the help of a new vibecard feature: macros

vibecard: todo app speedrun using macros

🗨️ Matt Curtis: 🌐 Matt Curtis

🧵 conversation @ 2025-10-13

since I'm starting my search for fulltime roles I did something I've managed to avoid doing for years now and made a (dundun) personal website

also trying to make more things that are sort of... just for me, you know?

anyway, idk if any of you have used Astro before (it's sort of similar to Gatsby, if you're familiar with that) but I used it for this and it's pretty neat. near first-class support for turning markdown into pages and querying and sorting collections of markdown. really great if you're building a text-heavy site. plus you can pull in components from your UI framework of choice, like React or Vue.

also got to play with a few SVG/CSS animation features I've never had the chance to fully use in a production site

would love to get any thoughts the folks here have! i feel like personal sites are sort of becoming more rare (might be just me, though)

The personal site of Matt Curtis

Matt Curtis

DevLog Together

🗨️ Tom Larkworthy:

One lame issue is Notebook 2.0, it does not support importing other Notebook 2.0s which kinda breaks my plan.
Upvote the feature request here https://github.com/observablehq/notebook-kit/issues/96 (they will do it and its a matter of when)

🗨️ Ivan Reese:

🧵 conversation @ 2025-10-19

Now that FoC stands for "feeling of computing", I can share this — I recently built a new website for Automerge, along with the absurdly talented designer Todd Matthews. The site includes an interactive demo and a bunch of illustrations that attempt to give newcomers a sense of what Automerge does. Like, on one level, we say what it does quite directly with words. But I think it's good to also try to, like, show that somehow, even though it's occasionally a bit abstract.

It was a deeply rewarding challenge, coming up with visuals where every detail (dash patterns, directions of lines, use of shapes) had to be both pleasing to look at but also true to the meaning, and consistent with the other meanings.

You can take something technical — "everyone has their own copy of the data, changes queue, you sync with your peers, everything converges on a consistent state" — and put that into imagery.

Now, of course, I want to actually use the imagery to do the technical thing.

🗨️ Tom Larkworthy:

Been thinking how Observable Notebook 2.0 format helps me. I conclude, that kind of transformation should NOT be in the low level. To run Notebook 2.0 you need compilers, but to run Lopecode the format is the low level raw JavaScript so Notebook 2.0 format puts specialised parsers/compilers in the loading path. Compilers and language choices should be in userspace, where they can be changed by the user. So I will revisit Notebook 2.0 when I have fixed the lower layer. I think it be neat as a userspace module.

So I return to where I left off. Bugs in importing from the net. I am redoing the foundational technology. I ditched importmaps and moved over to es-module-shims. It has allowed me to fix a problem that locally loaded models could not be deduped with network imported ones, which ends up causing semantic issues. importmaps are 1-way doors, es-module-shims gives you total control over import semantics at any point in time. Its a really amazing piece of software I recommend learning how it works. It has a C written Lezer parser doing the minimum parsing possible in the fastest possible way to read source code and swap "import" for "importShim" thus enclosing all import calls with a wrapper for customization.

Anyway, in the process I noticed defining the stdlib in the system space was also questionable because half those libs are broken (duckdb) and it takes up 50% of the system overheads for a large amount of extraneous code. Notebook 2.0 redid the stdlib => stdlib is subject to churn. So by a similar argument the stdlib definition should be in userspace too.

I spent a weekend on it and got surprisingly far. I can display some things, es-module-shim dedupuing seems to work and I added a userspace boot module that defines the stdlib and then loads the main module which I think its an improvement and allows the serialization format bootstrap process to be very small (26Kb). In that 26Kb you get a hot swapping reactive runtime and total control over ESM import semantics in a local-file.

📷 image.png

Thinking Together

🗨️ maf:

🧵 conversation @ 2025-10-15

Re adversarial interoperability - just figured out a fun approach. Most devices can share their screen over Miracast / AirPlay / something similar (last resort is HDMI cable). Most devices can also receive input from Bluetooth devices (alternatively, through USB cable). So as an alternative to accessibility APIs (or X11, or WinAPI input injection), one might set up another device that would spoof a Miracast display, a bluetooth mouse & a bluetooth keyboard. Such reflector could be implemented in a very cheap form factor (like a tiny ESP32) and allows another app on the original device to effectively bypass all access controls that the OS-es (especially mobile) impose.

It's not a security vulnerability per-se, since it requires the device owner to cooperate - just an interesting way to interop.

📷 shapes at 25-10-15 19.15.08.png

Linking Together

🗨️ Kartik Agaram:

🧵 conversation @ 2025-10-15

Literate tracing [pdf]

Augments Literate Programming with primitives for running a program on specific inputs and probing the values of specific variables after.

Augments the markup language with some way to define custom pictures. But I can't quite tell what the markup for that looks like.

📷 literate-tracing.png

🗨️ Kartik Agaram: 🎥 Micro Maker Series: Underdetermined Weaving with Machines

🧵 conversation @ 2025-10-19

Lea Albaugh, "Undetermined Weaving with Machines" [video; 1 hour]

"How do we carve out a chunk of the possibility space of weaving that makes viable and interesting fabrics?"

Paper

Micro Maker Series: Underdetermined Weaving with Machines

🗨️ guitarvydas:

Early Interpreters
Smalltalk “Blue Book” (esp. Part Four) http://stephane.ducasse.free.fr/FreeBooks/BlueBook/Bluebook.pdf
Tiny Basic (including tiny basic virtual machine) https://archive.org/details/dr_dobbs_journal_vol_01/page/n5/mode/2up
Frits van der Wateren Lisp (Lisp 1.5) (esp. LISP.TXT) https://github.com/guitarvydas/frits-van-der-wateren-lisp
SmallC (strictly not an interpreter, but a compiler (I learned about compilers from this code)) https://archive.org/details/dr_dobbs_journal_vol_05_201803/page/n189/mode/2up, https://github.com/trcwm/smallc_v1

📝 Dr. Dobb's Journal - Vol 1

Collected issues from Volume 1 (1976) of Dr. Dobb’s Journal of COMPUTER Calisthenics & Orthodontia also known as DDJ.A Reference Journal for Users of Home...

Dr. Dobb's Journal - Vol 1 : People's Computer Company : Free Download, Borrow, and Streaming : Internet Archive

📝 Dr. Dobb's Journal - Vol 5

Collected issues from Volume 5 (1980) of Dr. Dobb’s Journal of COMPUTER Calisthenics & Orthodontia also known as DDJ.A Reference Journal for Users of Home...

Dr. Dobb's Journal - Vol 5 : People's Computer Company : Free Download, Borrow, and Streaming : Internet Archive

Future of Coding Weekly 2025/10 Week 2

2025-10-12 23:07

📔 Architecture for a multilingual Wikipedia 🚇 Subway Builder 🎥 VibeCard: a todo list app in 5 minutes and 1 line of js

Share Your Work

🗨️ guitarvydas: 📝 The Marketing of C & 📝 Hardware Stockholm Syndrome

🧵 conversation @ 2025-10-06

🗨️ Denny Vrandečić: 📔 Architecture for a multilingual Wikipedia

🧵 conversation @ 2025-10-07

I think I shared this before, but Ivan told me to share this again because he thinks it is fascinating: I am working on a project called Wikifunctions. Wikifunctions was built in order to support Abstract Wikipedia, as described in this paper introducing Abstract Wikipedia and Wikifunctions. It is a short paper (here's the PDF), but there is also a long version with far more details.

The goal of Wikifunctions is to allow for the creation of Abstract Wikipedia, to create natural language text from a language-independent notation anyone can edit directly, using functions from Wikifunctions. These functions are aimed to be writeable and maintainable also by non-programmers.

So far, Wikifunctions has collected a catalog of more than 3100 functions, in diverse areas such NLG, chemistry, maths, colors, etc.

📔 Architecture for a multilingual Wikipedia

Wikipedia's vision is a world in which everyone can share in the sum of all knowledge. In its first two decades, this vision has been very unevenly achieved. One of the largest hindrances is the sheer number of languages Wikipedia needs to cover in order to achieve that goal. We argue that we need a new approach to tackle this problem more effectively, a multilingual Wikipedia where content can be shared between language editions. This paper proposes an architecture for a system that fulfills this goal. It separates the goal in two parts: creating and maintaining content in an abstract notation within a project called Abstract Wikipedia, and creating an infrastructure called Wikilambda that can translate this notation to natural language. Both parts are fully owned and maintained by the community, as is the integration of the results in the existing Wikipedia editions. This architecture will make more encyclopedic content available to more people in their own language, and at the same time allow more people to contribute knowledge and reach more people with their contributions, no matter what their respective language backgrounds. Additionally, Wikilambda will unlock a new type of knowledge asset people can share in through the Wikimedia projects, functions, which will vastly expand what people can do with knowledge from Wikimedia, and provide a new venue to collaborate and to engage the creativity of contributors from all around the world. These two projects will considerably expand the capabilities of the Wikimedia platform to enable every single human being to freely share in the sum of all knowledge.

🗨️ Mariano Guerra: 🎥 VibeCard: a todo list app in 5 minutes and 1 line of js

🧵 conversation @ 2025-10-10

Initial release of VibeCard, try it here: https://marianoguerra.github.io/vibecard/

VibeCard: a todo list app in 5 minutes and 1 line of js

🗨️ Daniel Coutinho Ribeiro:

🧵 conversation @ 2025-10-12

can i get your thoughts on my project: https://github.com/creact-labs/creact

DevLog Together

🗨️ Arcade Wise:

🧵 conversation @ 2025-10-08

I've been working on an app that provides a user-friendly interface to Linear Programming solvers, specifically for resource allocation problems. I have a UI that works, and it is getting data into the solver, however I don't think I'm setting up my solver correctly yet :0

📷 image.png

Thinking Together

🗨️ Daniel Harris: 🎥 shopping interface

🧵 conversation @ 2025-10-11

What the hell am I doing? I've built (with AI) a mock up of a shopping interface where I can make it more complex and more simple. But in a usable, production version of this I'm imagining nothing in the user interface is hardcoded and the UI responding to a variable quality of complexity. But how would we go about encoding the interactive elements so that we could filter based on the quality of complexity? And how do we do this for other quality vectors? How do we take a slice through a set of interactive logic? How do we represent the logic of interaction? I don't really know how I got here. But now that I have I need your help to figure out how we do this without AI. Because I want to do this not just for a shopping interface but for all my computing. I want malleable interfaces and interactions where I can filter qualities of the interface easily. If you don't know, then take a guess because I'm after any threads I can get. Cheers!

🎥 shopping interface

shopping interface

Linking Together

🗨️ Arcade Wise: 🚇 Subway Builder

🧵 conversation @ 2025-10-09

Y'all may appreciate this new indie game whose development I've been following, where you get to build a subway system based on modern US census data! The dev manually recreated the Apple Maps style in WebGL too.

https://www.subwaybuilder.com/

A game for building your own realistic subway system

🗨️ Jasmine Otto:

🧵 conversation @ 2025-10-11

thinking about Kartik Agaram's lenses of malleability & literacy https://akkartik.name/post/2025-06-12-devlog
in relation to rich discussions of annotation, embedding, & extension at LIVE workshop

Orion Reed and I submitted a positional paper for LIVE 2025 called "Live Programming in Hostile Territory". Now that it's been accepted, I'm excited to hear peoples thoughts and feedback! It touches on a topic wider than just live programming and, at least to me, is very relevant to the FOC community. Here is the abstract:

Live programming research gravitates towards the creation of isolated environments whose success is measured by domination: achieving adoption by displacing rather than integrating with existing tools and practices. To counter this tendency, we advocate that live programming research broaden its purview from the creation of new environments to the augmenting of existing ones and, through a selection of prototypes, explore three _adversarial strategies_ for introducing programmatic capabilities into existing environments which are unfriendly or antagonistic to modification. We discuss how these strategies might promote more pluralistic futures and avoid aggregation into siloed platforms.
https://folkjs.org/live-2025/

👨🏽‍💻 By 🐘 @[email protected] 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2025/10 Week 1

2025-10-05 22:31

💡 Computational Substrate for Document-Oriented End-User Programming 🎥 All the videos from LIVE 2025 📝 What We’ve Built Is a Computational Language

Share Your Work

🗨️ Mattias Rost: 📝 Reclaiming the Computer through LLM-Mediated Computing

🧵 conversation @ 2025-09-29

Hi all, I wanted to share an article I recently published in ACM Interactions: Reclaiming the Computer through LLM-Mediated Computing (it ended up being the cover story).

The piece is a mix of critique and speculation. I argue that today’s application-centered computing reduces the computer to icons and menus. I then suggest that with LLMs, we may be at the cusp of a shift toward a more relational and open-ended form of computing, where functionality emerges in dialogue rather than being predefined. I try and portrait a view of how that may look like and what it means.

I’d be really curious how this community reads it:
• Does it resonate with the kinds of directions you’ve been exploring here?
• Are there prior projects or framings I should know about that connect (or clash) with this line of thought?

I’ve been listening to the podcast but just recently joined Slack. My sense is that many of you have been wrestling with similar questions. I’d love to hear your thoughts and how this fits (or doesn’t fit) with your own visions of computing’s future.

In a sense I think the way I think about this is a way to get to Alan Kay's idea about the computer as a medium. Not as a medium for text, but as a computational medium. His initial idea really was that computers should not come with pre-packaged applications, but the building blocks with which you can think and express. That's how I envision LLM-mediated computing could be. A modality of computing where through ongoing interaction, the computer and what we can do with it emerges in a sort of dialogue.

📝 Reclaiming the Computer through LLM-Mediated Computing | IX Magazine Issue XXXII.5 September - October 2025

Ever since the desktop metaphor came about at Xerox PARC in the 1970s, we have interacted with computers that present themselves and their capabilities with what they display on-screen....

Reclaiming the Computer through LLM-Mediated Computing | IX Magazine Issue XXXII.5 September - October 2025

DevLog Together

🗨️ Tom Larkworthy: 🦋 larkworthy.bsky.social

🧵 conversation @ 2025-10-04

One of my goals was to get source file representations of my Observable notebooks. Well that got much easier as there is a download tool with the new observable notebook kit so I have finally done it.

🦋 larkworthy.bsky.social: Oh this is amazing, I backed up all my original notebooks to Notebook 2.0 files. I can open them in the Desktop app or generate sites from them. Finally I have a canonical source file representation for them.
500+ notebooks! Years of work.
https://github.com/endpointservices/observable-notebooks

<https://bsky.app/profile/larkworthy.bsky.social|@larkworthy.bsky.social>: Oh this is amazing, I backed up all my original notebooks to Notebook 2.0 files. I can open them in the Desktop app or generate sites from them. Finally I have a canonical source file representation for them.
500+ notebooks! Years of work.
<https://github.com/endpointservices/observable-notebooks>

Linking Together

🗨️ Beni Cherniavsky-Paskin: 📝 What We’ve Built Is a Computational Language (and That’s Very Important!)—Stephen Wolfram Writings

🧵 conversation @ 2025-09-29

Mathematica has long been a pretty unique achievement. The notebook interface, the symbolic power, and the polished consistency of it all. Due to being closed-source, I've somewhat ignored their evolution, and you need some tolerance to S.W.'s self-aggrandizing tone 😉. Yet they're definitely doing some very FoC work, and this essay proposes an angle I haven't heard before:

So for example, a computational language can intrinsically talk about things in the real world—like the planet Mars or New York City or a chocolate chip cookie. A programming language can intrinsically talk only about abstract data structures in a computer.

📝 What We’ve Built Is a Computational Language (and That’s Very Important!)—Stephen Wolfram Writings

Is the Wolfram Language a computer programming language? Stephen Wolfram explains why it is, rather, a computational language--a way to communicate computational ideas.

🗨️ Konrad Hinsen: 💡 Denicek: Computational Substrate for Document-Oriented End-User Programming

🧵 conversation @ 2025-09-30

Denicek: Computational Substrate for Document-Oriented End-User Programming by tomasp and jonathoda. So far I only watched the 5-minute video. The paper is on my reading list.

Building programming systems that support programming by demonstration,
collaborative editing, incremental recomputation and structure editing is hard!
Denicek is a computational substrate based on documents and history of edit actions
that simplifies the task.

🗨️ ruru4143: 🎥 LIVE 2025 - Scrappy: make little apps for you and your friends

🧵 conversation @ 2025-09-30

Scrappy: make little apps for you and your friends

https://pontus.granstrom.me/scrappy/

🎥 LIVE 2025 - Scrappy: make little apps for you and your friends

LIVE 2025 - Scrappy: make little apps for you and your friends

🗨️ Ivan Reese: 🎥 LIVE 2025 Premiere

🧵 conversation @ 2025-09-30

Related to the previous, here are all the videos from LIVE 2025. I'm slowly working my way through them. It's great to see so many familiar faces, and I'm really impressed with the quality of the work on display here. Huge kudos to Joshua Horowitz, Michael Homer, and the other folks involved with putting this together.

🎥 LIVE 2025 Premiere

LIVE 2025 Premiere

👨🏽‍💻 By 🐘 @[email protected] 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2025/09 Week 5

2025-09-28 22:31

🎙️ FoC 78: Let's Take Esoteric Programming Languages Seriously 📕 Forty-Four Esolangs: The Art of Esoteric Code 🎥 Foc Virtual Meetup: September 2025

Share Your Work

🗨️ Ivan Reese: 🎙️ Feeling of Computing • Episode 78 • Let's Take Esoteric Programming Languages Seriously

🧵 conversation @ 2025-09-27

One of the biggest goals of this show — our raisin detour, if you will — is to encourage people to look at computer programming differently. It’s not just a job, or a way to make the computer do what you want. Code isn’t just the material you sculpt into apps and games and websites. The very act of programming itself, and the languages we make and use to do that programming, reflect who we are as people. Programming languages say something.

Esolangs — esoteric programming languages — are programming languages created for these more self-reflective purposes. To some, they’re defined by what they’re not: not for serious use, not for education, not for efficiency. To others, they’re a bunch of funny jokes that people can commiserate through after suffering the steep learning curve of becoming a programmer. A few find in them an opportunity to explore strange computational models, or baffling syntax designs. But is there more to them? Could there be?

In this episode, we’re discussing a preprint of the paper Let’s Take Esoteric Programming Languages Seriously by Jeremy Singer and Steve Draper, and struggling with what it even means to give esoteric languages their due.

🗨️ Rory Byrne:

🧵 conversation @ 2025-09-28

I want to revive this old prototype I built - Codeline. It's a tool that lets you run commands from your source code comments. Anyone interested in helping?

Some ideas:

Build a LSP server that can detect appropriate comments and run the commands/add CodeLens context/other stuff
Finish off the SDK so people can build new commands
Modernise the tooling (poetry -> uv , make -> just etc)
Build a few commands
Design a way to decouple commands from the codebase, so they can be installed independently.
Use treesitter to find relevant comments
Permission system for risky actions (e.g. rm)
...

DevLog Together

🗨️ Jasmine Otto:

🧵 conversation @ 2025-09-25

(to a non-MVC codebase, threateningly) which one of you model-update rules clobbers the view as a side-effect?

Reading Together

🗨️ brett g porter:

🧵 conversation @ 2025-09-27

Just saw that MIT Press published an Esolang book by Daniel Temkin this week: https://mitpress.mit.edu/9780262553087/forty-four-esolangs/

Thinking Together

🗨️ guitarvydas: 📝 Recursive, Asynchronous Layering: What Shell Scripts Teach Us About Program Architecture

🧵 conversation @ 2025-09-22

Linking Together

🗨️ misha:

🧵 conversation @ 2025-09-23

please, share your favorite resources about programming languages and DSL design

Present Company

🗨️ Ivan Reese: 🎥 September 2025

🧵 conversation @ 2025-09-24

Here's the recording of our September virtual meetup. Three great demos today — I was remarking in the post-meetup hangout that I'm surprised and delighted that this community continues to attract people working on such interesting and varied prototypes. These meetups have been a blessing of inspiration for me personally, and hopefully for many of you as well.

Next month we're going to do something a little different — more on that soon! See you in late October 🎃

🎥 September 2025

September 2025

🗨️ Jouke Waleson: 🎥 Comper update July 2025

🧵 conversation @ 2025-09-27

During my demo in the meetup ^^ (first 15 minutes or so) I was encouraged to post an update about Comper here, so here goes:

Backstory
Three years ago I was CTO and was often playing GeoGuessr in the office with my team after office hours. It was a lot of fun, and then a very creative guy from marketing said "Why don't you build that for code?" I thought that was extremely cool. In GeoGuessr, you're dropped in Google Streetview and have to guess where you are by clicking on the map. The closer you are, the more points you get. For software you could see a code snippet and also guess where you are. I realized the problem in building this for software was that we don't have a map, so I had to create a different user interface for the game. After a couple of attempts I gave up and decided to build a map for the software landscape instead. When I had a PoC I realized that having a map could be very useful for all kinds of things! Then I quit my job, spent some time freelancing (I needed a break after that company) and saving up. In December last year I really started building, so now I'm starting to show Comper - https://comper.io to the world .

What is it
Comper is going to be the Google Maps for software organizations. With it, you visualize your landscape, zoom in and out, and use overlays to see different aspects (quality, security, complexity, productivity, .....). You can zoom in all the way to code using dynamic treemaps.

Here's a video showcasing most of the features from two months ago: https://www.youtube.com/watch?v=j5dqxRUmf6U . I mostly did a lot of polishing and refactoring since then so functionality-wise it's mostly the same.

I'm currently working on better diagramming and letting AI agents figure out the structure of each project so that it can create diagrams automatically. I want Comper to be the living map of your software team that is always up to date with reality, and can truly be used to explore and discover the software landscape, by giving everyone the "lenses" that are relevant to them.

Next steps / beta program
For now I'm building it alone in Utrecht, The Netherlands, the company is getting incorporated within the next two weeks or so. Still need to figure out the business model, but I have no doubts: this will be extremely useful to software teams. You can't download it yet, but I'm opening a private beta program. If you have a use case and are willing to pay for me to give advice / insights using the product, let me know. Might be useful for a tech due-diligence, restructuring teams or something like that.

PS. it's built on Rust and the frontend mostly PixiJS and a bit of VueJS. Rust because I need to analyze all the history of hundreds of repos quickly.
PPS. I showed a very early prototype to Jack Rusher a couple years aback and he encouraged me to join the FoC Slack, which I've mostly enjoyed from the sidelines so far :)

If it's appreciated I'll post some updates somewhere here on Slack every now and then. Let me know if you have any questions or comments!

🎥 Comper update July 2025

Comper update July 2025

👨🏽‍💻 By 🐘 @[email protected] 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2025/09 Week 4

2025-09-21 22:26

📑 Dynamic Abstractions Reading Group 🎥 hirba - Legible live programming through rich in-context representations 📢 LIVE 2025: Workshop on Live Programming

Share Your Work

🗨️ Jasmine Otto:

🧵 conversation @ 2025-09-15

I am giving a talk on boundary objects this Fri for the Dynamic Abstractions reading group, at 9am PT. I've linked couple readings from CSCW (Ribes on domain, and Star on good ol' fashioned AI) and my BELIV paper. 📑 Dynamic Abstractions Reading Group

In the meantime - we've got four great talks on the ladder of abstraction, constructivism & Building SimCity, and the design of intelligent interfaces & systems. Ian Arawjo's latest about how notations emerge is solid gold if you're thinking about non-code coding interfaces. (40min video + 20min q&a, through the link, scroll down.)

🗨️ Gregor:

🧵 conversation @ 2025-09-17

Here is some ideas I've been thinking about for my coding environment, as always happy to get feedback!

🦋 watwa.re: My ideas are faster than my fingers so I've did some Figma prototyping and video editing to talk about some of my new ideas before they are actual coded reality

🎥 hirba - Legible live programming through rich in-context representations

Thinking Together

Does anyone remember a paper about a low level data format that was a kind of structured JSON thing, but it was a binary format and gracefully simplified into a raw string or raw int if that was the only data. It was definitely posted here at some point, maybe 5yrs ago though…!

🗨️ Hemi Edwards:

🧵 conversation @ 2025-09-17

guitarvydas A friend of mine and I were exploring this subject. He was a computer engineer trained at MIT back in the mid 1980s and had developed expertise in higher level languages like Go and Ruby, but was interested in going back to first-principles. He was interested in the possibilities offered by UML and generating domain specific language to solve problems. I actually thought about combining UML with a TLA+. UML could be used as a visual representation of a system's design and TLA+ could perform the role of specification and verification of the system's model and then generate Ada code to build mission critical system, like they do in aerospace.

Linking Together

🗨️ ruru4143: 📝 Introducing the HandAxe Collections Pattern Language - Strange Loop

🧵 conversation @ 2025-09-16

Introducing the HandAxe Collections Pattern Language is a abstract rundown on all operations you can have on common collection types. The switch to edges instead of indices is really nice.

Sadly this is the only public artifact of this project

🗨️ misha:

🧵 conversation @ 2025-09-18

Please, share your favorite resources about approaches to versioning of APIs, DB schemas, code libraries etc.
Versions rollout, support, and deprecation still feel unsolved and ad-hoc.

🗨️ Joshua Horowitz:

🧵 conversation @ 2025-09-20

The LIVE Workshop (all about live programming) is free & online this year, and coming up soon. We will be “premiering” presentation videos on Saturday, September 27, after which they will be available to watch on your own time if you prefer. Then, on Saturday, October 4, we will have live (har har) Q & A and discussion over Zoom.

Details are up at https://liveprog.org/. We’re still finalizing schedule, links, etc., but you can read a bit about the 12 exciting projects that will be discussed at the workshop.

I hope some of you can come!

End User Programming

🗨️ Beni Cherniavsky-Paskin:

🧵 conversation @ 2025-09-15

EUDability: a new construct at the intersection of end-user development and computational thinking
[I don't know why it was so hard for me to wade through this paper, despite being squarely in my interests.
I feel the academic format is a poor match for the content which could be a good blog post?]

The goal is extending "usability" so "use" includes end-user programming.
... They observe that "computational thinking" skills become a "literacy" when practiced, including the experience of when to apply which skill. [by that stage the paper still feels like a lot of word shuffling]...
The real stuff only comes in pp. 25–27 where they identify qualities ("dimensions") by which the software can help users apply those computational skills:

Concreteness: this dimension refers to the capability of a EUD environment of presenting concepts and requests in a concrete way, without requiring the user highly-developed abstraction skills;
Modularity: this dimension regards the availability in a EUD environment of different elements, blocks, modules or similar things, which help end-user developers decompose a problem and identify the pieces that may compose its solution;
Structuredness: when a EUD environment supports the structuring of a solution in a step-by-step process and facilitates the connections between the input and output of the different steps, it can be considered as having the structuredness property;
Reusability: when the outcome of a EUD activity can be reused in other situations and possibly shared among different end-user developers, the EUD environment possesses the reusability property;
Testability: this dimension refers to the capability of testing the outcome of the EUD activity within the EUD environment.

and the payoff is this diagram where everything falls neatly in place:

📷 image.png

AI

🗨️ Brian Hempel:

🧵 conversation @ 2025-09-15

Hi FoC AI-interested folks! Hope this isn’t spammy, but we are running a study on how experienced developers leverage AI agents directly in their coding environments and we are looking for developers that use AI agents so we can sort out what’s hype and what’s actually working and then publish that publicly for all to know. It’s a paid study ($100 Amazon gift card) through UC San Diego’s Foundation Interface Lab.

In particular, we’re looking for people using terminal-based agents like Claude Code, OpenCode, Gemini CLI, or Codex CLI. We’ve already interviewed many Cursor and Copilot users.

What’s involved?
• 90-minute remote user study (via Zoom)
• Working through a programming task of your choosing that involves agents while you code

Who can join?
• You must be located in the U.S and 18 years of age or older
• You are a professional software engineer or developer with 3 or more years of experience
• You are a professional software engineer or developer who uses agentic programming workflows (e.g., Cursor, Windsurf, Claude Code, etc.).

If you are interested in participating, please fill out this short Google Form. We will be in touch with you ASAP to schedule a meeting.

By participating, you will help advance the state of human knowledge about the fast-evolving roles and practices of coding agents, potentially leading to more intelligent, efficient, and accessible software development. Thanks for considering!

Present Company

🗨️ Kartik Agaram: 📝 Less is safer: how Obsidian reduces the risk of supply chain attacks

🧵 conversation @ 2025-09-19

I'm glad to see a big player in the JS eco-system address supply chain security head on.

Supply chain attacks are malicious updates that sneak into open source code used by many apps. Here’s how we design Obsidian to ensure that the app is a secure and private environment for your thoughts.

👨🏽‍💻 By 🐘 @[email protected] 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2025/09 Week 3

2025-09-14 22:44

✊ Live Programming in Hostile Territory 📡 Propagators 📄 What Does ‘Human-Centred AI’ Mean?

Share Your Work

🗨️ Pandi Lin:

Hi everyone 👋
I’ve been working on a JavaScript implementation of Sussman & Radul’s propagator model and wanted to share some progress + questions. here's the link to the repo: https://github.com/Semi-0/Propagator
I currently have two branches:

A custom push-based version (works, but amb can get weird). (In the AMB branch)
A more faithful scheduler-based version, closer to the original design. (but amb still acts weirdly when execution gets large)

It supports almost all of the original Scheme machinery, and I’ve been experimenting with a reactive extension so propagator networks can drive UI updates.
Lately I’ve been exploring some theory: I noticed interesting parallels between wired diagrams in category theory and propagator networks, and I’m researching how to separate representation from execution (syntax vs. scheduler). And how I can perhaps making the propagator more self-reliant as independent programming languages.
Since I’m pretty new to open-source, I’d really appreciate advice on two fronts:

Research direction → does this “wired graph <-> propagator <-> representation/execution” connection resonate with anyone? Are there papers or projects I should look at?
Sharing the code → what’s the best way to make an infrastructure repo like this easier for others to understand? (Docs? examples? small demos?)

Thanks in advance for any pointers

For anyone not already familiar with propagators, here’s a quick refresher:

A propagator network is a collection of small, independent agents connected by cells that hold partial information. Each agent watches its inputs and, whenever it can deduce something new, it updates other cells. Unlike ordinary functions, information can flow in many directions at once — for example, if you know two sides of a right triangle, the Pythagorean propagator can solve for the third no matter which two you provide. This makes propagators a general model for constraints, dataflow, multi-directional reactivity and incremental reasoning.

🗨️ guitarvydas: 🎥 PBP Part Basics

🗨️ Guyren Howe:

I can’t find a working link here or in the YouTube video. For those interested in further info about Propagators, see: https://wiki.futureofcoding.org/Propagators/

TIL that we have a wiki…

🗨️ Christopher Shank: ✊ Live Programming in Hostile Territory

https://folkjs.org/live-2025/

Orion Reed and I submitted a positional paper for LIVE 2025 called "Live Programming in Hostile Territory". Now that it's been accepted, I'm excited to hear peoples thoughts and feedback! It touches on a topic wider than just live programming and, at least to me, is very relevant to the FOC community. Here is the abstract:

Live programming research gravitates towards the creation of isolated environments whose success is measured by domination: achieving adoption by displacing rather than integrating with existing tools and practices. To counter this tendency, we advocate that live programming research broaden its purview from the creation of new environments to the augmenting of existing ones and, through a selection of prototypes, explore three adversarial strategies for introducing programmatic capabilities into existing environments which are unfriendly or antagonistic to modification. We discuss how these strategies might promote more pluralistic futures and avoid aggregation into siloed platforms.

Thinking Together

🗨️ guitarvydas:

🧵 conversation @ 2025-09-12

A sketch that might inspire brainstorming. I perceive that we're "doing what we've always done" instead of stepping back and inventing new stuff, like they did in 1960. The "we've always done it this way" mentality results in epicycles piled on top of epicycles.

📄 Programming - The Good Parts.svg

Linking Together

🗨️ Ivan Reese:

Meschers: Geometry Processing of Impossible Objects

(Graphics) Clever use of screen-space vertex positions + edge depth to represent impossible objects in a robust way.

🗨️ Ivan Reese:

Double header — lead author on the above also has a good paper/talk about gender and bias in graphics research.

🗨️ Jasmine Otto:

📝 Lori Emerson (@[email protected])

Dreyfus 1965, 98p. longread, early example of critical AI. feels kinda ripped from the headlines.
emphasizes gestalt processing & gestures toward embodiment. looks like frame problems and wicked problems (critique of reductionist / associationist assumptions) developed in parallel

I am SO enjoying this very early...the earliest? critique of AI from 1965 whereby Hubert Dreyfus calls the hot air about AI "the production of intellectual smog" #ai https://www.rand.org/pubs/papers/P3244.html

🗨️ Mattia Fregola: 📝 Physically based rendering from first principles

🧵 conversation @ 2025-09-11

Feels like it might have been shared before, if not this is pretty awesome:

📝 Physically based rendering from first principles

Physically based rendering from first principles

🗨️ Jasmine Otto:

🧵 conversation @ 2025-09-12

good manifesto for slow tech 📄 What Does ‘Human-Centred AI’ Mean? (15p.)

🦋 olivia.science

Something I hinged on to get to this what I describe: the Marxian fetishisation of artefacts is so complete in the case of AI that not only do we somehow conclude machines think, but we accept for them to think, speak, draw instead of us, while also thinking these are (expressions of) our thoughts.

👨🏽‍💻 By 🐘 @[email protected] 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2025/09 Week 2

2025-09-07 23:40

🎼 Unleashing Creative Expression in Music Score Writing 📝 Type Checking is a Symptom, Not a Solution 🤔 What Declarative Languages Are

Two Minute Week

🗨️ Jasmine Otto: ♾️ Infinite Love Triangles (and other Graph Coloring Experiments)

Infinite Love Triangles (and other Graph Coloring Experiments)

Someone asked me to define a "splot", which is like a flood-fill texture for narrative design. In addition to doing that, I've started teaching robots to spill tea. Hmm

Wave Function Collapse (WFC) is an algorithm for constraint propagation on adjacency graphs. Game designers use it to procedurally generate interesting levels for players to traverse. Let's use it to generate toxic relationships instead. Now we have a bunch of interesting relationship roles that might get thrown around when heartbreak happens. Red is for traitors, orange is for their enablers, and yellow is for people who got hurt. (Green doesn't care, and teal tries to help.) Use these buttons to assign ne

Share Your Work

🗨️ guitarvydas: 📝 Type Checking is a Symptom, Not a Solution

🧵 conversation @ 2025-09-07

DevLog Together

🗨️ Tom Larkworthy:

Trying to properly learn codemirror 6. I upgraded my AI with code search and optimised its prompt with GEPA so it could help me program codemirror better. Given Observable is going plain Javascript, that simplifies things a bit language-wise and its just a matter of getting the off-the-shelf JS language syntax highlight working + injecting runtime state for code completion based on the current state of the runtime. My new prototype runtime editor lets you change the runtime graph using the plain JS SDK instead of the higher level cell model. Anyway, nice to start understanding about 3% of codemirror's programming model. I think getting rid of cells will make things more straight forward.

📷 image.png

Thinking Together

🗨️ guitarvydas:

🧵 conversation @ 2025-09-04

Pond'ring aloud:
We know that "loop" is recursion, but recursion is often expressed in too-academic a manner.
We know that recursion consists of 2 parts:

termination case
recursion case.

I'm thinking about what might be a less-inhumane syntax for expressing a recursive solution. Suitable for non-programmers and LLMs?

[aside: the goal is not "efficiency" at the machine level, but expressiveness and human (non-programmer) understandability]

humane syntax???:  
----------------  

break down member (x, list) -> ([#found | #not-found], value) {  
    finish when list is empty { ^ #not-found, ɸ }  
    finish when x in list     { ^ #found, list }  
    decompose list' <- rest (list) {  
        ^ again (x, list')  
    }  
}  

break down append (x, list) -> value {  
    finish when list is empty { ^ x }  
    decompose «item» <- first (list), «list'» <- rest (list) {  
        ^ prepend «item» onto again (x, «list'»))  
    }  
}

inhumane syntax:  
----------------  

(defun my_member (x lis)  
  (cond ((null lis) (values nil nil))  
        ((eq x (car lis)) (values t lis))  
    (t (my_member x (cdr lis)))))  


(defun my_append (lis x)  
  (cond ((null lis) x)  
        (t (cons (car lis) (my_append (cdr lis) x)))))

[aside: "send ..." sends something forward asynchronously instead of returning it synchronously to the caller and unblocking the caller]

less-inhumane syntax involving async ports:  
-------------------------------------------  

break down member (x, list) output ports: { success: [#found | #not-found], value: object } {  
    finish when list is empty { send success: #not-found, send value: ɸ }  
    finish when x in list     { send success: #found, send value: list }  
    decompose list' <- rest (list) {  
        ^again (x, list')  
    }  
}  

break down append (x, list) output port: { value: object } {  
    finish when list is empty { send value: x }  
    decompose «item» <- first (list), «list'» <- rest (list) {  
        send value: prepend «item» onto ^again (x, «list'»))  
    }  
}

suggestions / comments?

Linking Together

🗨️ Konrad Hinsen: 👨‍💼 Issue 084: Spreadsheets

🧵 conversation @ 2025-09-01

A few articles on spreadsheets that are well worth reading:

Issue 084: Spreadsheets

Welcome to the 84th issue of De Programmatica Ipsum, about Spreadsheets. In this edition, we declare spreadsheets the most popular software programming environment of all time; in the Library section, we learn how to use Lotus 1-2-3 for science reading "Spreadsheet Physics" by Charles Misner and Patrick Cooney; and in our Vidéothèque section, we discover that Excel is a Turing-complete, functional programming language through the eyes of Dr. Felienne Hermans.

Issue 084: Spreadsheets

🗨️ Nilesh Trivedi: 🤖 Coding Agent Builders Mixer · Luma

Coding Agent Builders Mixer · Luma

I am hosting an online mixer this Sunday for those who are building coding agents:

If you're building Coding Agents using LLMs, this online meetup should help you connect with similar folks and discover ideas and opportunities.

Coding Agent Builders Mixer · Luma

🗨️ Ivan Reese:

What Declarative Languages Are

there's actually a surprisingly simple and useful definition of declarative language: a declarative language is any language with a semantics [that] has some nontrivial existential quantifiers in it.

Music

🗨️ avon:

🧵 conversation @ 2025-09-02

Hi all, I remember running into a wonderful blog post a while back where the author described recreating a DAW from a sort of hazel(https://github.com/hazelgrove/hazel)-like moldable programming environment. I unfortunately cannot find the post in my bookmarks, and my searching the last few weeks has turned up empty. Does this ring a bell for anyone?

🗨️ avon: 🎼 EuterPen: Unleashing Creative Expression in Music Score Writing