📝 Choose Your Own Adventure Calculus 🤔 We are destroying software 🦾 Weak robots

Our Work

📝 Choose Your Own Adventure Calculus via Tomas Petricek

🧵 conversation

I do not have a cool video to share - only dry text! 🙂 but I think there is a very interesting "interaction pattern" that comes up in a lot of simple programming systems (at least the ones that I sometimes work on) - so this is an attempt to capture that...

Choose-your-own-adventure calculus

🎥 I Found Hidden Patterns in UK place names using Code via Conrad Godfrey

🧵 conversation

I'm getting increasingly more and more into the "app as a home cooked meal" paradigm, and this is me sharing some of that playful approach to coding with a non technical audience.

I hope that part of the future of coding, particularly AI facilitated, is more people able to satisfy their curiosity with code, in a playful way.

I wonder if there is a world where there are lots of programs that are totally ephemeral and just spun up on demand.

Project itself is at conradgodfrey.com/grep_britain

Devlog Together

📝 programmatic import via Tom Larkworthy

🧵 conversation

working towards programatic bulk export of observable notebooks into the lopefile format. Currently Observable has the concept of an import, but its a static macro type of thing, so there is no way of scripting it. I need to script it to be able to take any notebook and shove it into a standard website frame, that then becomes a single static file you can move around as a single HTML file artefact. Anyway, some progress towards that with a programmatic import. The import merges the notebooks in such a way as a subsequent export includes the import as a statically baked in dependancy. So it becomes offline-first at that point.

💬 Paul Tarvydas

🧵 conversation

Status:

• of interest: this is all fast enough to look like a REPL, although it spawns several heavy-weight processes and uses a local browser and websockets
• das2json is now written in javascript (formerly only Odin)
• das2json is a small program which converts a .drawio file into JSON
• this means that drawings can be reduced to JSON, a format which can be manipulated by just about any programming language
• VHLL language:
• got "RT" ("recursive text") compiler (transpiler) to run, at least for Python, and to self-compile
• RT is a VHLL that uses Python, Javascript and Common Lisp as "assemblers"
• rt pushed to repo
• next: test Javascript and Common Lisp self-compilation
• next-next: create a local copy of t2t so that the whole thing resides in one repo
• next-next-next: implement Larson Scanner in Javascript in a browser
• README.md expanded to include some discussion of the mechanics of this stuff.

🖊️ a page for our Inkling project via Ivan Reese

🧵 conversation

Small update from the Programmable Ink track at Ink & Switch — we just launched a page for our Inkling project.

(Whisper: actually, maybe a bit more than just a page . Take a peek!)

💻 rewrite rules usage in single html file via Oleksandr Kryvonos

🧵 conversation

"Tom is a cat", "is a cat => has tail", "Tom has tail"

...

rewrite rules usage in single html file

....

github.com/uprun/egalite-ai

Thinking Together

💬 Karl Toby Rosenberg

🧵 conversation

A bit off-the-wall, but I’m thinking about what true “spatial computing” (or insert buzz-term here) visual programming could look like, or instead of the word “true”, interesting, pragmatic, and unique. I’ll post something if I think of anything at all, but in the meantime, I’d be curious to hear thoughts. One thing I don’t want to do is rely on wire spaghetti everywhere. To me, interesting problems arise because of the spatial component. Things going out of view.

📝 Wrangler: interactive visual specification of data transformation scripts via Tomas Petricek

🧵 conversation

I would like to recreate an example of some nice data wrangling / data cleaning user experience based loosely on programming by demonstration. The classic reference for things like this I know of is Wrangler (Wrangler: interactive visual specification of data transformation scripts). Are there nicer newer things I should be looking at?

💬 Scott

🧵 conversation

Has anyone here spent much time thinking about how the business of software changes as AI models, techniques, and devtools improve?

In particular, I've been spending a lot of time thinking about the implications of:

1) what happens when things that previously took 6mo-1y to build out are quickly turning in to $0.10 API calls today and once models are small enough, architectures optimize more, and hardware improves, transform into a low level OS primitive tomorrow

2) do we need to start accounting for software as an asset differently when the payback period gets measured on a much shorter timeline?

3) internally, how much time do we need to focus on reducing our Time To Rebuild vs letting external forces reduce it for us?

🤔 We are destroying software via Andreas S

🧵 conversation

Hey 👋 this one could be interesting:

We are destroying software (Hacker News Discussion)

Is programming culture collapsing under its own frustrations(technical and social and all in between and towards each other?)?

What do you think?

🦾 Weak robots via Tak Tran

🧵 conversation

🤖 I’m reading about weak robots (Panasonic also made a “farting cat robot” called Nicobo), and I’m loving the idea:

Exposing “weaknesses” instead of hiding them inside creates a space for connection in a relationship. Furthermore, it creates a relationship in which both parties can compensate for each other’s imperfections and draw out each other’s strengths. The “weak robots” prove this, says Okada, and the same principle applies in human-to-human relationships.

“However, we have always lived in a society that encourages people to be self-sufficient, so it is difficult for us to show our weaknesses. Still, sometimes a weakness can turn into a strength when we expose it and trust the other party. I hope that ‘weak robots’ will serve as a model for restoring rich and flexible relationships to society, and will help loosen the intolerance that exists in the world.”

“Weakness” dissolves hierarchical relationships and the boundaries of doer and receiver, and in this sense, it is a “strength” that enriches the relationship. The “weak robots” taught me the essence of what we should aim for in a diverse society.

Also love the idea of soft robots like Toyota’s Punyo. They’re such a refreshing take on robots, as opposed to the dystopian humanoid robots that the big tech companies seem like to be striving for 😬

This rabbit hole started from seeing a Megatron transforming robot, which initially triggered all my dormant “thats, so cool!” childhood dreams - but seeing it fail at a few voice commands, and being quite unnatural outside of the preprogrammed/animated tasks^, I was yearning for better forms of robotics. About 7 yrs ago, I thought cozmo/vector, had potential, esp with their team’s ex-pixar experience, but these products seem to have become hollowed out after running out of startup cash and being sold off 😢 The programming aspects of these consumer robots are pretty disappointing too - mainly relying on block based programming, which seems quite primitive compared to what the hardware is capable of. I guess the more modern approach is to use some blend of ChatGPT-esque interface, but that’s quite clunky too.

Anyone know of any delightful programming interfaces for robots? Or other interesting alternatives to the Terminator style robots coming out?

^ To be fair, when it worked, it was amazing 😍 They even got the original voice actors, to add to the nostalgia value.

Content

🚀 Plan 9 night via Jeff Lindsay

🧵 conversation

Good to see people excited about the history of coding as well! I'm hosting a Plan 9 night this Friday if anybody is curious about the forgotten successor to Unix. It's a watch party of curated videos on Plan 9 from Bell Labs, its history and ideas, and possibly some live demos.

🗺️ Wardley maps via Kartik Agaram

🧵 conversation

I've been drawing Wardley maps for a couple of years now, and also creating debug UIs inspired by Glamorous Toolkit. It's surreal to see Simon Wardley and Tudor Girba collaborating.

🎙️ Gigahand Dreams long form interview podcast via Tak Tran

🧵 conversation

Loving the Gigahand Dreams long form interview podcast atm. It’s a nice intersection between tech/art/education/making, from Jay Silver who is one of the people who created the Makey Makey.

Last interview I watched was with Andy Cavatorta, who makes these big crazy tech art contraptions eg, an instrument for Björk and a 5 player pinball machine to teach the ideas behind economics.

Some highlights from it:

• “How to make things you don’t know how to make” - prototype a lot ! And be relentless about it - __ “prolific prototyping” and “discovery orientated design”

• Mouse in a maze types

• The specialist - can run one specific maze, really quickly

• The generalist - has the fortitude to wander many mazes, but not quickly

• The prototyper - can run unfamiliar mazes quickly, solve unfamiliar problems

• Telharmonium - the first electronic music streaming service made using giant organs and the telephone switch board

• He’s created a curriculum for teaching his prototyping process that he has developed over the years, and takes you through algos, maths, electronics, physics, using making tools and programming - which sounds amazing! Too bad I ain’t in NYC though.

Music

🎼 Jacob Collier x MusicFX DJ via William Taysom

🧵 conversation

See Jacob Collier play with Google's MusicFX DJ. He basically uses MusicFX as a sort of silly sampler. It's a more interesting use than whole-cloth generation. This is what he comes up with in about two hours.

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

🎥 FoC Virtual Meetup 8 📢 HYTRADBOI 2025 🎹 Sound As Pure Form

Two Minute Week

🦋 It's worth explaining how I'm making these semantic zoom demos with just CSS via Christopher Shank

🧵 conversation

I put together a brief writeup about how I've been doing semantic zoom with just a little CSS. I feel like I haven't seen a lot of recent visual programming interfaces (although there are certainly a lot of prior art) take advantage of fluid zooming and geometric encapsulation. Here's a couple small demos:

🎥 Screen Recording 1

🎥 Screen Recording 2

🎥 Screen Recording 3

Our Work

📝 Pure CSS Mixin for Displaying Values of Custom Properties via Roma Komarov

🧵 conversation

Finally, finished my most recent article (and published a package): kizu.dev/preview-mixin — a lot of overcomplicated CSS, but one that makes it much easier to debug various dynamic values. For now, it is mostly for displaying them as text when possible, but I have a few ideas about some other visualizations. I already used it for a few experiments — and seeing the values of what you're working on in real time really helps.

💻 levlo.com via Jarno Montonen

🧵 conversation

My natural language programming technology, Levlo, is now a "LLM Integration Platform". Updated the site: levlo.com. The Document Agents stuff is something I have not shared here before: levlo.com/document-agents. Any feedback appreciated!

📝 Of Interest via Paul Tarvydas

🧵 conversation

FWIW: this is a reply I made elsewhere. Hoping it might be of interest here.

🎠 Practicing graphical debugging using too many visualizations of the Hilbert curve via Kartik Agaram

🧵 conversation

🎥 Video

🎥 Transclusions and Rectangles via Robin Allison

🧵 conversation

Here is something I've been working on for a while that I've finally figured out how to do. You draw rectangles in the plane and 'transclusions' between them. Transclusions produce copies which display only in the target. Transclusions copy rectangles to produce new (cropped) rectangles. Transclusions also copy copied rectangles. Additionally, transclusions copy transclusions, which in turn copies transclusions and rectangles as well. Because rectangles can be moved around and resized every transclusion copies every rectangle and every transclusion ad infinitum at all times (though currently we stop after four steps). You can think of this structure as something like a syntax tree whose pieces can be moved in and out continuously at will, and two way transclusions as a kind of symbolic variable with the symbol missing. The math behind all this is really interesting too, but I probably don't want to go on about that here.

(cc @Elliot and Lu Wilson, thanks for inspiring me to think about rectangles and affine transformations! Also cc Jonathan Edwards since transclusions are very similar to inclusions from First Class Copy and Paste.)

Devlog Together

🧰 das2json.js via Paul Tarvydas

🧵 conversation

Created yet another diagram-to-json converter in Javascript by asking Claude 3.5 nicely to convert the existing Odin version to Javascript.

📝 Draw.io via Paul Tarvydas

🧵 conversation

I got live update messages to work in DPLWB. Draw.io -> choreographer.py -> spawn transpiler -> choreographer.py -> dplwb.html. The transpiler, while working, sends little updates (JSON objects (an array of one object consisting of a pair of strings)) to the choreographer which are immediately sent to dplwb.html. Final result is sent to dplwb.html as an array of JSON objects. Turn-around is "fast enough" (seconds) to be usable in bootstrapping and debugging this stuff more deeply. [DPLWB == Diagrammatic Programming Language WorkBench]

🎥 DPLWB with Live Updates

🎛️ GOOD KNOB via Ivan Reese

🧵 conversation

I've been tinkering on a way to handle continuous numeric input. Or, in plainspeak, a knob … that you can turn. But it's, like, good , as far as knobs go. (Fake computer knobs, at least.)

• It does the usual thing… you can drag up-and-down to turn the knob. Classic.
• Oh! You can also drag left and right to turn the knob. That's nice.
• Wait… you can crank in circles around the knob? And that works well too?
• But but but… you can also crank in circles, like, anywhere on the screen!

The goal is "do what I mean" gestural input. Granted, it's currently dumb and could be better, which is why I'm still tinkering on it.

You can play with it here. Code is here.

🎥 GOOD KNOB

Thinking Together

💬 Matt Rasmussen

🧵 conversation

I've been thinking about what libs and pkg indexes might look like as coding assistants become the norm. What if instead of packages providing a post_install.sh script (to regex config, add symlinks), they had a post_install.md prompt to help integrate the code into your app.

Libraries and packages indexes (especially language specific ones) have been a boon for code reuse. But they can only be used for code that can be cleanly abstracted. I often encounter chunks of code I wish could reuse as a lib, but I can't because I can't abstract it well enough

But if you wanted to package up a partial table schema and some prompt about how it could be rendered in a UI, then the package manager+coding assistant could auto merge the partial schema into the user's existing schema and even make the right UI updates to show the new fields

This might really help when building apps using coding assistants. Having assistants write so much code from scratch still feels unpredictable. What I really want is to be able to suggest from an index of code fragments and prompts which things to glue into my app.

Such a package index would encourage open source contribution of prompts plus pre-made code fragments. I'm interested in others thoughts.

💬 Jim Meyer

🧵 conversation

AI-coding (chat) to create UIs — working software you can own — is the "worse is better" existential threat to traditional design tools and no-code.

This is as big, or bigger, than the "worse is better" that JavaScript pulled off for the Internet.

Chat is slow, but it gets the job done in a super accessible way, hence the "worse is better".

The real prize will be to combine the best parts of chat with the best parts of the canvas in design tools / no-code tools.

💬 Oleksandr Kryvonos

🧵 conversation

I was sceptical about LLMs up till yesterday,

what changed? - arrival of Deepseek R1

Do I think it is "Sputnik moment" - not entirely,

I think it is more like an "Apple I moment" - in a sence that now more people can experiment with this idea,

And the tools are no longer in the hands of only big players.

I will explore the combined approach - I will use LLM with some simple workflows,

For example verification/critique of answer first.

And I will research the subject more carefully.

I do not have powerfull hardware - Apple M1 and SteamDeck ,

So I hope that these limitations will benefit me.

🤔 How might AI change programming? via Mariano Guerra

🧵 conversation

Interesting list of questions to think about

It will change it. But how?

💬 Jason Morris

🧵 conversation

Is it neuro-symbolic AI if a generative AI system is used to generate a symbolic representation, which is then modified by a human user, and provided back to the generative AI in a later phase? Or does neuro-generative AI specifically require automated reasoning over the symbolic knowledge? I'm playing with a system for editing propositional argument maps that were generated by an LLM, and I'm not sure that counts. Is it "reasoning over symbolic knowledge" if a symbolic data structure is only being used to generate a graphical UI? It seems borderline, but I'm inclined to think not, and if we aren't reasoning over it, it doesn't count...

💬 Jon Secchis

🧵 conversation

Hey, folks. I'm experimenting with a universal structured input interface for my research project. The idea is that commands/functions will provide a schema and invoking them prompts the user with a form. I'm pushing for super tight constraints on information density (I want interfaces to spread over time to save screen space, non-negotiable). Now since inputs are going to be generated I cannot have exceptional designs/behavior – it's all going to be rigorously data driven and I can only affect the design/experience by changing the data model. Below are two videos showing how a user would invoke a function for data input. Each video represents a distinct data model. The one with a tabular data model yields a short "time-to-first-field" (less overhead) interaction. The one with a composable tree model (much much more powerful) yields more overhead (2 more steps to reach the first field). Can you share your opinions? Not seeking any specific kind of feedback, just wanna hear your thoughts.

🎥 prototype editor short

🎥 prototype editor long

Content

🏢 Umpteenth take on "Programming As Theory Building" via Kartik Agaram

🧵 conversation

Umpteenth take on "Programming As Theory Building"

One thing I haven't thought to mention until now, in all the conversations about this paper. Between 2019 and 2021 I had perhaps the influential experience of my dayjob career. I got reorged to take over a legacy codebase, and after some initial struggles became expert with it to the extent it felt like my baby, something I'd written myself. And it wasn't just me; I gradually became the tech lead for the team, helped others understand it, and for a while[1] the team was able to own it and make improvements to it.

Factors that made this possible:

• The codebase was relatively recent, just like in OP.
• The codebase was well-designed, just like in OP.
• One of the original authors was still in the company, and welcoming to questions. This one is not like OP. And it was crucial.

[1] What happened after? The company decided it was old, banned changes to it, chased a new shiny thing and let it decay. Companies find many, many ways to fail.

📊 The Communal Plot | A Daily Visualization We All Build Together via Bill Mill

🧵 conversation

this is a small neat thing: perthirtysix.com/communal-plot-daily-poll

Interactively respond to a daily poll and see how your responses compare to others in real-time!

🎹 Sound As Pure Form via Mariano Guerra

🧵 conversation

Sound As Pure Form - a Forth-like language for audio synthesis using lazy lists and APL-like auto-mapping.

From the creator of SuperCollider

Other languages that inspired this one: APL, Joy, Haskell, Piccola, Nyquist, SuperCollider.

📝 The Future of Coding: ignore users, build for cyborgs via Kartik Agaram

🧵 conversation

📝 The UNIX Time-Sharing System: D. M. Ritchie via Xavier Lambein

🧵 conversation

Expanding on @Jon Secchis's video from last week, here's a 50-page memo on the design of Unix, written by Ritchie

Present Company

🎥 Virtual Meetup 8 • January 22, 2025 via Ivan Reese

🧵 conversation

Here's the recording of the Future of Coding Virtual Meetup 8. Once again, I've added notes and timestamps to the description. For next month, we're considering trying a different day/time than our usual Wednesday eu-evening/na-morning. Maybe a few hours later, maybe a weekend, who knows. Leave a reply in the thread if you haven't been able to join our other meetups but would love to join the next one. It might be nice to try a bunch of times and get different folks to cycle in/out.

📢 HYTRADBOI 2025 is a fun online conference about databases, programming languages, and everything in between via Jamie Brandon

🧵 conversation

HYTRADBOI still has plenty of room for more lightning talks, so I'm going to extend the deadline to Feb 16. Check out hytradboi.com/2025#lightning-talk-buffet for details.

Also the program is up and tickets are live.

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

🎥 Embedding a structured editor 🦠 Cells & More Cells 🐛 Debuggers & More Debuggers

Two Minute Week

🎥 Embedding a structured editor in blog and slides via Peter Saxton

🧵 conversation

I've Implemented an embedded version of my editor so I can structurally edit code snippets in blogs or in slides.

Using the effects in the web platform I can even send tweets from the snippets in a slide.

🎥 Assembly Kickoff 🎮💻 AUTOMAT DEVLOG 2 via Marek Rogalski

🧵 conversation

Some news from Automat. I'm tackling the problem of control flow now. I think its the central issue for establishing interoperability between different types of software. Knowing when to continue work in parallel vs wait for completion, how long to wait before giving up, whether to retry, alert or crash, when to save & restore state, etc. Generally all the things called "glue code". They're not essential to "solving" any specific problem, but are still necessary for any practical application of any solution. I believe that with proper design all of those functions could be implemented as virtual devices, intuitive enough that folks without formal education could use. That will take time though. This is my interim solution . It's meant to allow folks with sufficient dedication to implement the missing functions, without scaring them off. Most importantly it only requires three virtual devices to achieve virtually all control flow primitives (Instruction, Instruction Library & Assembler) so it's feasible to do in a relatively short time.

I'm also attaching a WIP design for the "Instruction Library" object. If you're bored you may try to guess what which icon matches each x86_64 register (due to lack of space, only two REX registers are shown) :)

Our Work

📝 Cells: Want to show a grid of cells on a screen? via Lu Wilson

🧵 conversation

i made another explainable about how to draw a grid of cells

🎥 Making Cell Episode 1 via Federico Pereiro

🧵 conversation

Yesterday I recorded the first episode of Making Cell, which is basically going to be about building cell from the ground up, live. In this episode, I explain the basics and put some The Smiths in the background.

💬 John Christensen

🧵 conversation

At yesterday's meetup I demoed a node and wire tool I'm working on in the scientific computing domain.

@Márton Gunyhó had an interesting question, so I'm sharing here in case anyone has any related thoughts:

do you use some graph algorithm to figure out what needs to be recomputed, or do you keep all intermediate values in the wires in memory? I imagine the latter would get pretty heavy pretty fast.

Currently I've gone with the simple/naive approach of just keeping everything in memory. This is nice because any long-running nodes at the top of the network don't need to recompute when their descendants need to re-run. This does mean that you can run out of memory quickly if you are dealing with large pieces of data though.

I'm not sure what my long-term solution is yet. Currently my thoughts are to start dropping/caching-to-disk large pieces of data as memory usage to get too high, and recompute when they are needed again. In the meantime, it's not too bad for the primary use cases I have in mind to simply be content with working with a subset of data that fits into memory.

📝 File Systems: The Original Hypermedia via Jon Secchis

🧵 conversation

Wow, lot's of great stuff you all are posting here! So exciting 😃

I'd like to share something too, it embraces the "scaling-down" sentiment I am seeing in other projects here.

I designed a semantic hypermedia data structure (FIFO) with a "higher-order" syntax, allowing form to be transferred across text/gui substrates. The general idea was to see how closely you can emulate hypermedia documents using just semantic and semiotic rules. These rules are then encoded in a rendering pipeline to systemically present the data on the screen. It sounds fancy but in practice it's very mundane.

FIFO's syntax is actually inspired by the file system information model, which, as we know, has these properties, allowing trees to be rendered systemically and consistently in whatever style, but without any loss in meaning. Not only file systems, though, this is a very pervasive modality, such as the universality of frequencies in relation to the particularities of timbre, or natural language itself, which is very malleable in terms of encoding, preserving meaning mostly intact regardless of representation. This sort of thing is only possible with models that are purely abstract, immaterial, but yet well defined.

Now this is not just for fun, it can be very useful to have a document language like in some scenarios, for instance, to very cheaply and quicky compose and distribute multimedia information. I made my website using FIFO, and also a portfolio for a friend of mine. It's just a proof of concept at this point, I invested very little in the rendering part, just enough to make it usable. In the future I'd like to make an editor for it, for now I just write it by hand. You can check the links below to see it in practice. Before anyone asks why bother with all the work to have a worse version of markdown, consider that: 1) this is not markup but a data structure, it has it's own in-memory DOM and query interface, 2) it's extensible, 3) it's hierarchical, so you can have directories in the document, 4) it's mathematically rigorous, 5) is composable, and some more things. The fact it looks like a basic document is consequential, as the whole idea was to capture the stereotype but starting from a different principles. There can be different visual renditions, too, I'm just not so much creative in this department.

visual repr: jon.work/og

text repr: jon.work/og/index.fifo.txt

visual repr: jon.work/fifo

text repr: jon.work/fifo/index.fifo.txt

visual repr: henriquecesar.pages.dev

text repr: henriquecesar.pages.dev/index.fifo.txt

🤏 A WebAssembly compiler that fits in a tweet via Mariano Guerra

🧵 conversation

I wrote a blog post undoing one by one the tricks I used to write a Wasm compiler for a Reverse Polish Notation calculator that fits in a tweet

Devlog Together

🎠 Infrastructure for Graphical Debugging via Kartik Agaram

🧵 conversation

4-minute video update on my "Emacs for visualizing LÖVE apps": it no longer looks very much like Emacs at all. I think all it shares with Emacs is a flat namespace of handler functions that you can compose to create windows with different experiences around shared data.

💬 #devlog-together@2025-01-07

💬 Jimmy Miller

🧵 conversation

As I was trying to build a debugger (well, a frontend to lldb right now) for my language, in my language (beagle), I was getting a weird bug I couldn't figure out. So I decided to build a little compiler explorer tool for it. The left is the code, the middle is my (already register allocated) IR, and the right is the machine code. (Don't look too close, there are some bugs in how I print the machine code like and doesn't apply the shift).

The UI is incredibly ugly, because hopefully this is the last UI I need to build for my language that isn't built in the language itself. Using the UI I was able to figure out the bug. It turns out, if I had a compilation cycle with code > 3 pages of memory, I wasn't doing the accounting properly and writing the over existing code. Ironically, the way I built this tool meant, I saw my code was right, but the code I was stepping into the debugger was wrong. So the tool showed me the bug by the absence of the bug...

Now I'm continuing on to building the debugger in itself. Having a real application is helping me realize features I need and forcing me to think about what I want my language to feel like to program.

💬 Tom Larkworthy

🧵 conversation

I added the missing ability to upload File Attachments into the HTML bundle thing (this also adds the ability to add local files to Observable notebooks as its all userspace).

I am somewhat at a fork in the road about what to do about state. I prototype a cell mutating itself, and now I also have the ability to programmatically write binary blobs into itself. IndexDB is not so relevant here because every time you fork, you lose that kind of browser state as the domain switches).

So should I use cells to store state? they are cool because they are reactive and programmable, or do I use files to store state? Files are a bit more classic, maybe a bit easier to eject and upload into a different notebook. I think I lean towards files as the long term data store, seems like it would be easier to interop with other systems.

🎥 Lope

📱 A program on my phone with a custom debug UI via Kartik Agaram

🧵 conversation

A program on my phone with a custom debug UI.

Pretty hilarious. After spending a week creating spaces for custom debug UIs, I realize a different fork can already do all that. On my phone. By repurposing a script I wrote a year ago.

I did deliberately design screens in Lua Carousel to support sharing and exchanging data. But I didn't appreciate all the benefits.

💬 #devlog-together@2025-01-19

🎥 hilbert debug phone spedup

🔤 Sand Letters via Ivan Reese

🧵 conversation

I'm tinkering on a little sand experiment with @Elliot. Without dipping too far into spoilers, you have a small selection of tools you can use to fill the screen with grains of sand and then move them around, with brushes (of a sort) that each have a bit of logic (eg: scatter the sand randomly, push the sand downwards, merge sand grains together). What's fun about these brushes (of a sort) is that they apply some behaviour that feels like a computation. So you sort of brush your computation over some data (sand).

One possibility I've been mulling, that I'd love to hear some ideas for, is a brush that does cellular automata. The brush might use some global grid (discrete) or sense of proximity (continuous), and apply some CA-esq rules depending on the density of the sand. Then you'd just brush that computation onto the sand to advance the state of the CA. Maybe each brush stroke advances the CA one step wherever you apply it, or maybe the CA runs continuously but only where you're brushing. The thing I'm presently brainstorming is… how might one specify the CA-esq rules just using sand and brushes?

sand letters

🗨️ Kartik Agaram

🧵 conversation

With 💬 #devlog-together@2025-01-16 on my mind, here's an example single-file html with some support for annotation. Save it locally, swap out the text with some stuff to read, take notes on it as you read, save your notes locally. Thanks @Eli Mellen and Tom Larkworthy in particular for the inspiration. Based on Cristóbal Sciutto's note example. Suggestions and feature ideas welcome.

🎠 building out a custom debug UI via Kartik Agaram

🧵 conversation

One nice thing about building out a custom debug UI as I'm writing a program: it turns into an explorable explanation by the time I have a working program. Here's a (silent) explorable explanation for a simple program that I nonetheless struggled to get right.

Each screen is a hundred lines beyond Lua Carousel (which has existed before this whole idea of debug UIs was a twinkle in my eye)

🎥 freewheeling debug

📔 Added a context menu via Tom Larkworthy

🧵 conversation

Added a context menu so it was a bit more obvious how to add new cells. hosted page is here. Maybe this is enough webpage stuff for now and I should start porting my notebooks. Its getting a bit laggy now as well which I think is because the reactivity is not fine grained for most of the UI (underlying calculations are though).

🎥 context menu

Thinking Together

📝 Whence Bloat? via Paul Tarvydas

🧵 conversation

Doodles for discussion towards simplification of computers for non-programmers.

💬 Karl Toby Rosenberg

🧵 conversation

I found that indentation in programming languages like Python, at least with some of my students, seems to be a point of confusion. This idea of introducing spatial thinking and jumping around seems to conflict with our learned way of reading text on a page. The closest thing is textual paragraph indentation.

Maybe there are some studies that contradict me, but couldn’t braces or begin/ends actually be better? Or something built-into the editor.

Why couldn’t this be acceptable?

# instead of:

if bla:

    do_bla()

   if blabla:

       do_blabla()

   else:

       other()

else:

    other()



# do

if bla {

do_bla()

if blabla() {

do_blabla()

}

else {

other()

}

else {

other()

}

Okay it’s hard to read, but it makes me think: any block of code could really be its own function, and suppose we had a kind of function that was purely an inline macro to jump to without any stack rules. The goal would just be to make code look as procedural/linear as possible.

if bla do_bla() else other()



#define do_bla somewhere somehow in a way that keeps the same scope without param/stack rules

Sure this would probably require more annoying steps and jumps for some, but I do wonder how it might impact early learners or maybe prove useful (or not useful) for understanding control flow

Maybe if an editor could automatically inline code folding off and off with these macros…

Probably more of a structured/dynamic editor that isn’t just pure text.

I’m sure this path has been followed before, but I wonder.

It’s really just closer to ASM languages with the conditional jumps and islands of code. Strangely, I find those pretty not so hard to understand. No nesting.

📝 Three thoughts on the summer of AI via Federico Pereiro

🧵 conversation

Hi everyone! I just posted a short article with three thoughts on the "AI summer": federicopereiro.com/ai-summer

If anyone has similar (or contrasting) experiences, I'd be glad to hear them!

• UI through AI: the possibility of replacing more parts of the UI with AI
• LLMs shrinking the area of training with own data
• Temperature rising

💬 Xavier Lambein

🧵 conversation

A thought occurred to me while checking Kartik Agaram's post on #devlog-together A Web page is a convenient medium to write a small application for yourself and distribute it. But it's also limiting, because of the browser. You can't easily edit local files, requests are limited by CORS, you can lose data if the browser's cache is emptied, etc.

So I'm wondering: is there a sort of "browser for local apps", which would be just a webview with some of the browser's limitations lifted? For example, I could use Kartik's single-page app for annotating text, but instead of saving my changes by downloading the saved file, it would use the filesystem directly.

💬 Jon Secchis

🧵 conversation

I just realized that if browsers could display notification badges when a site is closed and showed it on the bookmarked item in the fav bar while the site is not open (no tabs), that'd be super cool and useful! Like I could visibly place sites I commonly expect traffic and allow them to fetch notifications in the background such as this very platform, email, etc. Then I wouldn't need to open the site, "waste" time/resources just to check for new messages and such

Content

📝 From Burnout to Breakthrough - CoRecursive Podcast via Tim Schafer

🧵 conversation

Hedy: Textual programming for the classroom

📝 From Burnout to Breakthrough - CoRecursive Podcast

Can you imagine risking your career to making coding easier to learn? Meet Felienne Hermans, a professor who did just that by stepping beyond academia to redefine coding education. Disillusioned by her research's limited impact, Felienne discovered a new calling in teaching coding to underserved students. Her journey led to the creation of Hedy, a programming language designed to dismantle... […]

🤔 What is Code? by Paul Ford via Jasmine Otto

🧵 conversation

god, this longread on the software industry hasn't aged in a decade

Somehow it keeps working out. The industry is always promising to eat itself, to come up with a paradigm so perfect that we can all stop wasting our time and enter a world of pure digital thought. It never happens.

it's very much a bird's eye view but there's a fantastic balance between the beauty and the ravenous ouroborous

Languages are liquid infrastructure. You download a few programs and, whoa, suddenly you have a working Clojure environment. Which is actually the Java Runtime Environment. You grab an old PC that’s outlived its usefulness, put Linux on it, and suddenly you have a powerful Web server.

🧱 Pantograph, a structure editor via Xavier Lambein

🧵 conversation

Very cool work on a typed structure editor presented yesterday at POPL: Pantograph, a structure editor

With a demo available online here: pantographeditor.github.io/Pantograph I just worked through the tutorial myself, it's very pleasant to use overall.

🎥 UNIX before Linux (1982) via Jon Secchis

🧵 conversation

Worth rewatching and reflecting on what we had vs what we have now. Can be pretty chilling depending on how you frame the comparison

🐦 Alex Warth (@alexwarth) on X via Steve Dekorte

🧵 conversation

🐦 Alex Warth (@alexwarth) on X: Sketchpad running on the iPad!

(This is my plug for the @inkandswitch wrapper, check it out at https://t.co/bkx9dhM17r)

💡 Expert CSS: The CPU Hack via Roma Komarov

🧵 conversation

Finally spent time understanding what's going on in dev.to/janeori/expert-css-the-cpu-hack-4ddj

(but only for the main technique, not the way it is used for the demos in the article, like in the Game of Life demo — codepen.io/propjockey/pen/NWEYdjY (Chrome only))

Basically, re-evaluation of state in pure CSS (turing complete, all of that) using the interactions between animations and custom properties (and, currently, Chrome-only details of their implementation)

Present Company

🗽 The NYC Tech/Art/Games Triangle via Ivan Reese

🧵 conversation

The NYC Tech/Art/Games Triangle

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

🤔 Where Should Visual Programming Go? 🧑🏽‍💻 Reactive coding substrate that looks like a webpage 🐦 Influence a future Alan Kay talk

Two Minute Week

Our Work

🤔 Where Should Visual Programming Go? via Tom Larkworthy

🧵 conversation

Making direct manipulation diagrams fast to develop.

So this work was motivated by "Where Should Visual Programming Go?". I kinda thought dataviz driven development was a step in the right direction but some people here though unidirectional was too limiting. So it made me think about what a bidirection diagram was.

Grammar of graphics provides a nice abstraction of what a scale actually is. It's a mapping from dataspace to pixel space. A bidireciton diagram might go in the other direction, mouse movements (actions) are mapped back to changes in data space. Once you consider libraries like Plot are very liberal on what scales they support: non-linear, categorical etc. then the ability to manipulate data points through a diagram is pretty compelling. You stop thinking about data as external data but as control surfaces that live in a weird high dimensional configuration space of your choosing.

Inverting scales is reasonably easy, once that general primitive is in place then you get a shit ton of possible gizmos that take very little time to make look good and work because all the heavy lifting is done in the other direction using an off-the-shelf dataviz library.

Full explanation and code in a notebook although the one-weird invert trick is quite general.

🎥 direct manipulation

📝 Speech AI has 10x’d: purpose, evaluation, and products via Kilian Butler

🧵 conversation

I wrote a blog post for anyone building AI models, rethinking human-computer interaction, or just looking to build truly great speech products:

• Why TTS is finished as a model paradigm—and what’s next with multimodal speech synthesis.

• How model evaluations must evolve to focus on communication, not just naturalness.

• Why product success hinges on understanding speech’s purpose: meaningful user intent.

📝 Composition to the Rescue via Guyren Howe

🧵 conversation

Devlog Together

💬 Kartik Agaram

🧵 conversation

I've been trying some new stuff lately:

• Decker. I'd for some reason assumed it was some npm and/or wasm monstrosity (perhaps because it's so dang inefficient), but it turns out it's nice zero-dependency Javascript in a single html file! And that's in addition to the native version that uses SDL just like LÖVE. So in some ways it has a better cross-platform story than LÖVE, which is non-trivial to run on iOS.
• Rust. I spent some time playing around with a LÖVE-inspired game engine called ggez, and the much more basic wgpu crate. The promise here: Rust seems to be evolving some pretty nice cross-platform tooling, so in time we may end up with a world where it's easy to cross-compile to any platform. Of course, the compile step is not ideal, but it promises to yield much more efficient binaries that might run on lower-end devices like old phones. The eco-system is not quite there, and the npm-like dependency explosions are rough. But I want to try to look outside my comfort zone. It's possible the way forward isn't unique-snowflake minority platforms like LÖVE or Decker, but just to use a majority platform with better taste, taking the time to understand and curate the landscape of dependencies.

🎥 decker

🧑🏽‍💻 Lopefile: a reactive coding substrate that is configured to look like a webpage via Tom Larkworthy

🧵 conversation

I added Plot and therefore d3 to the hermatic notebook self hosting html bundle thing, also uploaded it to a domain.

UI is a bit rough for adding cells, bit its quite ok at editing existing content.

Thinking Together

📝 Practical Parallelism via Paul Tarvydas

🧵 conversation

As I understand it, to achieve true concurrency on a single computer, you need to ensure that app code sits in one of the core-private caches (L1, L2, but not L3). Thoughts

🦋 I just asked over on bsky: via Gregor

🧵 conversation

I just asked over on bsky:

I'm morbidly fascinated by Business Process Modeling. On some level it's exactly what I want: end user programming.

But then the only people I heard speak positively about it are vendors, which is very much not what I want

It's also a non-topic in the alt programming circles I frequent. Any takes?

I guess I could've just put it here. Curious if anyone has thoughts on it

🐦 Unique chance to influence a future Alan Kay talk! via Anselm Eickhoff

🧵 conversation

Hey folks!

Unique chance to influence a future Alan Kay talk!

• If you could ask Alan Kay anything, what would you ask?

Twitter thread / Bluesky thread

1. Now he has some questions for you!

Twitter thread / Bluesky thread

Feel free to reply here as well

Present Company

📝 Cat Hicks (@grimalkina@mastodon.social) via Jasmine Otto

🧵 conversation

📝 Cat Hicks (@grimalkina@mastodon.social)

We are designing a new research project in the Developer Success Lab, and we're seeking to understand software engineers' experiences with incidents ! Good, bad, ugly, all of it!

Have a big story or strong POV on this? We're bringing together a small community group for a one time zoom session, to share stories and help us learn. You'll directly influence what the lab studies on this.

You can let us know if you're interested here (more details below):

Incidents community-group

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

💻 Moldable Webfile 📝 Coding is not the new literacy 🖐 Wrapper: Better web-based prototypes for iPad

Our Work

📝 AI risk I don’t see discussed via Guyren Howe

🧵 conversation

Hopefully this is regarded as sufficiently on topic…

I’ve started a personal blog. My first post is on an AI risk I don’t see discussed.

💻 Moldable Webfile (prototype II) via Tom Larkworthy

🧵 conversation

OK I finally put all the pieces together into a coherent whole but its still an MVP

tomlarkworthy.github.io/lopecode/webpage.html

a self-hosted, self-sustainable, recursively exportable, offline-first, file-first, hermetic, web-based programming substrate based on the Observable runtime (and the source code is an Observable notebook)

I am seeking ideas on what to do next with it next? What would make it desirable to use for a project? There is an AI in it but I don't have a UI for it. Or maybe I figure out how to do content editable cells, or maybe port some bigger demos (e.g. 3d stuff, maybe VR?)

🖐 Wrapper: Better web-based prototypes for iPad via Ivan Reese

🧵 conversation

Here's a little thing I made that solves an extremely specific problem.

At Ink & Switch, one of the things we're researching is a new kind of "dynamic notebook" — something sort of like a pad of paper, but programmable. As part of this research we build a lot of little prototype apps. We use the web platform for prototyping because the iteration time is really fast. We run these prototypes on iPad, because the form factor (tablet + stylus) is very close to what we have in mind for our dynamic notebook. But a limitation of the Safari browser on iPad is that you can't receive simultaneous input from the Apple Pencil and your fingers.

To work around this limitation, we built a little native iPad app in Swift. It loads a URL of your choosing (ie: the live-reloading dev server running your prototype de jour), then captures all incoming touch and pencil events on the native side and forwards them to the JS context. Just like that, your JS code gets full-fidelity (ie: 240 Hz) simultaneous input from fingers and the pen. And, if you want to hack in additional features that aren't available via the browser — like haptic feedback — you can easily whip that up on the Swift side.

I've just packaged-up this Xcode project and some example JS code and put them up on Github: Wrapper. The code is covered by the Unlicense (public domain) so that you can scavenge this thing for parts without worry about credit or whatever. Just make shit!

So, if you have a Mac, an iPad, and an Apple Pencil… and you want to do some experiments with rich gestural interfaces… and you want to write those experiments in JS… and you're in a hurry… then this project might be useful for you :)

📝 The Organization of Digital Information Systems via Federico Pereiro

🧵 conversation

Hi everyone! Over the last three months I've written a treatise (fancy noun!) with a view to understand computation systematically. My goal was to create, at least for myself, a coherent picture of what's essential about all this bit pushing we do individually and societally. I intend that picture to be empowering and actionable to those of us trying to make sense of systems, as well as build (much) better systems.

It's about 40-50 pages long, so it's not short, and probably quite dense, despite me trying to make it as conversational as possible. I have a visual summary of it linked at the top but it's yet incomplete (I'll finish it tomorrow).

My goal in posting it here is to get some feedback. I'm especially looking for thoughtful disagreement, particularly concerning my main points. Something quite at the top of Paul Graham's disagreement hierarchy. I'm really open to challenge to my main points; if what I wrote is any good, it should be anti-fragile and get better with a good critique. And if it doesn't, hey, at least I learned something! And I'll be happy to share what I learn from you too (as long as you manage to convince me).

Here it goes: github.com/altocodenl/todis

💬 Cole Lawrence

🧵 conversation

I’m working on a new way of writing “dense” UI inspired by MVVM + ECS, and this is the debugger for the “View Model Components” (VMCs?) in the UI

The problem I’m usually facing with my apps is that we aim to pack many many features into small areas (for example: context menus, keyboard shortcuts, focus management, spatial navigation, version control diff presentation, multiplayer user presence, and then the parts that are unique to your app).

My goal in managing this complexity is to be able to write each individual part of the application in its own single file. All things related to “module” editing, diffing, keyboard shortcuts, spatial navigation, CRDT sync, etc should be in a single file. Then, each shared behavior’s logic are implemented in their own single files. This is what is best as well for LLMs to understand and build out features without needing to understand everything all at once.

Here, I’ve taken a video of just the “debugger” I developed in the last two days to observe the state of all these components for each item in the world.

🎥 Phosphor

Devlog Together

💬 Kartik Agaram

🧵 conversation

Progress on "Emacs for visualizing LÖVE apps": I have the first message between windows. I press a key, the key gets processed by the first window's keymap and dispatched to a function, which reads the selection, parses it and sends a message to the second window. The second window then responds to the message by adding a new object into its scene.

In principle, this approach feels nice and timeless. I think "every window is a scene and runs its own event loop" is more general a foundation than Emacs's "every window is a buffer containing text." It feels realistic to provide this foundation alongside a wide library of primitives for text rendering and analysis.

In practice, I've been struggling to find a focus, and I'm probably going to focus on creating tools for myself to more visually debug the LÖVE apps I create. I'm not going to focus at the moment on:

• editing the source code for the environment in the environment, the way you can modify Emacs sources from within Emacs. I already have a way to do that: you open a second window and modify the app live as it runs.
• interfacing with other processes or tools besides LÖVE, the way Emacs lets you connect to any programming language REPL.

Both these are totally feasible. I don't think any crucial infrastructure is missing here. They're just not priorities for me right now. I plan to focus on more easily adding new windows to a LÖVE app, and creating new kinds of debug UIs in them.

One open question: supporting focus follows mouse. I don't know if it's possible in Emacs, and even if not I think it makes a lot more sense in a more graphics- and mouse-centered environment. Again, not a priority but perhaps this is a sign this foundation is not quite as timeless as I would like.

🎥 motley message

💬 Kartik Agaram

🧵 conversation

The kids have been playing with a pen on a pendulum, I don't know what the technical term is for it, but that didn't stop me from playing with it. This way I can adjust the friction.

🎥 pendulum

💬 Tom Larkworthy

🧵 conversation

I think there is a shortcut to direct manipulation by "inverting" grammar of graphics.

🎥 direct manipulation

Reading Together

📝 Naur: Programming as Theory Building via Federico Pereiro

🧵 conversation

My first time reading a classic: Naur on programming as theory building.

Loved the article and disagreed with almost everything. Sharing my private thoughts without polish or much justification, in case someone's interested in a dissenting opinion 😅

• I think Naur is not quite right. It's not theory building. It's the building of a representation of reality, that in itself can be a part of reality.

• My take: if programs are much more readable, and we have a set of universal constructs for thinking programs, then reading and modifying a program doesn't require an external entity. There needn't be a private theory of the program except for the program itself (and any documentation in natural language). The theory should be readable from the constraints and the words/calls used in the system.

• Simplicity can be evaluated as relative length of two solutions that do the same thing.

• "Theory" can be rediscovered by studying both the problem domain and the solution.

• Naur's concept of the theory of a program is downright animist. The theory is an entity living in the programmers that created the program, and can only be communicated by them while they are working in the program. When the program stops being worked up, the theory quickly fades and dies. No amount of program or documentation reading is going to revive it.

• I think a more accurate and constructive view of programming considers it akin to an intellectual or scientific discipline, where a thread can be maintained over time through language, even if the chain is not transmitted orally.

Content

🧑‍🏫 PhD in Digital Movement for Interaction Design via Joel Gethin Lewis

🧵 conversation

Opportunity for a fully funded practice based PhD in Digital Movement for Interaction Design in Oslo, Norway, through my friend Lise Hansen: jobbnorge.no/en/available-jobs/job/272911/phd-in-digital-movement-for-interaction-design

🐦 GalaxyBrain. A powerful JSON-based information operating system via Marcin Ignac

🧵 conversation

"GalaxyBrain. A powerful JSON-based information operating system. " - looks super interesting

📝 Coding is not the new literacy via Oleksandr Kryvonos

🧵 conversation

my notes app suddenly revealed the link I read a while ago, due to the fact that I rewrote search function

🎥 Proofs without words: the example of the Ramanujan continued fraction via Mattia Fregola

🧵 conversation

Proofs without words: the example of the Ramanujan continued fraction

🎥 SIGGRAPH Asia 2024 – Real-Time Live! via Dany

🧵 conversation

Interactive Music Effect Playground, may be of interest.

Present Company

💬 Tomas Petricek

🧵 conversation

For a research project we're doing, I'm looking for some Excel experts - if you (or someone you know) have done something non-trivial with Excel, please let me know! We are thinking of doing some additions to the spreadsheet programming model and are curious how people currently solve the kind of problems we are interested in - so we want to ask people to solve a series of task and see how they would think about them. (I know it is hard to say who is "Excel expert" - ideally, we are looking for people who will have some thoughts about different ways of structuring larger things or encoding some kind of simulations using Excel.)

📞 Call for Case Studies via Vitorio Miliano

🧵 conversation

Hey, folks, if you're working with AI to help you spec, prototype, or build your projects; or if you're designing forward-looking interfaces to help utilize or apply AI, I'd encourage you to put in for a talk at Rosenfeld Media's upcoming Designing with AI 2025 conference. A colleague is doing the curation, and they're looking especially for cutting edge explorations like get shown here on the regular (just looking in #share-your-work, Mariano Guerra, @Francisco Garau, Maikel van de Lisdonk, @Pavel Mikhailovskii!). The CfP is short and it's currently slated to close this week: rosenfeldmedia.com/designing-with-ai/call-for-case-studies (happy to pass along any questions if you have them). The conference is fully virtual, they have a great speaker prep process, and there's an honorarium. Thanks!

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