Future of Coding Weekly

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

🧵 conversation @ 2025-08-31

Searching for that livecoding blog post I mentioned above, I found this really amazing programmable ink software for composing:
🎼 EuterPen: Unleashing Creative Expression in Music Score Writing By Vincent Cavez, Caroline Appert, Catherine Letondal, Emmanuel Pietriga

Video demo

The pattern manipulation & search operations are especially interesting imo.

👨🏽‍💻 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 1

2025-08-31 22:09

🧑‍💻 Write your own tiny programming systems 🎥 Python: The Documentary 🗓️ FoC Meetup

Two Minute Week

🗨️ Ivan Reese: 🎥 automerge cards

Share Your Work

🗨️ Dany:

🧵 conversation @ 2025-08-29

I recently finished (and released) my first app built in my miqula programming system: https://danybittel.ch/marbling
Overall it worked quite well. Still some dearly missing features (like constants)... and bugs are super demotivating when I need to switch back to C++.
I really need to look for some paid work right now.. that's why I've been a bit quite in here.

Reading Together

🗨️ When Leggett:

🧵 conversation @ 2025-08-27

I just got finished reading "The Dream Machine" about Licklider - great book, I recommend it to anyone who ever enjoyed an Alan Kay talk

Thinking Together

🗨️ Eli: 📝 Oatmeal - To the surprise of literally no one, I'm working on implementing a programming language all my own

🧵 conversation @ 2025-08-27

Inspired by conversation last night at the virtual meetup, I wrote a blog post to introduce the toy language I’ve been working on.

Inspired by conversation at a recent Future of Coding event, I decided I’d write up a little something about the programming language I’ve been

Linking Together

🗨️ Stefan: 🧑‍💻 Write your own tiny programming systems

🧵 conversation @ 2025-08-25

Came across tomasp's teaching materials and would like to especially highlight these two courses here:

Write your own tiny programming systems — build your own tiny versions of ML, Basic, HM type system, Prolog, Self, Excel
Programming Language Design — fantastic resources that embed technical language features into a broader perspective of design and culture

This is the kind of resource that is absolutely amazing to be publicly available under such permissive license.
Seriously, look at the tiny programming systems and bootstrap your way into your favorite programming environment in an afternoon or weekend. Don't miss the source code for the demos in the same repo. The only things missing are a TinyLisp and a TinyForth, but you can find those easily somewhere else on the Internet.

🗨️ Craig Abell:

🧵 conversation @ 2025-08-30

Saw Will's Rust for Everyone! talk earlier oh his research into tooling to help people understand programs. The program slicer (highlights all lines impacted by the current line) seems particularity useful for understanding large functions.

🗨️ Konrad Hinsen: 🎥 Python: The Documentary | An origin story

🧵 conversation @ 2025-08-31

Python: The Documentary | An origin story is a somewhat surprising movie, in the sense that I haven't seen anything similar yet in the Open Source universe. I'd summarize it as an autobiography of the Python community. In general, I am not particularly interested in autobiographies. But as an ex-member of the Python community, it was nice to see the aged faces of people I interacted with in the past, or even just faces to put on the names of people I never met but exchanged lots of e-mails with at some time.
Still, I'd be much more interested in a history of Python and its community, written by a trained historian and adding historical context and outsider views to the memories of the main protagonists.

Python: The Documentary | An origin story

Present Company

🗨️ When Leggett:

🧵 conversation @ 2025-08-27

I guess this isn't exactly a presentation, but I'll be at the IIW unconference this fall if anyone else is gonna be there or wants to sign up: https://internetidentityworkshop.com/

also happy to chat about it with anyone interested but not sure or whatever

🗨️ Maikel: 🗓️ FoC Meetup · Luma

🧵 conversation @ 2025-08-28

Our next "european" FoC meetup is on the 24th of september, this is the luma link : https://lu.ma/eog1qc5x and we already have 2 guests (I'll contact you), so we're looking for one more demo/presenter! This meetup will last an hour

Information about our meetup can be found here : https://futureofcoding.org/meetups

👨🏽‍💻 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/08 Week 4

2025-08-24 22:14

🗃️ Grist: Organize your data, your way 💡 Icepath: a 2D Programming Language 🧑‍💻 Alpaca 2025: Algorithmic Patterns in the Creative Arts

Share Your Work

🗨️ Alex McLean: 🧑‍💻 Alpaca 2025: Algorithmic Patterns in the Creative Arts

🧵 conversation @ 2025-08-23

Alpaca festival and conference on algorithmic patterns in the creative arts In-person talks+workshops+concerts+algorave in Sheffield, much of which will be streamed online, from 12-14th September 2025

Then continuing as on-line conference into the following weekend, with in-person watch parties/hubs in Barcelona, Berlin, Linz and Sheffield

Features a fair amount of live coding, including a paper from the mysterious 'pastagang' Full info and line-up/schedule:

2025.algorithmicpattern.org

🗨️ Scott: 📝 Safe Is What We Call Things Later

🧵 conversation @ 2025-08-24

Wrote a little followup to the post from last week based on the conversation with Jonathan Frederickson and D. Schmudde: 📝 Safe Is What We Call Things Later

Some Software Engineering Folklore

Safe Is What We Call Things Later

DevLog Together

🗨️ Ezhik:

Making a little Obsidian plugin that lets you cook small apps right inside of your vault.

I find boilerplate annoying for little experiments, so I got rid of all of it. Each file is a standalone little app that automatically gets built and executed. Data persistence is also usually a pain, so it's nice to be able to just do it HyperCard style and have changes auto-save right to the file.

🎥 Screen Recording

🗨️ Kartik Agaram:

I add a feature and add a toggle of state for it. Then I add another feature and add another toggle. Do I really need to handle 4 possible states now, or just 3, i.e. I have an enum in disguise 🥸? I keep making this mistake. Designing things up front is easy, but I find it impossible to reliably avoid mistakes when adding to an existing design.

Thinking Together

🗨️ Christopher Shank: 🎥 My Favourite Games from GMTK Game Jam 2025

🎥 My Favourite Games from GMTK Game Jam 2025

The theme of the GMTK Gam Jam was "loops" and there are lots of fun and novel explorations of affordances, interactions, and mechanics that feel applicable to the types of stuff explored here

My Favourite Games from GMTK Game Jam 2025

🗨️ Ivan Reese:

🧵 conversation @ 2025-08-24

Anyone have experience with XSLT? The recent kerfuffle about removing it from the html spec and the episode of Igalia Chats about it were both quite interesting to me. A declarative tree-transformation language!? Sounds like the sort of thing you could build a web app engine around ;)

Linking Together

🗨️ Pablo Donato: 🗃️ Grist: Organize your data, your way

🧵 conversation @ 2025-08-20

Not sure if it was already shared here before, but Grist looks like a good contender in the No Code/Relational Spreadsheet game. It seems to be to Airtable what Zulip is to Slack: an open-source, self-hostable, and more customizable alternative.

Learn about all of Grist's powerful spreadsheet-database product and its many features.

Product | Grist

🗨️ Eli:

Ends in what is likely a fun question for these parts:

In the 1970s, you could launch a new language with a paper and a maybe a compiler and/or interpreter. In 2025, you need an integrated product, a narrative, and enough momentum to bootstrap an ecosystem and on top of that a huge corpus of code that can only be created through sustained use. Modern langdev is daunting to say the least.

Where do languages go from here?

Languages could be shaped by physical and purpose-specific constraints once again. Tomorrow’s interesting languages may target IoT, SBCs, edge devices, Blockchain, GPUs, and let’s not forget that the world still runs on microcontrollers.
Python is the lingua franca of AI, which means it’s the lingua franca of LLM-generated code. Eventually Python will force LLMs to eat their own tail, but more immediate an over-reliance on AI-generated code will expose inherent weaknesses in the technology. We’re seeing real problems with an increased lack of rigor and there are novel problems that LLMs simply cannot solve. These short-comings are opportunities.
Future innovations may look more like a new operating environment with integrated semantics across distributed systems, or programmable infrastructure that blurs the line between language and runtime.

🗨️ Jon Tran: Open-source geometric constraint solver

🧵 conversation @ 2025-08-21

A while back, when I saw the Inkling presentation I said that my company was working on designing a constraint solving system for CAD. It's just getting started and still very much a work in progress, but it's happening. https://github.com/KittyCAD/ezpz

🗨️ Konrad Hinsen: 📝 Google is killing the open web

🧵 conversation @ 2025-08-22

A statement I frequently hear is that no platform is as stable as the Web platform, because everyone makes an effort to keep old Web sites functional. The current XSLT debate suggests that this stability may soon end, as part of another enshittification campaign.

📝 Google is killing the open web

The juggernaut is taking advantage of its dominant position to enclose and destroy the commons.

🗨️ Jimmy Miller: 💡 Icepath: a 2D Programming Language

🧵 conversation @ 2025-08-23

https://healeycodes.com/icepath-a-2d-programming-language

A little 2D programming language called Icepath. Named after the ice puzzles in Pokémon Gold and Silver. The vibe I was going for was sliding around a cave and hitting opcodes.

👨🏽‍💻 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/08 Week 3

2025-08-17 23:33

🛸 A moldable Common Lisp object inspector 🧑‍🔬 Trying out "Reflective Prompt Evolution Can Outperform Reinforcement Learning" 📄 Hierarchical File Systems are Dead

Share Your Work

🗨️ guitarvydas: 📝 De-Spaghettifying Control Flow & 📝 Towards Asynchronous Programming Workflows and Languages

🧵 conversation @ 2025-08-11

In my mind, CPUs implement subroutines, and, "functions" are but artificial constructs built on top of subroutines. Here are some more attempts to explain this hardware-centric view (see, also, the playlist of short videos in the first article).

📝 De-Spaghettifying Control Flow

📝 Towards Asynchronous Programming Workflows and Languages

🗨️ Robin Heggelund Hansen:

🧵 conversation @ 2025-08-17

I'm working on a language called Gløgg, which is a fully declarative, relational language where the source code is stored in a sqlite3 database as AST.

I now just got vite support and (proof of concept) dom integration working.

I'll be doing a whole presentation on Gløgg at the upcoming JavaZone conference (september 3-4).

🎥 glogg

🗨️ Scott: 📝 The System Inside the System

I've been thinking about the Viable System Model as a framework for AI agents since I came across it, mentioned it here actually: https://futureofcoding.slack.com/archives/C5T9GPWFL/p1748381760844169

Finally put together some rubygems to explore it - vsm the framework and airb a CLI-based agent built with it and wrote up some more detailed thoughts about them on my newsletter:

📝 The System Inside the System

Announcing two new Ruby gems: vsm and airb

The System Inside the System

DevLog Together

🗨️ Konrad Hinsen: 🛸 A moldable Common Lisp object inspector based on CLOG

🧵 conversation @ 2025-08-11

I finally implemented dataflow-based reactive views for my moldable inspector for Common Lisp. It's much shorter than the limited input handling I had before, and also more versatile. I am working on a demonstration/example, stay tuned...

There seem to be two widely used dataflow implementations for Common Lisp, out of which I picked the simple one (https://github.com/kchanqvq/lwcells) over the complex one (https://github.com/kennytilton/cells).

In the process, I ran into my first experience with ambiguities in the Common Lisp specification, with one of my new indirect dependencies.

clog-moldabl-inspector

Thinking Together

🗨️ Joel Neely:

🧵 conversation @ 2025-08-17

The clean way that the if/fi and do/od constructs embraced non-determinism still looks cleaner to me than the contemporary toolkits of various mainstream languages and frameworks.

Linking Together

🗨️ Ivan Reese:

🧵 conversation @ 2025-08-11

Let's have a discussion that'll hopefully generate lots of links.

Microsoft have just placed GitHub under AI in their org chart.

If I don't want to stick around and find out what fresh hell comes next, where should I go instead? Gitlab? Codeberg? Sourceforge? Send me links to your favourite social network for git repos!

🗨️ Bill Mill:

🧵 conversation @ 2025-08-13

a semi-related opinion that I don’t want to clutter that thread with:

self-hosting is awful* and there’s a big opportunity to develop structures for community-hosting things like git forges, chat servers, &c. Spread the load and develop social experience for sharing resources

*: too much work for too little use, too expensive, nobody wants to be on the hook all the time for maintenance so it rots

🗨️ Chris Knott:

I thought I would hate this paper (Hierarchical File Systems Are Dead) because I actually zealously love the hierarchical directory metaphor and hate the modern broth of files approach. In fact it is basically neutral on the user facing metaphor, recognises the necessity of replicating posix if anything will ever get traction, and is overall very good.

More like - how do we reify semantic search and tagging to the lowest level of the OS

📄 Hierarchical File Systems are Dead

AI

🗨️ Tom Larkworthy: 📝 Trying out "GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning"

🧑‍🔬 Trying out "GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning"

I completed a toy setup of GEPA with some fricken good results! I am very happy to have a methodology that removes some of the guess work with prompt design. Its a really simple algorithm that orchestrates a genetic evolution where the mutation operator is asking a LLM to improve the prompt based on the diagnostic trace your evals. So simple! I also enabled websearch during reflection so it can actually do its research when improving the prompt. This means it would adapt the web documentation to suit the prompt format automatically. Very good, been looking for something like this and it did not disappoint.

Present Company

🗨️ Ivan Reese:

🧵 conversation @ 2025-08-06

We still have nobody offering to demo this month at the weirdly timed meetup (North American Tuesday Evening, or NATE). If nobody volunteers I'll have to get weird with the format. We need your help to make sure that doesn't happen: 👉 Call Now 👈

👨🏽‍💻 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/08 Week 2

2025-08-10 22:54

🔌 Spirit Plant Software and Network Architecture 🎥 Virtual Meetup 13 • July 2025 🧑‍🔬 Notes from the Lab

Share Your Work

🗨️ guitarvydas:

reading When Leggett post caused me to write this article

🗨️ Marcin Ignac: 🔌 Spirit Plant Software and Network Architecture: a technical case study

🧵 conversation @ 2025-08-09

We have just published an in depth case study about our last generative (non genAI) art installation. All JS + WebGL baby! Check it out Spirit Plant Software and Network Architecture: a technical case study. · Variable - new ways of experiencing data | https://variable.io

We used web technologies to power the Spirit Plant installation visuals in real-time.

Spirit Plant Software and Network Architecture: a technical case study. · Variable - new ways of experiencing data | https://variable.io

DevLog Together

🗨️ Christopher Shank: 🧑‍🔬 Notes from the Lab - June & July 2025

Latest notes about what we've been working on with the folkjs project. Explorations include DOM sync, Desktop Interlay via Accessibility Trees, DOM interactions and instruments, HTML pipes, HTML attributes for syntax highlighting, LSPs, and reordering lists, and much more!

Notes from the Lab - June & July 2025

Thinking Together

🗨️ Joel Neely:

🧵 conversation @ 2025-08-09

I hadn’t thought about your before-and-after interpretation in quite that way. I’ll have to ponder a bit.
Regarding your reference to determinism, only some constructions in EWD’s wp-based notation are deterministic! While some cases (e.g. x := x-y) are, EWD’s reasoning makes some kinds of determinism a not-very-interesting special case. The “Aha!” moment for me was his solution for max in c := a max b.

if  
   a >= b -> c := a  
[]  
   b >= a -> c :- b  
fi

In the (again, uninteresting) special case that a = b, both guards are true it is perfectly valid to “perform” either of the two guarded commands.

Linking Together

🗨️ Jasmine Otto: 🕹️ too many gamedevs and only one game

🧵 conversation @ 2025-08-04

ahaha, multiplayer bitsy in the wild at A MAZE (using MouseMux)

🗨️ Nilesh Trivedi:

🧵 conversation @ 2025-08-06

Prof Eric Hehner's April 2025 article on interpreting the Halting Problem:
https://www.cs.utoronto.ca/~hehner/Boxes.pdf

📷 image.png

AI

🗨️ Jason Morris:

Happy GPT-5 day to those who celebrate. I got to play with it at work a bit, and it is impressive. I think having the AI generate symbolic representations of facts in text is going to be a lot more feasible going forward, which is going to be a game changer for people who can figure out how to use it.

Present Company

🗨️ Ivan Reese: 🎥 Virtual Meetup 13 • July 2025

Here's the video from last week's virtual meetup.

Virtual Meetup 13 • July 2025

🗨️ Ivan Reese: