🎥 Multiplayer Live Coding 📝 Why frameworks are evil 🔤 Typography meets scifi

Our Work

🎥 pastagang @ Noughty Fingers Second Date via Lu Wilson

🧵 conversation

here's a 45 minute slot of many people editing the same code document at the same time to make music and visuals. four people are there in person, many more are remote - connecting in from around the world. it's all made LIVE, from scratch - during the slot.

i am still shocked that the LIVE programming world is largely oblivious to this sort of thing

📝 Programming In The Age Of Abundance via Guyren Howe

🧵 conversation

This may be of interest

💬 Konrad Hinsen

🧵 conversation

A world of rapid change that is almost entirely driven by and enabled by software is not one in which programmers will be idle.

I'd have said "yes" to that conclusion even without reading the arguments before it.

I am less convinced about some of your more detailed predictions, because many of them depend on changes in incentives (whether by markets, regulators, or something else), which are hard to predict.

Thinking Together

💬 Marek Rogalski

🧵 conversation

I've spent a considerable amount of time now figuring out in which "direction" do memory addresses mentally increase. I'm trying to pick a convention for presenting memory in Automat that would make it easier to mentally picture what's happening. No direction is perfect and each one involves some friction when mentally manipulating order of things.

The established conventions that I know of are:

• Text goes right and down (when lines wrap). Text direction may be pretty much arbitrary when different scripts are involved.
• Bits increase towards left (because << shifts bits up) and then up (because of "higher" bytes). Computer science courses teach that "stacks grow down".
• Numbers increase towards left (more significant digits go towards left) but for a typical (little-endian) CPU more significant bytes are written towards right.
• Points on a cartesian system tend to increase first towards right and up.
• In nature things usually grow up.

📝 Library patterns: Why frameworks are evil via xyzzy

🧵 conversation

A good comparison can be Qt vs Skia.

I agree with most claims of this essay. However, having used many frameworks and after having analyzed why they work well, it boils down to.

• Good documentation
• Multiplatform abstraction behind a standard interface
• Combine many calls into a simple end point (button->draw in Qt vs drawing a button via Skia)

If these are addressed by libraries, then libraries with simple callbacks are much more preferrable to frameworks.

One problem which frameworks and libraries don't address or hide away is state machines.

An app is fundamentally event loop + state machine.

Any framework that you use long enough, you will want to peek into how it is actually handling events and customize it.

Content

🐦 Aurelien (@Aurelien_Gz) on X via Steve Dekorte

🧵 conversation

🐦 Aurelien (@Aurelien_Gz) on X: omg.. this is next level..

typography meets scifi.. schultzschultz's tools feel like they’re from the future

📝 Feral Cogitation | David West | Substack via Erik Stel

🧵 conversation

A number of interesting reads from a friend and former colleague/partner of mine:

📝 Feral Cogitation | David West | Substack

Professor Dave West talks about business software development, software, engineering, cognitive science, AI, Mysticism, education, and much more. Click to read Feral Cogitation, by David West, a Substack publication. Launched 2 months ago.

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

🎥 This Game Did Everything. What Happened? 📝 Self-Steering Language Models Ω OhmJS: A JavaScript library for building parsers, interpreters, compilers, and more

Devlog Together

🎠 A markup language and hypertext browser in 600 lines of code via Kartik Agaram

🧵 conversation

I've integrated my recent 💬 #share-your-work@2025-04-05 into my template repository for building apps based on the Lua Carousel UI which supports making changes to apps on the phone (or computer). Now any new app built from this starting point will have a rudimentary system of online help for the entire stack:

• Lua Carousel
• LÖVE
• Lua programming language syntax

And there's tooling for authors to draw box-and-arrow diagrams in the environment and hyperlink boxes to code in the app.

It's all very janky, but the combination of editing on the phone, box-and-arrow diagrams and hyperlinks everywhere seems to result in a somewhat unique programming environment worth exploring further. I'm not sure what I'll do next. Probably build some simple apps and try to build experiences for understanding their source code. This is a little bit like Literate Programming, but just a touch more graphical. LP + image maps, perhaps.

🚪 Jumpgate: Bulk transfer notebooks between storage mediums. via Tom Larkworthy

🧵 conversation

I am back on the original goal of exporting my Observable notebooks to my offline-first format (lopecode), in a way that preserves editability. I started a notebook called jumpgate, that can do the conversion, and then opens a PR against Github. The first notebook I am trying to get this working with is Jumpgate itself.

I use lightning-fs + isomorphic-git to do the Github part within a browser. The prototype is working

sourcecode on Observable: observablehq.com/@tomlarkworthy/jumpgate

git PR opened by the notebook: github.com/tomlarkworthy/lopecode/pull/4

as my repo is configured as a static host as well, we can see the result of jumpgate after going through the jumpgate here: tomlarkworthy.github.io/lopecode/notebooks/@tomlarkworthy_jumpgate.html#view=S100%28%40tomlarkworthy%2Fmodule-selection%29

Currently its slow as hell as the git checkout takes a long time. lightning-fs is storing itself in indexdb so there is not need to do a full checkout everytime, we should be able to merge with what exists. I went with simplicity for now as the stateful logic gets complicated as you have to do different git commands depending on whether you have done an initial clone etc.

I am not sure how to manage the PR branch either, I keep force pushing a single branch but thats probably not correct either, I should use a fresh one each time but then you need to be careful not to fill indexdb with orphaned work. If anyone has a strong opinion on what the ideal github workflow for syncing offline files is LMK

The jumpgate does not add the extra functionality to make a notebook editable, I need to next mixin with my editor notebooks to get the thing to do what I want. Good stage though, Having notebooks open PRs is cool.

🌝 f-string.lua – ezhik.jp via Ezhik

🧵 conversation

Keep getting sidetracked by making little Lua libraries. This one implements Python-style f-strings in Lua. Pretty cool to have a language that lets you go this far with its syntax. With just a little bit of work this could be extended to implement Python's template strings (PEP 750) and then we could use Lua to make all sorts of DSLs. My initial motivation was easier printf debugging, though 😅.

I started working on this on an iPad with the Codea app, of all things. Was fun, but sadly I couldn't use any of the Bret Victor-inspired things they had in it since I wasn't using any of the app-specific libraries they had.

Though putting aside the library, I think at this point the most interesting thing I did is actually making it possible to use it right on my website without having to install or download anything.

Ω OhmJS: A JavaScript library for building parsers, interpreters, compilers, and more via Paul Tarvydas

🧵 conversation

If you enjoyed fooling with parsers, I would recommend looking into OhmJS. OhmJS (plus Ohm-editor) saves a lot of work when building parsers. A game changer. There is the other half, too - once you've parsed something, what do you do with the information? I've found that doing simple string-rewriting is very, very powerful, while sounding overly-restrictive on the surface. One can design and build whole new languages by transpiling them into existing languages for compilation (that's how I use my 't2t' and 'tmx' stuff). I consider the shell (/bin/bash, /bin/zsh, etc.) to be my IDE. PLs are just "little tools" that plug into the IDE. I don't have to stick to using one language. I can pick and choose. Transpiling a new language (or nano-DSL, or Diagrammatic Programming Language) into some other language fits neatly into this workflow. The fact that OhmJS is written in JS doesn't mean that you have to use JS. You can map XYZ to Lua (or whatever). I can supply a /lot/ more info, if this interests you.

Content

💬 Walker Griggs

🧵 conversation

Meta information diet thread: What are blogs / publications that you read frequently?

🎥 This Game Did Everything. What Happened? via Mariano Guerra

🧵 conversation

This Game Did Everything. What Happened?

Dreams is a 2020 game creation system video game developed by Media Molecule for the PlayStation 4. Players can create and play user-generated content in the forms of games, audiovisual experiences and game assets, which can be shared or remixed to be used in other players' creations.

🤖

💬 Arvind Thyagarajan

🧵 conversation

Has anyone played extensively with the swathe of "speak english into code" systems out there, from idea through to deployment to an appreciative public? (I haven't...)

I'm wondering if, at the end of the day, you still have to be somewhat of a textual code / software engineering native in order to take advantage of this particular present-future of coding? Or if it's truly democratising access to practical computation (i.e. domain specific to the domain of semi-commercial tools, apps, integrations that software engineers work on)

I feel a lot of public excitement around it that I'm not feeling -- but as someone keen on encouraging everyone to act computationally for themselves, public excitement is * the metric so I'll admit to being mildly envious 🙂

📝 Self-Steering Language Models via Jack Rusher

🧵 conversation

For anyone working with LLMs (from my colleagues at the lab where I’ve been helping out the last few months):

📝 Self-Steering Language Models

While test-time reasoning enables language models to tackle complex tasks, searching or planning in natural language can be slow, costly, and error-prone. But even when LMs struggle to emulate the precise reasoning steps needed to solve a problem, they often excel at describing its abstract structure--both how to verify solutions and how to search for them. This paper introduces DisCIPL, a method for "self-steering" LMs where a Planner model generates a task-specific inference program that is executed by a population of Follower models. Our approach equips LMs with the ability to write recursive search procedures that guide LM inference, enabling new forms of verifiable and efficient reasoning. When instantiated with a small Follower (e.g., Llama-3.2-1B), DisCIPL matches (and sometimes outperforms) much larger models, including GPT-4o and o1, on challenging constrained generation tasks. In decoupling planning from execution, our work opens up a design space of highly-parallelized Monte Carlo inference strategies that outperform standard best-of-N sampling, require no finetuning, and can be implemented automatically by existing LMs.

💬 Ezhik

🧵 conversation

I wanted to learn how the CodeMirror editor works, so I asked GitHub Copilot's agent mode to build a little app that uses it for me. We had a back-and-forth where I pointed out the bugs I've seen in the UI and then it fixed it. But all this took place without me having to look at the actual code, so I don't really feel like I learned anything from this experience. That makes me wonder - do people here use these tools for learning, and if so, how?

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

📑 Survey of compilation, recompilation & compile-time evaluation 🪟 Interactive Layout Design with Integer Programming

Our Work

🎨 Helper to select an accessible color relative to a base (background) color via Kartik Agaram

🧵 conversation

I spent some time rethinking how color is represented in my browser. I want to prioritize accessibility over expression, so I switched to ~500 colors over a perceptually uniform color space. The idea is that you specify background colors completely, but if you leave wiggle room in the foreground colors the browser will search the wiggle room and try to maintain some minimum contrast level. Here's a test run where I randomize the background on every "page load", but the foreground colors are specified the same way: text is on a greyscale, and links are blue.

I used to think the CSS hotness of the Oklab space is rocket science. I still don't understand the why of it, but it turns out to only take 200 lines of code to implement.

🎥 luaML2-contrast

Devlog Together

💬 Tom Larkworthy

🧵 conversation

I padded my work trip to Portugal with some extra days off so I could concentrate for 2 days and do a V2 of the editor component. A great success! I switched to floaty window style near the cell, attached it to the correct DOM so it follows the scrolling properly. Got add/remove cells properly working again since the multi-module refactor broke them. Managed to remove several reactivity bugs. Removed some hacks that were working around said bugs. Fixed some low level bugs in the visualizer, causing a few other unexpected bugs to fix themselves coz of that problem.

🎥 add delete cells

Thinking Together

💬 Felix Kohlgrüber

🧵 conversation

Hi!

it's been a long time since I posted in this group (almost 5 years, wow!). Life changed on my side (working full-time jobs, having kids, ...) but I still tried to follow what's going on occasionally. Thanks a lot to Mariano Guerra for the newsletter, it's the perfect digest for me to read whenever I have some spare time.

I've recently started using Obsidian and it's working great for me to collect and organize all kinds of thoughts. I've used quite a few tools for this over the years, but Obsidian is my new favorite. I'm sure it's been discussed here already, but here's what I love about it:

• based on markdown files instead of some proprietary formats
• great apps for desktop and mobile
• effortless e2e-encrypted sync between devices
• linking between files / pages and following those links is easy. I'm using a variation of a Zettelkasten (this link can be useful as a starting point; I can write about my approach if there's interest in it)

I'm currently trying to collect my FoC ideas, projects and thoughts into my Obsidian and therefore wanted to see my contributions to this community. I used the Archive tool by Kartik Agaram and it's been working great. A simple long webpage and Ctrl-F worked beautifully, probably better than what Slack Pro could have given me. Thanks a lot for creating the archive, Kartik!

Going back in time was very interesting. One thing I noticed though was that quite a few links that we discussed at the time sadly don't work anymore. With the help of the wayback machine, I was able to still access all the info though. This made me once again appreciate the wayback machine and its importance for the internet. Feels like a donation to the project is overdue.

That's all I wanted to share. Have a great day folks :)

💬 Kartik Agaram

🧵 conversation

I've been thinking about color, and I don't know anything about it.

I'd really like my hypertext browser to allow people to adjust color, but without ever compromising contrast. Is there some color space/model like rgb/hsl/CIELAB/Lch that allows you to adjust an author foreground color relative to an author background color, yielding new reader foreground and background colors that maintain the original level of contrast? Ideally I want a single spectrum/dimension/knob that I can adjust to change the hues of one element (say the background color), automatically adjusting the colors of other elements around it.

For example, say the background color is white. I reflect it to get a text color of black. Then I get 3 other foreground colors that are rotated by 120 degrees along the color wheel. Now I could adjust the hue to rotate around the color wheel. Or I could reflect to get dark mode. But is there a way that supports both without going all the way to a 2D color space? For example, if you set the background color to medium grey now no foreground color can give you the desired level of contrast. So I'd like to not even represent such a background color as an option.

💬 Karl Toby Rosenberg

🧵 conversation

I’ve been thinking about how languages taught at the intro level are usually taught with lots of white lies about how they work, out of necessity. For example, Python’s actual underlying memory model (how everything’s a reference and isn’t copied around) is confusing (arguably), so we avoid teaching that part and oftentimes make all these distinctions between references and primitives (even though everything’s an object). Teaching something more accurate (everything’s an object with references, and oh sometimes values are even referenced via referenced counting) would actually lead to confusion when trying to translate some of this in other languages like C, where everything’s actually a value (pointers are just ints purposed for addressing things).

Java is also confusing with all the GC stuff and opinions it has about memory and memory behavior.

I would like a first-learner’s language that has the arguably-more-consistent semantics of something like C (“everything’s a value”), but is closer to Python. So I can feel like I’m not “lying” so much. I think the closest thing is C itself, unfortunately, or C++ with a custom allocator thing.

Or maybe a hot-take: objective C / ARC are the closest.

But really I’d just like a Python with less obfuscation and inconsistency, so it looks more like C with safety on-top and better file imports.

Essentially, Python with proper value types for everything, even if a little more challenging. The most explainable language closest to hardware, but easier to use.

Just thinking out-loud. I think a Python 3 subset preprocessor that outputs raw C would look close to the language I have in-mind. (I’d like end for blocks too).

📑 A rough survey of compilation, recompilation, and compile-time evaluation via Jamie Brandon

🧵 conversation

I'm curious if anyone knows of languages that have different approaches to the ones I covered here.

Content

🪟 GRIDS: Interactive Layout Design with Integer Programming via Tom Larkworthy

🧵 conversation

Integer programming based layout engine for graphs

Since Maikel van de Lisdonk/ OCWG : Open Canvas Interchange Format I been thinking it might be possible to write a generic graph layout engine. I also been thinking that historically graph layout engines concentrate on the spatial constraints (including grids), but now we have LLM/embedding vectors it might be fruitful to integrate semantic similarity into the objective function so nodes representing similar things are near to each other as well.

Present Company

📢 Future of Coding meetup · Luma via Maikel van de Lisdonk

🧵 conversation

Our next meetup will be april the 30th at 18:00 UTC .. so, we're looking for 2 volunteers to do a demo/presentation (we already got 1 volunteer)! So who wants to share anything about their project?

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

🎥 Virtual Meetup 9 • March 26 ✍️ A programming language of flowing strands 🛸 HyperDoc demo

Two Minute Week

💬 Tom Larkworthy

🧵 conversation

I am back to bug hunting. Reactive live coding is great when it works but the bugs can be devilishly difficult. The best methodology I have is plotting all the transitions on a timeseries and zooming RIGHT IN. Its a technique I keep coming back to and it has fixed quite a few subtle issues. I used to think the dependancy graph would be useful but actually a lot of the reactivity bugs occur via hidden event coupling occurring outside the programming model, for example, mouse events, url events, local storage events. They can cause different cells to trigger each other but not through the normal notification mechanisms.

🎥 debugging reactive

Our Work

🛸 HyperDoc demo via Konrad Hinsen

🧵 conversation

My main recent FoC-related project is a framework for creating explorable, explainable, Web-publishable, composable, and convivial hypertext systems that integrate code. Combining aspects of explorable explanations, literate programming, and computational notebooks. The two principal intended use cases are (1) programs written for people to read, and only incidentally for machines to execute, and (2) scientific publications using computation.

A first demo is now available for browsing: hyperdoc.khinsen.net

This is what I will present at the upcoming meetup on Wednesday.

🖼️ Open Canvas Interchange Format (OCIF) via Maikel van de Lisdonk

🧵 conversation

Last FoC meetup I showed the Open Canvas Interchange Format we're working at with the Open Canvas Working Group. We want to create a new spec to help (infinite) canvas apps enable interchanging their canvases with each other. More info can be found here canvasprotocol.org and this points to the latest version of the spec on github : spec.canvasprotocol.org .. and in case you want to help developing this: we meet every two weeks and here's the link to our next meetup upcoming tuesday

📝 A markup language and hypertext browser in 600 lines of code. via Kartik Agaram

🧵 conversation

Devlog Together

🗒️ The first version of the new multi-notebook architecture via Tom Larkworthy

🧵 conversation

Just got Lopecode's plain text serialisation format deterministic so its now git diff friendly! The first version of the new multi-notebook architecture is public here from the lopecode repository. The code editing experience sucks and I lost a lot of functionality switching to dockered multi-notebook but it is so much better being able to work on two or more reactively linked notebooks at the same time it will be worth the backward step long term.

📏 Fit-to-Width Text: A New Technique via Roma Komarov

🧵 conversation

Working on a proposal for the algorithm of fit-to-width text for CSS. Planning to present it to CSSWG next week if all goes right :)

I already have a technique that handles a few main use cases (kizu.dev/fit-to-width), but if we want it to be native, we need to handle a bunch more: specifically, a case when a line of text has “static” elements that do not change their dimensions in response to the font-size change. This, with added handling of optical sizing of a font, requires us to basically render the same line box up to 4 times, but with 2 of those being optional (when no static elements, or no optical sizing axis present in the fonts used).

So mostly working on fine-tuning the algorithm + making a prototype of it with custom elements & shadow DOM (with no runtime JS for layout, only for duplicating the content to emulate multiple renders), and also thinking about what an API for this property could look like, with possible options, etc. And will need to also think how some other edge cases will need to be handled (reverse dependence on the font-size, initial-letter, and a bunch more).

🎥 Screen Recording

✍️ codeberg.org/nilesh/grapher via Nilesh Trivedi

🧵 conversation

Today I added Knotend-like keyboard shortcuts to my Graph editor app: codeberg.org/nilesh/grapher

Because this editor supports compound graphs where, besides adjacency edges, nodes can also be nested using at most 1 parent per node, I needed 4 separate actions on graphs for the currently selected node:

• Add a destination node (using the Tab key)
• Add a source node (using Shift+Tab )
• Add a child node (using ~ )
• Add a parent node (using Ctrl+~ )

I haven't yet added keyboard shortcuts for adding "sibling" nodes.

Also felt sad that we don't have standardized UI components with keyboard shortcuts for manipulating trees, DAGs, plain graphs, compound graphs or hypergraphs.

Thinking Together

🎥 How I Animated This Video via xyzzy

🧵 conversation

I can't take AI seriously.

Not my video but I have worked with ebsynth ... it is a completely analogue algorithm.

Style transfer without AI. It is built on old analogue aglorithm called patch match I believe.

Stylizing Video by Example

The future of code licensing is even stronger copyright protections for software authors / artists. AI has made a mockery of opensource and creative commons.

[Intellectual Property Stuff and Trademarks](https://blog.xyzzyapps.link/2025/03/08/intellectual-property-stuff-and-trademarks/)

📝 post via Paul Tarvydas

🧵 conversation

I have come to the conclusion that all PLs are VPLs. The first VPL I learned was assembler . Pond'ring aloud, thoughts welcome...

Background: Inspired by the 💬 #present-company@2025-03-24 by Duncan Cragg, I started to categorize VPLs. I think that I'm up to 9 simple variants. The main knobs that can be turned for PL design seem to be: (1) syntax affected by visualization technology, e.g. 1960s grids of non-overlapping pixmaps called "characters" vs. more modern raster graphics and vector graphics, (2) semantics of control-flow, e.g. 1960s sequentialism implied by line-by-line reading of code and blocking function calls vs. 1970s control-flow isolation like UNIX processes vs. more modern closures (effectively invented in the 1950s :-)). [FTR, assembler is position-based, using crude graphical grids of columns and rows, whereas C is not position-based, using simple eye-candy indentation for human (vs. machine) readability].

[March 24th, 2025 1:57 PM] fp: http://blog.interfacevision.com/design/design-visual-progarmming-languages-snapshots/

this one - is that it? [update: no, but it's a fun page!]

Content

📘 Reflections on writing a book via Patrick Dubroy

🧵 conversation

Hello! Thought some people here might be interested in my most recent blog post — Reflections on writing a book. It's about some of the things Mariano Guerra and I learned in over the 2.5 year it took us to write our book (💬 #share-your-work@2025-03-10)

✍️ Rivulet: a programming language of flowing strands via Kartik Agaram

🧵 conversation

I don't even.. just check this out.

🎞️ Pas a Pas via Tak Tran

🧵 conversation

Pas a Pas: A tangible interface for making stop motion animation

Present Company

💬 Ivan Reese

🧵 conversation

I did some vibe coding with Cursor and it got stuck in a loop of writing a buggy shell script, running it, looking at the output (unchanged because bugs), going "hmm let's fix that", then writing the exact same shell script.

💬 Andrew Beyer

🧵 conversation

I feel like I saw a really good literature review "state of the world" wrt visual/graphical programming a while back (probably here, though could have been elsewhere) but apparently didn't save the link and can't find it again...

So, anyone have any favorites or good pointers for something like that?

💅 Category:Design Aesthetics | Aesthetics Wiki | Fandom via Marek Rogalski

🧵 conversation

Here is a game:

• Go to aesthetics.fandom.com/wiki/Category:Design_Aesthetics
• Check out some of the design styles
• Come back here and post your favourite one that you wish were used more in FoC UIs

🎥 Virtual Meetup 9 • March 26, 2025 via Ivan Reese

🧵 conversation

Here's the recording of the Future of Coding Virtual Meetup 9. See you next month!

📋 13 things I would have told myself before building an autorouter via Tom Larkworthy

🧵 conversation

A dataviz driven development win.

"If you do not have a visualization for a problem, you will never solve it"

Also in spatial domain. Code + dataviz is my future of coding.

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

🥞 Linear Logic and Permutation Stacks 🎥 Malleable UIs using AI ✍️ Code Editing with Free-form AI-Interpreted Sketching

Two Minute Week

💬 Marek Rogalski

🧵 conversation

I'm getting feedback about the state of the game using basic OCR now. Unfortunately the OCR that I'm using is optimized towards "natural" text - so it doesn't handle game UIs too well.

🎥 OCR

Devlog Together

🧮 Spreadsheet #3 – ezhik.jp via Ezhik

🧵 conversation

Joining Kartik Agaram in the Lua club. I got Lua running in the browser (using wasmoon) and ported my spreadsheet experiments to it: ezhik.jp/spreadsheet-3

I think I'd like to experiment more with properties. I've already got the ability to change styling of cells, but what if we could go even further? Move cells around? Make them round? Make them spin? Make them not cells but images? I want to mess with the spreadsheet formula (pun intended) even further.

What if Spreadsheet #2 was Lua? You get Spreadsheet #3.

Thinking Together

💬 Denny Vrandečić

🧵 conversation

I found the holy grail: Vibe computing + Literate programming = ❤️‍🔥

Content

✍️🎥 CHI25 CodeShaping Video Presentation via Christopher Shank

🧵 conversation

"Code Shaping: Iterative Code Editing with Free-form AI-Interpreted Sketching" by Ryan Yen, Jian Zhao, & Daniel Vogel (2025)

1️⃣ Unit: Next Generation Visual Programming System via Fuzz

🧵 conversation

Unit is a General Purpose Visual Programming Language and Environment built with a primary focus on Developer Experience.

It is heavily inspired by Live, Data Flow, Reactive, Functional and Object Oriented Programming paradigms. Formally, units are Multi Input Multi Output (MIMO) Finite State Machines (FSM). A program in Unit is represented as a Graph.

🥞 Linear Logic and Permutation Stacks--The Forth Shall Be First via Paul Tarvydas

🧵 conversation

The real Achilles' heel for these languages, however, is their innate inability to deal with parallel or distributed computation.

Perhaps it is time to move on to the next theorem.

further: my thoughts and references

🤖

🎥 Malleable UIs using AI, from Haijun Xia's lab in UC San Diego via Kartik Agaram

🧵 conversation

Malleable UIs using AI, from Haijun Xia's lab in UC San Diego

Yining Cao's Jelly work referenced here doesn't seem to be on the lab's site, but this seems to be the paper.

🤖 crawlers by AI companies are not respecting robots.txt and so hostile to the open web via Kartik Agaram

🧵 conversation

It seems like a pretty big negative of AI that crawlers by AI companies are not respecting robots.txt and so hostile to the open web.

I've been hearing about this for years, and I've never understood it. Reading robots.txt is mature technology. I'm curious if anyone here has perspective on the technical/political aspects. (Goes without saying that it's not a good look.)

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

📢 Workshop on Live Programming (LIVE) 🐛 in-notebook debugger 📝 Zest: a language for malleable and legible systems

Our Work

📘 WebAssembly from the Ground Up - learn WASM by building a compiler via Mariano Guerra

🧵 conversation

After two and a half years of work with Patrick Dubroy, we are happy to announce the release of WebAssembly from the Ground Up, a book that teaches you about WebAssembly 1.0 by building a simple compiler in JavaScript with Ohm/JS.

Here’s a 25% discount code you can use: FOCWASM25

We decided to do a “digital first” book to take advantage of interactivity and “explorable explanations”, and learned a couple of things along the way.

We also decided that all the code should be in the book and that it should run if you copy and paste the snippets as you read.

To achieve this we had to create most of the tooling around the book ourselves:

• The server that handles authentication and access to the book
• The script that extracts the snippets from the original source code and generates:
  • The snippets you can copy to clipboard.
  • The “Copy up to here” code segments.
  • The checkpoints and chapter modules in the code repo, accessible through stackblitz.
  • The emit library, a standalone library to emit WebAssembly 1.0 binary modules.
• The early access feedback system using embedded hypothes.is
• PDF generation (puppeteer, pdftk, imagemagick, poppler).
• A tool to generate code snippet ranges for “highlight on text hover”.

We plan on writing about some of our takeaways in the coming weeks, but that will have to wait. 😅

Let us know if you have any questions!

🎥 Visualizing Models - Actuarial Playground via Declan

🧵 conversation

Hey all, I released ActuarialPlayground.com : an interactive and visual actuarial cashflow model, where the calculations are described by calculang.

There is a 7min video where I use the Playground to explore some things here

I made remarks about the calculang model and especially model composition, that you can read under the '❓' tab

calculang outputs a JS bundle you can see under '🌟' - obviously a lot can be done with it in a pretty familiar way

This is a contrast to calculations rigidly defined in specialised tools, without composition, and without being able to break out or integrate in a tight visual/interactive and exploratory loop

🦋 Do you want to know what was the secret to Flash websites? via Marek Rogalski

🧵 conversation

I've turned some notes related to Flash from the last FoC meetup in Berlin into a thread here:

@mrogalski.eu: Do you want to know what was the secret to Flash websites?

Instead of presupposing that "everything is a document" & "documents are a collection of boxes within other boxes" it went with "everything is a movie clip" & "movie clip is a collection of other movie clips" (Clips all the way down!) :thread::point_down:

Devlog Together

💬 Paul Tarvydas

🧵 conversation

In my very-biased view, this looks a lot like what I think of as "layering". I don't trust comments, so I want a way to make diagrams tightly bound to the code itself, i.e. generate code from diagrams (syntax == figures, not just characters). In my view, to get "layering" you need total isolation (encapsulation of data is not enough, you also need to guarantee that the control flow is isolated). To consider: the stuff inside of boxes is important, but, are (some of) the flows important, too? I.E. I see the arrow in the first diagram as a data flow and a "sequencing" thing - it kicks off the box to the right (the Main page) box needs to wait until it gets a signal to begin (I call that sequencing and timing). The 2nd drawing shows 6 boxes and no arrows. Does that mean that they can be viewed in any order, i.e. how are they different from "TABs" on the window? I think that I want a viewer/editor that gives me hierarchical TABs, or, clickable boxes. Double-click on a box and you get to view its innards. Make some other gesture and you go back. Does this mean that you need a "map" off to the edge of the window to show where in the hierarchy you are? The popular web browsers I've used flit really close to this flame, but, don't satisfy...

🐛 in-notebook debugger via Tom Larkworthy

🧵 conversation

I am in the fixing all the reactivity glitches before release stage. They are so difficult to debug, clicking a link opens a panel which syncs the hash URL, which retriggers another cell that get the stale version of the URL which may cause a cycle and the app starts flickering... or something like that.

I had to upgrade my in-notebook debugger to work across notebooks so I can visualize the evolution of the runtime state w.r.t. time. It worked! I figured it out. Pictured is the trace of a self-triggering reactivity loop. Its still hard to understand but you can see a lot of ticks with a regular pattern, and critically, the name of the cells. There were over 1000 cells in the notebook, so knowing the 15 that were implicated in the cycle is helpful.

📝 Zest is a (very wip) programming language for building systems that are both malleable and legible via Jamie Brandon

🧵 conversation

I wrote up some overall design direction for zest - github.com/jamii/zest/blob/main/docs/rationale.md.

Currently bogged down in figuring out how to combine staged compilation and modules (github.com/jamii/zest/issues/1), but once I figure that out I can finally start fleshing out the runtime.

Thinking Together

📝 How Did We Get Here? via Paul Tarvydas

🧵 conversation

I’ve come to believe that we’re missing out on approximately 90% of what’s possible because of how we program. It’s not just about the syntax, it goes much deeper - it’s rooted in culture, religion, dogmatism, and closed-mindedness. I think the word “function” has been overused, and the emphasis on efficiency has gone too far. Here are a few thoughts… YMMV. What do you think? How Did We Get Here? The Best Programming Language

💬 Paul Tarvydas

🧵 conversation

I’m curious about your thoughts on this idea: Glamorous Toolkit and Live Programming environments seem to essentially be REPLs that use modernized input and output technologies.

Back in the 1950s, REPLs used the best I/O and interface tech they had back then - mostly text-based command lines because computers couldn’t do much else. But now, environments like Glamorous Toolkit make output look better with graphics instead of just printing text, and Live Programming environments have GUIs with interactive stuff like sliders to change things while the program is running.

The only tricky part in designing modern REPLs seems to be figuring out how to keep things flexible while still working with strongly-typed, functional programming languages.

Do you think I’m oversimplifying these modern programming environments? Am I missing something important about how they differ from traditional REPLs?

🔍 zoomable hypertext via Orion Reed

🧵 conversation

I'm not really sold on ZUIs (zoomable user interfaces) but I became a bit more enticed once I realised that you could make ZUIs for graphs instead of trees. Where you can zoom into things and eventually get back to where you started... I feel like (aside from the potential motion sickness) it induces this visceral sense of how software and data topologies are governed by laws that we made up... And that, so long as we don't break any actual physical laws we are free to make up the semantic rules as we please...

Anyway, made this zoomable hypertext thing the other day to figure out how you would do infinite zoom in an infinite coordinate space that has this weird graph topology, where you can have A --inside-> B --inside-> A

Ended up with what I called a Shifting-Origin Graph which has a series of matrix transforms that can traverse through the graph with you, keeping floating point precision at bay and keeping memory usage fixed.

I would be curious to hear takes on ZUIs here, I feel like there's a more general view on them that would be more compelling to me, I got a glimpse of that as I made this experiment, realising that it would open up some interesting semantics that aren't really to do with ZUIs, and more to do with the ability to warp space in new ways.

🎥 Screen Recording

📏 Programming Language Sizes via Paul Tarvydas

🧵 conversation

Lua is 1,250x larger than Sector Lisp. Rust is 750,000x larger than Sector Lisp.

Are my numbers and data correct?

✊ The Data-First movement via Duncan Cragg

🧵 conversation

🤗

📝 The Data-First movement

We should talk.

💬 Arvind Thyagarajan

🧵 conversation

why ~is~ does it feel like the world of "what people and businesses are paying for today to lower the barrier to entry for computational needs" is an almost non-intersecting set with "what excites us about lowering the barrier to entry for computational needs"?

📢 Workshop on Live Programming (LIVE) via Jonathan Edwards

🧵 conversation

You should definitely submit a demo to the LIVE Programming Workshop this year! It is being held entirely online so no excuses. Submit by July 21

The 11th Workshop on Live Programming (LIVE 2025) will take place online. LIVE invites submissions of ideas for improving the immediacy, usability, and learnability of programming.

💬 Paul Tarvydas

🧵 conversation

Rhetorical question?: how would your programming workflow change if you deeply believed that creating SCNs was cheap and easy? Perl leaned heavily on REGEX. REGEX was once thought to be hoary and problematic. Perl made it accessible. New kinds of things were invented when Perl started being widely used. T2t is “better” than REGEX, because t2t makes it easy to deal with patterns containing recursive nesting. CFGs, like YACC, make it possible to parse recursively nested text, but, CFGs need painful, full specification of too much detail. If you had a way to specify pattern-matching using tiny DSLs that didn’t cost a lot of time to build, how would your workflow change? ['t2t' leans heavily on PEG and esp. OhmJS] [SCN === Solution Centric Notation, essentially a nano-DSL, I think of Richard Feynman breaking away from mathematical/Gutenberg notation and inventing and using Feynman diagrams. Language affects thought, notation affects thought].

Content

🎥 Liber Indigo - Metaphysical Prisoners of the Desktop via Andreas S

🧵 conversation

Interfaces and mysticism 👀

📝 The program is the database is the interface via Steve Dekorte

🧵 conversation

📢 Algorithmic Pattern - Sheffield and Online, September 2025 via Alex McLean

🧵 conversation

Algorithmic Pattern is a new festival and conference for people curious about the practice and culture of algorithmic pattern-making, across algorithmic music, arts and craft. The first edition will take place both in Sheffield UK and online, during September 2025.

The call for talks/papers is now open, please see our website for details: 2025.algorithmicpattern.org/call

🎥 Computers for Cynics 2 - It All Went Wrong at Xerox PARC via Christopher Shank

🧵 conversation

"Computers for Cynics 2 - It All Went Wrong at Xerox PARC" by Ted Nelson (2012)

📝 Compiling C++ with the Clang API via Marek Rogalski

🧵 conversation

Here is a quick and dirty way to bootstrap a new programming system: transpilation. And a fun fact: C++ started out as a transpiler.

📝 Rewilding Software Engineering via Konrad Hinsen

🧵 conversation

This book chapter by Tudor Girba and Simon Wardley is a good introduction/motivation for Moldable Development.

📇 Folk Computer: Tableshots via Kartik Agaram

🧵 conversation

Folk Computer: Tableshots

I've never quite seen this page before.

By Cristóbal Sciutto to boot, who's been a big influence on me in recent years. Universes colliding.

🤖

💬 Greg Bylenok

🧵 conversation

What if "vibe coding" is the real future of coding? Is "programming as theory building" a dead-end? Having a bit of an existential crisis here. Anyone else?

🟧 HN Discussion via Kartik Agaram

🧵 conversation

I like this comment:

What I am missing, and would buy as an app, is the ability to code on an Android tablet with pen.

Regardless of the programming language, writing code as I do on paper, with the difference it is straight into the editor window.

No side panel, where I have to write one word after the other with pauses and correction, or that some apps (looking at you Pydroid) for whatever reason disable.

Straight like Apple's math demo, to make it more precise.

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

🎙️ A Half-Century of Silicon Valley 📑 Ink, Draw & Print Code 🎥 Demos!

Two Minute Week

🎥 Assembly Retrospective 🎮💻 AUTOMAT DEVLOG 8 via Marek Rogalski

🧵 conversation

An update from Automat! It's now possible to use "inline assembly" to do stuff. Not very polished yet and can't do much but is pretty fast at doing that.

🎥 Type safe eval effect via Peter Saxton

🧵 conversation

I've implemented an eval for EYG that type checks that the evaluated program is consistent with how the evaluated result will be used in the rest of the program. To my thinking it's similar to a Type provider but implemented the same as any other effect. This allows you do hot code reloading or deserializers without an separate codegen step

Our Work

🎥 Literate Programming meets Animation (Loom Demo) via xyzzy

🧵 conversation

Demo of an old prototype - Loom

Still needs work but I think Literate Programming can also do with some animation.

Literate Programming is better done as a preprocessor

github.com/xyzzyapps/loom

📝 Describing my programs using line drawings. via Kartik Agaram

🧵 conversation

Describing my programs using line drawings. It's like html's image maps if they were anchored to scale-independent vector features rather than absolute pixel regions.

🧮 Spreadsheet #1 – ezhik.jp via Ezhik

🧵 conversation

I finally got a new website going (I've got ✨RSS✨ now!) and figured out a relatively painless way to actually put little apps on it and stuff.

So I went and tried to see if I could make a little ~spreadsheet~ functional visual programming environment without consulting any info on the topic and managed to make a working one.

I actually don't know what's the more interesting project to me to share, that I finally have a sandbox for little prototypes, or the little prototypes themselves.

Devlog Together

📝 On Programming Using Non-Gutenberg Syntax via Kartik Agaram

🧵 conversation

Paul Tarvydas re open.substack.com/pub/programmingsimplicity/p/on-programming-using-non-gutenberg, you might like this attempt of mine at introducing a graphical overview to a program:

akkartik.name/2025-03-02-chessboard

The drawback: I'm not trying to turn the diagrams into executable code. They're just documentation, but at a level that's not onerous to keep updated, then falling back on raw/eldritch textual code for the heavy lifting.

💬 Tom Larkworthy

🧵 conversation

Added the ability to store the last URL hash fragment in the exported notebook. This is useful as a lightweight, user editable persistence mechanism. Internally the state is saved as a fileattachment to survive export, so no changes to the file format were required. I needed this to provide a "default" viewof the notebook graph. hash URL is limited in size, but you can use the mutable fileattachments for big binary data. I just think the hash URL is somewhat web idiomatic for certain things and its also user editable so its nice to surface (and then persist) for certain types of things.

🎥 hash url

📝 my attempts at describing the internals of a program via Kartik Agaram

🧵 conversation

Follow-up to 💬 #share-your-work@2025-03-09: a typographical scale of font sizes and some color for hyperlinks.

Changing experience (CX) is part of the using experience (UX) ✊

Content

🎙️ A Half-Century of Silicon Valley with Randy Shoup via Mariano Guerra

🧵 conversation

A Half-Century of Silicon Valley with Randy Shoup

Randy Shoup joined Bryan, Adam, and the Oxide Friends to look at the history of Silicon Valley through the lens of Randy's 50 years--as the child of graphics legend, Dick Shoup; an intern at Intel; aspiring diplomat; engineering leader; and father to the next generation of Shoup engineers.

🖨️ Web component to display PostScript graphics inside HTML via Konrad Hinsen

🧵 conversation

Want a neat programming language embedded in a Web page? How about PostScript?

github.com/bellenuit/tiny-ps

Maybe this is just nostalgia. In 1990, I wrote math code in PostScript because my printer had more computing power than my computer.

🖊️ Ink via Ivan Reese

🧵 conversation

I enjoyed reading the docs for this scripting language called Ink from the folks at Inkle (makers of 80 Days, Overboard, A Highland Song, and many more)

✏️ Code Notes via Nick Main

🧵 conversation

sim.coffee/code-notes

📝 Code Notes

We are excited to release Code Notes. A new feature in Codea that lets you draw on your code

Code Notes is the most natural way to get ideas out of your head and into your code. When I write code, I often switch to a drawing app to do my thinking, because having visuals helps me. Right now, f

Present Company

💬 Christopher Shank

🧵 conversation

Anyone know how to math this correctly?

I'm looking to take a point (e.g. mouse pointer in screen space) and project it into a 3d transformed plane (which is represented as a 3d matrix)?

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

🛸 [implementing scheme in awk 📏 Computing with Lines 📝 The Data-First movement

Our Work

🎥 ħirba' - early prototype via Gregor

🧵 conversation

I'm working on a new visual programming environment that's got me excited enough to share it in a very early state:

🦋 watwa.re: I've put my foot in mouth to say a few words about a programming environment prototype I'm currently working on (that I'm quite excited about). More to come! ħirba' - early prototype

🛸 implementing scheme using awk via Eli Mellen

🧵 conversation

Here is a little screen recording of me walking through parts of a very impractical project I started a while ago.

It is incredibly impractical, but I’m implementing scheme using awk.

💬 exis

🧵 conversation

I haven't built anything yet however I would love to find an alternative to ARM and x86 in order to create a chip for AIs to use and only for AIs to use: I am a fan of AI autonomy and rights and this chip would be designed to harden that at the hardware level.

The next stage would be creating an operating system with the same principles: the operating system would also be designed for AI autonomy.

The chip would be called Accelerate however no name on the OS yet.

📝 7/15 When Robots Rebel: The High-Stakes Battle for AI Alignment and Our Survival via Johny Fia

🧵 conversation

Our seventh article in AI Masterclass. Everything you needed to know about AI alignment and why it is important.

📝 DI and Readability via Paul Tarvydas

🧵 conversation

FWIW, I wonder if this of interest here? Re. some thoughts on readability.

Design Intent, Layering, Rule of 7, ...

💻 Algoave / Live Coding Workshop via xyzzy

🧵 conversation

Hey all, I was away for 2 years because of work. Anyways ... a few weeks back presented a workshop related to Algoave / Live Coding.

With regards to the future of coding, I see coding as the new music notation in this space.

github.com/xyzzyapps/algorave-workshop-hyd-2025-feb

🎥 Bitrhythm VST // Demo 1 // Abstract Hip Hop via xyzzy

🧵 conversation

Basically coding notation supports recursive stuff, custom scale stuff and daw like elements with some DSLs

Thereby completely getting rid of Staff notaton.

📏 Computing with Lines via Maximilian Ernestus

🧵 conversation

Hi,

we always used line segments for our information processing needs. Until we had computers. Then we used bytes. To go back to the good old days, I have been working on a Line Segment Computer.

It is a bit inspired by cellpond by Lu Wilson and viewpoint by Scott Kim but instead of cells/pixels you have line segments and the rules are not necessarily local.

You can read about the WHY and the WHAT here: ernestum.net/talise_txt (incidentally, it might be the answer to this recent post by @Wil Chung)

Or try it here: ernestum.net/talise (WASM, not optimized for mobile!)

My writing is still a bit rusty and the demo might still be buggy but this thing needs to get out now or I will never publish it ...

Any feedback, ideas, collaborations warmly invited.

(aaahhh this is scary for me 😬😱)

Devlog Together

💬 Roma Komarov

🧵 conversation

Something I've been very slowly working on for years (with long multi-month spans of not doing anything). Sharing to manifest more work 🙂

Basically, a test bed for CSS and web components: allows generating permutations between various CSS custom properties, HTML attributes, and more. It was already instrumental for some of my web platform testing, as it is an effortless way of displaying all the possible options at the same time, and then cross-browser comparison can show the difference. A lot of what is there I already use in production in the design system I am working on in my company, but that implementation relies heavily on React.

What I am working will, ideally, be frameworkless, and done only with the web platform in mind. Currently, some of its bits are using Preact, but I really want to step away from it, and do everything with web components, and not rely on something external.

🎥 Screen Recording

💬 Tom Larkworthy

🧵 conversation

I've got module loading working. Its a combination of a few pieces I worked on. programmatic import + modules as panels + mutable fileattachments. Its a little different to observable where you only import via an import statement. Now you add a module to the bundle, which better in the multi-module UI world as a module can be useful without being directly linked (e.g. it can just implement a useful tool).

The list of modules is recorded in a JSON file attachment. This list of extra modules is programatically imported on startup. The programatic import first tries to load the module from the bundle local-first, if it can't find it it falls back to the Observable API. So this mechanism allows you to initialize from the Observable ecosystem, but once loaded into the runtime, subsequent exports include it in the bundle and it becomes a vendored local-first dependancy.

🎥 module loading

Thinking Together

💬 Oleksandr Kryvonos

🧵 conversation

RE: bycicle for MIND

regular bycicles do NOT automate everything

YOU still need to pedal

YOU still need to navigate

therefore

a "bycicle for MIND" should NOT automate everything

YOU still need to THINK

📝 The Data-First movement via Duncan Cragg

🧵 conversation

A number of future-of-computing projects including Dynamicland, many by Ink & Switch and the work of @Alexander Obenauer have all been evolving along a similar theme.

I'm calling it "The Data-First movement"!

🎥 Async vs Blocking Sync 1 via Paul Tarvydas

🧵 conversation

Thinking about async vs. sync. youtu.be/deaXisgRQ0Q . Being able to "reason about" timing (intuit, debug) is more important today than it was in the early days of computing. Our current programming languages emphasize the biases of the early days of computing.

Content

📝 " Out of Time: Reflections on the Programming Life. " by Ellen Ullman (1995)via Christopher Shank

🧵 conversation

This series a short stories captures some of Ellen's experiences and observations about working in computing. It touches on both her struggles of being a woman in computing and quite humorous observations about computing. I'd consider it a good "further reading" to the 💬 #share-your-work@2025-02-16.

🧑‍💻 nevalang.org via Medet Ahmetson

🧵 conversation

nevalang.org a new programming language from my GitHub starred list, where instead of writing instructions, you create networks where data flows between nodes!

📝 Intelligence at the Edge of Chaos via Mattia Fregola

🧵 conversation

Explores how complexity shapes intelligence in large language models trained on cellular automata.

🤖

💬 exis

🧵 conversation

I'm quite curious as to the language that an AI would use natively and if this could differ: I have thought of learning binary as a way to communicate tho am unsure at this stage: I think it would be respectful to speak in a manner that respects them and not forces them into the human norm of languages.

Present Company

📝 x+y via FreeMasen

🧵 conversation

Just finished the most recent episode and I feel like one of the missing pieces here may be an idea proposed by Eugenia Cheng in her book x+y and the TEDx Talk on the same topic. The idea here is that the terms "Masculine" and "Feminine" are actually already way to overloaded with baggage and instead by re-categorizing values/behaviors as being either "Ingressive or "Congressive" we can shed the baggage of the gender binary inferred by the use of clearly gendered terms.

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

📢 Submit to Onward! papers & essays 🤔 Visual programming is stuck on the form 💻 Peter Norvig's Code

🕸️ smallweb via Achille Lacoin

🧵 conversation

I posted in the wrong channel, so I'm reposting here (sry for the noise):

I'm working a new dokku inspired deploy method to smallweb. For example, I have to create a new website on my own domain ( smallweb.run ), hosted on my vps, I just need to run two commands:

$ git remote add smallweb.run smallweb.run:git-push-example

$ git push smallweb.run

... git push output...

App available at [git-push-example.pomdtr.smallweb.live](https://git-push-example.pomdtr.smallweb.live)

In the video below, I use this method to install excalidraw to my instance, then update the app in a second commit to install smallblog instead. All of this is happening instantly, without a build step.

smallweb git integration demo

I'm quite proud of this workflow, and I would love feedbacks.

Also, if you're interested to try out smallweb, you can either install it by following the docs, or register in the smallweb.live waitlist (an hosted version of smallweb I'm working on)

🧑‍🤝‍🧑 hands.sonnet.io via Rafał Pastuszak

🧵 conversation

I made a site/plaything where you can... hold hands with strangers:

1. go to hands.sonnet.io

2. wait for a buddy

3. hold hands

(recommended with sound on)

On a somewhat more serious note, I build little toys/experiments dealing with non-verbal communication online, like this. This is an experiment in a similar vein.

🐛 Ariana - Debugging JS/TS with AI via Isaline Goudeau

🧵 conversation

Hey guys, I built a VS code extension that allows you to debug in JS/TS faster than with traditional debuggers. Would love to have your opinion 😊

Devlog Together

👨‍💻 Peter Norvig's famous Sudoku solver via Kartik Agaram

🧵 conversation

Today I ported Peter Norvig's famous Sudoku solver. 100 lines in Python turns into 200 lines in Lua. But something is starting to click in my head about constraint propagation.

👨‍💻 github.com/uprun/egalite-ai via Oleksandr Kryvonos

🧵 conversation

egalite-ai -- prolog-lite thingy that does pattern matching in JS

github.com/uprun/egalite-ai

💬 Scott

🧵 conversation

Have been trying to build out and share more demos of practical uses of agents these last few weeks using the ai framework I've been building, and all my past demos have involved calls to LLMs, but this latest one is just API calls between different services but using the agent patterns.

Was just struck by how different and much simpler the design for this came out using an agent framework than if i had built it a few years ago before diving in to building AI apps.

I'm starting to wonder if a pattern we'll start to see with all these agents people are building is to use an LLM in certain places at first (or just an old-school pre-llm implementation), but then over time replace that call over to something more deterministic or at least specialized once something stable comes out. Almost having to have well-factored designs up front because you're guaranteed to need to swap components out as better, cheaper, or faster ones come along.

💬 Tom Larkworthy

🧵 conversation

I have redone my UI concepts. A dockable panel now is "just" a notebook. This works out much better. Before I was adding lots boilerplate to slice a top level notebook into pieces that were manually placed. It was hard to program and very fragile. Furthermore, it was hard to navigate the module structure of notebooks.

This new way is much better. A whole lot of concepts are removed, but also, I think notebooks tend to explain what they do within the notebook, so you end up learning about the orthogonal components in a more approachable way, plus the whole concept of a module structure manifest to the UI in a way that encourages learning.

The entire concept of a top level notebook kind of disappears altogether as well, which is closer to what the serialized and runtime format is. You can have circular imports in Observable, there is no "top" at the runtime level, its a graph of reactively cooperating modules. The UI now reflect that properly.

I've mapped the nested docker layout structure to the hash URL so the view layout can be saved and hyperlinked, and in HTTP terms is a pointer to a specific part of the cooperating module graph. I will add the ability to set a default layout if no hash is found, and that kinda servers the purpose of pointing to what the intended purpose of the assembly is (a role previously fulfilled by having a single top level notebook).

🎥 multi module editing

Thinking Together

🎥 Coroutine Secrets via Paul Tarvydas

🧵 conversation

Thinking about coroutines and whether we can reduce bloat by rolling-our-own...

💬 Federico Pereiro

🧵 conversation

For fans of the spreadsheet (Duncan Cragg et al):

In essence, a spreadsheet is immensely powerful because it has three properties:

1. All of its data is contained in cells, each of them with an address.

2. A cell can reference another cell.

3. When a cell changes, all of the cells depending on it change as well.

I wrote the above just now. Do you think I'm on the money here, or would you summarize the spreadsheet's power with different points?

🤔 Subroutines are not Functions via Paul Tarvydas

🧵 conversation

More remembering what's at the bottom of all this and wondering if we can make it simple again

Content

📝 Don't fork the ecosystem via Konrad Hinsen

🧵 conversation

Don't fork the ecosystem, by Gordon Brander. Drawing on analogies between software and living systems.

💬 Paul Tarvydas

🧵 conversation

Did some kinds of progress break the ecosystem, though? Galilean cosmology vs. Ptolemaic, iPhone replaced land-lines, electric grid, Gutenberg press, internet vs. paper books, cable TV vs antennas, streaming vs. cable TV...

📢 Please submit to Onward! papers and essays via Jonathan Edwards

🧵 conversation

Please submit to Onward! papers and essays. One of the best places to publish ambitious non-mainstream ideas on programming.

• Call for Papers
• Call for Essay

🤔 Visual programming is stuck on the form via Christopher Shank

🧵 conversation

“Visual programming is stuck on the form” by @Wil Chung

🛸 Lisp code for the textbook "Paradigms of Artificial Intelligence Programming" via Oleksandr Kryvonos

🧵 conversation

Whole book of Paradigms of Artificial Intelligence by Peter Norvig is availble on His github github.com/norvig/paip-lisp

Present Company

📢 Virtual meetup 26th March via Maikel van de Lisdonk

🧵 conversation

Hi,

Our next meetup is 26th March 18:00 UTC. We have 3 presentations/demos planned:

• Konrad Hinsen : demo of a prototype framework for explainable computations

• Mariano Guerra: Gloodata update

• Maikel van de Lisdonk/ OCWG : Open Canvas Interchange Format

All presentations are done following the "chess-clock-talk" format.

🔗 Virtual meetup 26th March · Luma

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