🎙️ FoC 75 • A Case for Feminism in Programming Language Design 💡 The Power of Creative Coding 🤔 The Future of Programming with Jonathan Edwards

Two Minute Week

💬 Tom Larkworthy

🧵 conversation

My actual target goal at-the-moment is being able to export some of the existing notebooks I have on Observable to my offline-first file format, which led me to develop a programmable import so I can script grabbing other notebooks in a batch export. But after I got the programmable import working, I could not actually see the imported notebook. So that led me to add opening dependancies as extra panels in the golden layout. I was surprised when I first saw dependancies that they were actually executing, although its kinda obvious in retrospect coz of how Observable runtime works*. When I saw them running I then wanted to edit them, which I just added. Then, as a consequence of the editor being implemented in userspace, you can now live edit the development tooling itself! Kinda cool.

I still have not achieved my goal, but I am happy that these synergies are starting to emerge from combining userspace and development tooling inside a shared runtime.

* I have not chewed through the fully consequences of this, but it means you no longer need to plumb development aids all the way to the top like in Observable. For example, an LLM coding assistant can offer its advice without its UI spilling into the primary notebook.

🎥 live editing ui

Our Work

🎥 Origins of Multitasking and Coroutines via Paul Tarvydas

🧵 conversation

I found myself explaining how bare CPU hardware works and waving my hands in front of the camera, at this week's online Torlisp meeting. Later, I drew the pictures in draw.io and created a Keynote (Apple's version of Powerpoint) slide deck. FWIW, here it is (with some AI for generating the narrator's voice): 🎥 Origins of Multitasking and Coroutines

🎙️ Future of Coding • Episode 75 • A Case for Feminism in Programming Language Design via Ivan Reese

🧵 conversation

In the academic field of programming language research, there are a few prestigious conferences that you must present at to advance in your career. These conferences are rather selective about which presentations they’ll accept. If your research work involves proving formal properties about a programming language, you’ll have their ear. But if your work looks at, say, the human factors of language design, you might as well not bother applying — and thus, not bother pursuing that work in the first place. Why is the formalistic, systems-focused work elevated, and the human-focused work diminished? And what are the downstream consequences, the self-reinforcing feedback loops that come from this narrow focus?

In this episode we discuss a paper by Felienne Hermans and Ari Schlesinger titled, A case for Feminism in Programming Language Design. It applies the lens of intersectional feminism to reveal a startling lack of “Yes, and…” in academic computer science, where valuable avenues of inquiry are closed off, careers are stifled, and people are unintentionally driven away from contributing to the field, simply because their passions and expertise don’t conform to a set of invisible expectations. Through heartbreaking personal anecdotes and extensive supporting references, the paper makes the case that there’s a lot of high-value greenfield work to be done, and people who would love to do it — but we will need to collectively identify, understand, and then fix a few broken incentives before it’ll happen.

🔌 Functioncharts: A Graphical Programming Language via Bill Budge

🧵 conversation

Functioncharts are a new kind of diagram for programs, with the audacious goal of being as expressive as any textual programming languages. It supports creating abstractions, and first-class iteration and recursion. The first version of this diagram is for a Javascript-like language, but it could be adapted for others (WebAssembly?) It was inspired by and borrows ideas from the Statechart formalism.

This editor project started as a specialized drawing tool to allow me to explain the ideas. But I found that trying to build actual programs was the only way to find out what worked and what didn't. The GitHub pages are the documentation for now. The editor is usable but unstable. There is no code generation or iterpreter yet.

Read the doc first. You can try the editor at this link (warning, it is a buggy prototype)

As a warm-up for this project, I also developed a Statechart editor.

billbudge.github.io/WebEditorFramework/examples/statecharts

Devlog Together

💻 Living deps via Tom Larkworthy

🧵 conversation

now in the single file programming substrate you can look at your dependancies and they are things that are running. I was kinda surprised when I first saw their demos were executing. prototype here

🎥 living deps

🎠 Extremely simple static site generator via Kartik Agaram

🧵 conversation

I seem to be alternating between working with html and Lua/LÖVE. In the last few days I've been trying to extract some more timeless tools out of the ad hoc static site I replaced my old Rails website with a couple of years ago. Here's the project. Requires just Lua (any version after 5.1) and nothing else. In particular, it doesn't mess with any Markdown variant, just leaves you to edit raw HTML.

There's 3 tools that you can use independently that read a common data source of files with some --- metadata up top and a small number of VARIABLES that get substituted in. Each tool is self-contained in a single .lua file and so easy to mix and match. For example, my site has two distinct blogs (main site and devlog). I run the first tool once and the others twice each.

I can't quite cut my site over to this, though. Open questions I ran into with my site:

• How to style the pagination links. Those bits of html are hard-coded in the generator.
• Some of my older blog posts have no titles. Then I want to show the date in the <title> tag, but show no title in the <body> (because I already show the date and it would be redundant). It's unclear how to do that without a whole templating language.

I'm sure there are others. SSGs seem to be one of those things that everyone a unique-snowflake version of. But check it out if you're willing to leave Markdown behind. Using HTML is more accessible than Markdown. For example, it lets you distinguish a couple of key categories of <code> : keyboard shortcuts with <kbd> , references to names in other snippets with <var> and computer output with <samp> . Markdown's backticks can't do that. It doesn't matter if you never share your posts, and it's natural to not want to look at HTML given how monstrous it can get. But HTML also has a lovely core that a lot of civilizational effort went into, and it's sad that layers above don't use all of it. A little more manual labor can provide a nicer reading experience for others.

Thinking Together

💭 Paul Tarvydas

🧵 conversation

Trolling for ideas on which way I should go. I have too many choices in front of me and way too many learning curve(s) to go down. I've got a drawware REPL that uses 3 windows: (1) draw.io, (2) browser that displays output of run, (3) python glue running in a terminal window that watches the timestamp on the draw.io file, and spawns a compile/run cycle when the drawing changes. The python glue creates 2 websockets (1) a 1-way conduit to the browser to send it JSON key/value objects (strings) and (2) a 1-way conduit from the spawned compiler which sends key/value messages which get forwarded to the browser. The effect is like printfs but in a browser instead of a console (and more useful than printf because it doesn't need to be sequentially inserted into the circuit). It knows how to shell-out to command-line commands. This is a VSH - a Visual SHell to replace /bin/bash. The whole mess works "fast enough" to act as a code development REPL. What's the best way to package the whole thing into a singly-deployable app? (single from users' perspective, maybe retain all processes and windows). Should I dump the browser and go with some local GUI package (what?). Should I be looking at redbean? Should I be looking at Glamorous Toolkit? CLOG? Keeping the browsers and sockets makes it scalable across distributed machines and might result in new ideas. I want to keep draw.io, since it saves me a lot of work (it's a PITA to use, but better than anything I could build myself). Keeping Python and JS lets me forego actual coding (I just ask AI to build the thingies - AI has been trained on zillions of lines of code in JS and Python). I'm good with Common Lisp, Python and JS (but, hand-written JS usually creates mysterious failures that are hard to debug. Lispworks debugger is the "best", next is Python). I'm good with cranking out little nano-DSLs using OhmJS (t2t), so I can generate code instead of writing tricky code.

This is VSH, using websockets instead of UNIX pipes. Using 2D node-and-arrow drawings instead of 1D text on the command line shell syntax.

💬 Oleksandr Kryvonos

🧵 conversation

What if we use GPU / NPU / TPU to run Prolog several magnitudes faster?

Using technique of encoding words into numbers as LLM does?

Content

🎥 Surface-Stable Fractal Dithering Explained via Mattia Fregola

🧵 conversation

Worth watching even just because of this :D

💡 The Power of Creative Coding via Xavier Lambein

🧵 conversation

Great talk at FOSDEM about LOGO, Smalltalk and Scratch

🤔 The Future of Programming with Jonathan Edwards | Philomatics Podcast #1 via Steve Dekorte

🧵 conversation

🎥 Deep Dive into LLMs like ChatGPT via Oleksandr Kryvonos

🧵 conversation

Demystyfication of LLMs (at least for me)

📝 Toward Convivial Computing via Konrad Hinsen

🧵 conversation

Toward Convivial Computing by Terry Winograd (1979). I was intrigued by the term "convivial", but it turns out not to be a reference to Illich's work at all. It's about what we call "explainable AI" today, except that it's about first-generation AI, meaning expert systems etc.

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

📝 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

🎙️ FoC #74 • Is the Whole Universe a Computer™? 🎥 Fibonacci sequence in visual editor 🧬 undulant interface for genetic music manipulation

Two Minute Week

💬 Tom Larkworthy

🧵 conversation

My first attempt at putting all the pieces together to create a self-editable, zero toolchain, offline-first webpage with good debugger support. My CSS is quite weak so I need some more time to make it responsive and look cool, but the general idea is visible.

🎥 moldable website

Our Work

🐸 todepond.com/code via Lu Wilson

🧵 conversation

I'm really pleased to finally share my first-ever published paper (at last!)

This is...

DIALOGUES ON NATURAL CODE

by me and Dave Ackley

Please enjoy!!!!!

🐦 Hey Gadget, build me a CRM via Harry Brundage

🧵 conversation

my team and i have a little bit heretical take on the future of coding, which is that all the accidental complexity for building so much useful stuff comes from systems integration these days, not the programming language or environment so much. we've been hard at work on a systems-integrated development platform, and are now just launching our take on AI, starting with full app-at-a-time app generation. it takes advantage of all the systems integration we've done to produce apps that have real, working frontends, backends, data storage, auth, caching, apis, etc, and does it the hard way such that you can fully fiddle with all the code and make just about anything. curious what you all think! here's the preview and link: Hey Gadget, build me a CRM , DM me if you want early access i will let all you smart folks in!

🎥 Fibonacci sequence in visual editor via Peter Saxton

🧵 conversation

It's taken a while but after some conversations I had about making a structural editor that wasn't all keyboard shortcuts I finally have something to share.

I keep calling this a visual ui but that's probably not accurate as all the editors where visual.

It's a point and click discoverable ui for the structural editor. And here I walk through using it to build a Fibonacci sequence

🎙️ FoC Episode 74 • Is the Whole Universe a Computer™? via Ivan Reese

🧵 conversation

It's been so long since we released the last FoC episode that it disappeared behind Slack's horizon. Well, happy new year, here's an episode we recorded back in September!! It's been kinda nuts for the past few months, so sorry for the radio silence.

FoC Episode 74 • Is the Whole Universe a Computer™?

Jack Copeland, Mark Sprevak, and Oron Shagrir ask this question in chapter 41 of their book, The Turing Guide. They split this question in two, first asking whether the universe itself is a computer, then whether the universe could even be computed. These are lofty, unanswerable questions, sure, but they encroach on our territory — philosophy, automata, nonsense. So, in our usual reverent style and with attentive pacing, the three of us explore the paper, the questions, the answers they choose to highlight, and even share a few perfectly reasonable answers of our own.

Devlog Together

💬 Kartik Agaram

🧵 conversation

Beginnings of a tiling window manager. Still a bug as you can see. I need to come up with a clean way to constrain motion within an arbitrarily nested tree of windows.

🎥 motley wm

🪟 👋🏽 Hello Golden layout 2.6.0 via Tom Larkworthy

🧵 conversation

Somewhat inspired by Kartik Agaram I thought I would look at tiling managers / dockables for the web

📝 👋🏽 Hello Golden layout 2.6.0

Drag and drop window management. http://golden-layout.com/ This example persists to local storage! Golden Layout supports persisting the layout, but the draw-back is the componentState has to be serialisable, you cannot just pass nodes through, instead you need to look them up. It might make sense to exploit views to push or pull state in and out of components Saving state to local-storage.

💬 Tom Larkworthy

🧵 conversation

Yeah being able to reactively live edit dependancies is quite useful for fixing imported CSS. Good progress on the CSS, starting to look cool, starting to be usable.

🎥 My Movie

💬 Paul Tarvydas

🧵 conversation

Fooling around with visual animation as a way to describe algorithms (instead of strict linearization and time-flattening of written code). Inspired by Kartik Agaram's comments and this 💬 #thinking-together@2025-01-02. I'm not sure where this is going, but, I'm looking at the Wick editor, Apple Keynote, etc.

[January 2nd, 2025 6:57 AM] burningion: on a similar note, I'd like to have animations on diagrams of ideas for a blog post I'm working on. what sorts of tools or libraries should I be using to make this easier?

I'd like to add a button to send a message, and animate how it flows from the encoder to the decoder

Thinking Together

📝 Towards Diagram Compilation via Paul Tarvydas

🧵 conversation

I'm thinking about compiling this diagram to code. I don't know if this thought experiment should be posted to thinking-together or devlog-together.

💬 KP Kaiser

🧵 conversation

on a similar note, I'd like to have animations on diagrams of ideas for a blog post I'm working on. what sorts of tools or libraries should I be using to make this easier?

I'd like to add a button to send a message, and animate how it flows from the encoder to the decoder

💬 Daniel Harris

🧵 conversation

"Our tech is shaped by our need to make money". Apps and services are discrete items because they need to be packaged for sale or hire. These are my New Year musings. I'm curious if anyone else has thought about what influence our need to make money has made on the shape of our tech. App stores definitely promote the idea of discrete units that can be sold/hired because they make a cut of the transaction. I'm sure there's also an I made this factor playing out. I guess I'm wondering what if collaboration was the pervasive modus operandi? What would our tech look like then? What if we didn't need to package apps up as discrete branded units? What would the tech world look like? How would we build functionality? What if we never needed to earn anything from software? How much better could it be? What restrictions do we place on apps because we need to make money from them? And how much better would they be if we didn't need to do that? Purely from a technology angle. Even though there are loads of non-profit open source projects creating tech we are still stuck in the more pervasive paradigm of packaged units of code. How much better could we be? Of course, this is a pretty simplistic view of the world but anyone ever thought about this stuff?

Content

🧬 synopsis-04: lobe ui via Christopher Shank

🧵 conversation

lobe ui: an undulant interface for genetic music manipulation system (2000)

Present Company

🃏 this thing via Ivan Reese

🧵 conversation

Sharing this thing @andrew blinn is working on because it's delightful.

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

🕶️ Visualizer: Own Cell Renderer 📚 Advent of Papers (2024) 🌳 Tree Calculus

Our Work

🎨 Splash is a colour format via Lu Wilson

🧵 conversation

i made an explainable for a weird colour format i use

Splash

todepond.com/lab/splash

💻 all pairs via misha

🧵 conversation

I made a thing! akovantsev.github.io/corpus/pairs-campaign

🎙️ FUTURE OF CODING: INTERVIEW via Lu Wilson

🧵 conversation

Bonus episode alert!

FUTURE OF CODING: INTERVIEW

(featuring @Philippa Markovics)

This is the first FUTURE OF CODING interview since January 2022.

It's an experimental pilot so it's for patrons only this time. Thank you to everyone who supports the podcast and I hope you enjoy this behind-the-scenes look!

I tried out various different editing techniques to give them a whirrrrrrr before the Real Interviews. Let me know what you think!!!!!

I really enjoyed Steve Krouse's wholesome interviews back in the day so I hope I can do them justice with a 2024/2025 version. I promise this first one is (at the very least) not boring. Any other qualities are up to you to determine.

Of course, many thanks to Philippa for helping me out and being my first victim (and we'll maybe see her again soon).

Devlog Together

💬 Jimmy Miller

🧵 conversation

Finally getting to work on beagle again. I was able to get some Cffi working. So here you see a simple sdl application and a socket server on a background thread. I made a quick vs code extension that sends the contents of a buffer to this socket and the code evals. Now I have a quick and simple live coding setup. Here I just invoke a function, but you can redefine functions as well. I need to work on live redefinition of structs and all sorts of bugs and edge cases. But it's pretty exciting to see some real stuff working!

💬 Roma Komarov

🧵 conversation

Working on a native CSS mixin that would allow to easily debug any other custom properties in CSS by outputting their value into ::after pseudo-element. It is sometimes frustrating doing various complex calculations in CSS while not seeing the result itself (without applying it to something), and without looking into devtools (which is nice, but can be slow). So, being able to just output some CSS variable, calculation, viewport, or container unit for any element just by assigning a single CSS variable will be very useful.

(the code for achieving this is overcomplicated — but 100% fine for debugging purposes; I'll try to write an article about it in the next few weeks)

🎥 Screen Recording

🕶️ Visualizer: Own Cell Renderer via Tom Larkworthy

🧵 conversation

got the notebook cell visualizer finished. Its the final part MVP part for an userspace Observable-like experience off the platform, but I still need to actually put all the pieces together so its not hugely interesting yet observablehq.com/@tomlarkworthy/visualizer.

💻 just stage every change in git repo via Oleksandr Kryvonos

🧵 conversation

so previously I created a small tool that creates commits on every file change

and though it was very fun in the beginning it turned out to be a trouble to remember what I actually did

so now I downgraded it to just "create a new feature branch if I make some changed on main branch and stage everything"

github.com/uprun/git-auto-commit

🐘 Emacs via Kartik Agaram

🧵 conversation

After a conversation with Jack Rusher and others about Emacs Nature, and playing with Seymour by @Alessandro Warth, I'm getting interested in building..

An environment for visualizing programs

(Not to be confused with visual programs, or visualization more generally.)

• Start with a tiling window manager for managing named graphical canvas "buffers", using Emacs operations like split and resize.
• Each buffer exposes a coordinate space of its choosing, listens for messages and positions objects in the space in response to messages.
• Buffers can send messages to other buffers.

Examples, etc. in 🧵

Reading Together

📚 Advent of Papers (2024) via Jimmy Miller

🧵 conversation

Maybe I should have posted this here at the beginning. But I did an advent of papers. All of them are papers we haven't done on Future of Coding. And most of them will probably never be papers we do

Thinking Together

💬 Iacob Nasca

🧵 conversation

does anyone work on making a programming language ? and if so, can you share a repo or some notes ? I'm curious what features are you implementing and what programming language are you using do develop it and how you do the codegen part. I'm currently struggling quite a bit with LLVM

Content

🌳 Tree Calculus via Mariano Guerra

🧵 conversation

Tree calculus is minimal, modular, Turing-complete, reflective

anyone has any opinions on this?

One operator. Trivial semantics. Turing complete. Intensional.

✍️ Drakon via Kartik Agaram

🧵 conversation

Drakon is a visual programming language. I haven't dug into the modern editor implementation yet; the language description pdf is lovely just as an opinionated guide to drawing clear visual descriptions of programs.

📝 alt.chi via Andrew McNutt

🧵 conversation

Kind of a weird link, but:

There’s a paper under review at alt chi right now called “Eden OS: A Call for a New Concept and Metaphor for Operating Systems for PCs”. This feels within the remit of this community and looks pretty interesting. Alt chi does an interesting thing where anyone can review any paper, all you need to do is volunteer to review for it on PCS (some instructions avail here). So, if this seems interesting to you, you can read it now or review if you want

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

🛡️ Unusual programming environment for counting 🎥 Incremental Graph Code 🏹 tldraw computer

Our Work

🛡️ Droste's Lair is an unusual programming environment for building and counting mathematical structures via Elliot

🧵 conversation

Joshua Horowitz and I invite you to explore our experimental visual programming environment (which takes place in a dungeon)

Features

• dissolve the bounds of decision and explore all possibilities at once

• use sigillic incantations, delve into recursive caverns

🎥 Incremental Graph Code (IGC) Introduction via Thomas van Binsbergen

🧵 conversation

This video demos a prototype that Max Boksem and I built to investigate a modular graph structure for representing and running source code . The tool allows you to create different projections out of the code such as code structure, documentation view, and execution history. The tool supports incremental and exploratory programming (multiple execution sessions) and "nested graphs" (importing a graph as a node) for hierarchical views. The work was presented at Splash earlier. See the paper here. Konrad Hinsen, this is the video I promised you a while ago.

Devlog Together

💬 Tom Larkworthy

🧵 conversation

There were some tricky problems to solve to get to this. Still glitching and a WIP, but finally piece number 3 is beginning to come together, a userspace notebook renderer inside a notebook, that works with the existing observable notebook cells, but whose layout state can be drastically different, and yet still persisted via single file export. All the pieces are reactively editable insider the notebook. The notebook state is the editor. There is no distinction between the development UI and the executing program, and its a single 1.2MB HTML file that works offline.

🎥 lopebook

Thinking Together

💬 Alex North

🧵 conversation

Does anyone know of any DSLs or similar that are specific to graph/chart drawing? I.e. a language that defines a function from data to image, specialised toward visualising data?

If not, what’s the closest thing? E.g. is there a JS chart-drawing library with an API that feels close to a DSL?

💬 Jason Morris

🧵 conversation

I have been working with large-ish knowledge graphs on and off over the course of the year, and I keep running into the same problem... my intuition for what I have done when I modify the graph and how it will effect everything else is just dismally bad. I make what seems like will be an incremental change, and it doesn't do what I expected, or if it does, it breaks all my algorithms. This happens with other data structures, too, obviously. But with graph data it happens far more often, as in nearly always, and the time between "it isn't working" and "oh, I know how I broke it" is much longer. So I'm wondering, assuming that my experience is not unique, is there something about graphs that makes them harder to grok? The absence of a clear serialization, the absence of order, complexity of structure? Or is it a UI problem, and if I could just see what I was doing it wouldn't be so bad... Often, when I come to a particularly hard problem, I sample and visualize the graph, and learn that the previous three problems were not correctly solved. So visualization helps, but is that enough? Or is there something fundamentally inhuman about large, dense graphs?

Content

🏹 tldraw computer via Maikel van de Lisdonk

🧵 conversation

computer.tldraw.com ... I think it's awesome! And I am a bit jealous but in a good way 😄 .. very inspirational and I think this is what the chatgpt canvas should have been

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

📺 Variable design 📢 FoC Virtual Meetup 2025.1 📝 Problems people are motivated by

Our Work

🧮 Pictures of Pensions – Calc with Dec via Declan

🧵 conversation

I made a 'narrative visualization' blog post that's about pension savings. Like other places I use calculang it combines reactive programming/visualization (OJS and Vega) and calculang models (a pension calculator, which is using a separate income tax model for a tax relief calc- an example of model composition)

FP nature of calculang and no state and FRP nature of the rest makes it kinda easy to put together - Some viz signals and some calculang parameters condition on progress which increments as the user scrolls (the reactive systems do the rest).

I'd like to bring a few tools together to streamline DX for this kind of output for calculang models - it could be even more declarative. (+see Fidyll)

Happy to hear any feedback or suggestions.

🎥 Live Coding an Interactive Tool with Val Town & AI via Mariano Guerra

🧵 conversation

Live Coding Interactive Tools with Val Town & LLMs

Quickly prototype interactive data components without the need for local installation or setup

First FoC tool collab? 🙂

🖩 Mortgage Calculator via edward

🧵 conversation

I wrote a Mortgage calculator web app, suitable for use with Mobile devices, using my Super Duper Pythonic language. It makes it easy to build rubbery user interfaces that adapt to the device size by specifying things using proportions when possible. Keeps things legible without fussing over measurements. App is at voicecarrier.com/lab/calc/calc.html, source code is at screenshot of calculator

I couldn't stand how complex the web is to build for, especially when you want to make things legible.

The key strategy for simplification is to make the layout and rendering part of the language, and having all subdivision of the screen be executable statements that can be put into loops and conditional clauses, making the entire page layout programmatic as opposed to static, which is the great flaw of HTML.

Devlog Together

📝 RT - Now What? Towards Higher Level Syntax for Programming Languages via Paul Tarvydas

🧵 conversation

I've implemented a rough-in of a VHLL (Very High Level Language) and used it to write a non-trivial program (a mutual multi-tasking kernel that does message passing, about 1,400 LOC). It generates Python, Common Lisp and Javascript (node.js) code, essentially using existing languages as assemblers. This uses a variety of techniques, including a DPL (diagrammatic programming language), t2t (text-to-text transpilation) and a jury-rigged REPL programming language workbench. Several mundane gotchas were wrestled down. Now, I'm wondering what direction to take this next. My thought is that this needs to run in a browser (Javascript, WASM?), but that exceeds my limited knowledge and will require going down new learning curves. Maybe I'm thinking too much inside-the-box? Comments (and help) appreciated. FWIW more detail: RT - Now What? which further references RT Transpiler

💬 Tom Larkworthy

🧵 conversation

Miniscule progress on an alternative notebook renderer that hacks the observable runtime to capture all the values. Behold, "foo" is rendered in two places! One of those places is a giant cells containing every other cell in the notebook.... that is what visualizer will be. A cell that renders the whole. So then the outer HTML frame will not actually provide any DOM nodes for the runtime to render into externally, the engine will start and visualizer will dynamically create DOM nodes to render the rest from the inside. An inversion, much more hackable that way.

🎥 synced cells

📝 Building A DSL - Example DSL That Generates Python Code via Paul Tarvydas

🧵 conversation

Incremental progress documenting writing of a DSL and generating code from it. A quick overview video...

Thinking Together

📝 Problems people are motivated by via Kartik Agaram

🧵 conversation

I still think about this every once in a while.

🎥 Marcin Ignac, Variable.io - Variable design /KIKK24 via Jack Rusher

🧵 conversation

If you liked the above project, you might also enjoy Marcin Ignac’s talk from KIKK 2024, which features more of his studio’s work and some additional insights into their in-house visual programming environment.

🤖

💬 Tom Larkworthy

🧵 conversation

we just got Devin, pretty slick slack based workflow. Still teaching it we use python 3.10 but it seems like its quite useful for dependabot alerts. I am seeing if it can do a decent refactor or not.

Present Company

📢 Virtual Meetup 2025.1 via Maikel van de Lisdonk

🧵 conversation

Hi, on wednesday 22th jan 2025 (16:00 UTC) we will have our first online meetup of 2025 and we will continue in the same format with short live demo's and presentations from our community .. the meetup is also on Virtual Meetup 2025.1 .. if anyone wants to give a demo about their project or give a short talk then please let us know here in the thread of this message 😀

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