Future of Coding Weekly 2025/09 Week 2

🎼 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)

🧵 conversation @ 2025-09-05

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

Infinite Love Triangles (and other Graph Coloring Experiments)

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-05

DevLog Together

🗨️ Tom Larkworthy:

🧵 conversation @ 2025-09-07

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.

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:

1. termination case
2. 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.

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

🧵 conversation @ 2025-09-05

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

Coding Agent Builders Mixer · Luma

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

🗨️ Ivan Reese:

🧵 conversation @ 2025-09-05

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.

What Declarative Languages Are

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-09-05

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 🐘 @marianoguerra@hachyderm.io 🐦 @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