✉️ Not subscribed yet? Subscribe to the Newsletter

Future of Coding Weekly 2025/03 Week 5

2025-03-31 10:12

🎥 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.

image.png

📏 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

Youtube Thumbnail

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:

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

🧵 conversation

Youtube Thumbnail

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

Future of Coding Weekly 2025/03 Week 4

2025-03-23 23:08

🥞 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

Youtube Thumbnail

"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

Youtube Thumbnail

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

Future of Coding Weekly 2025/03 Week 3

2025-03-17 10:12

📢 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

Youtube Thumbnail

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.

image.png

📝 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

Youtube Thumbnail

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

Youtube Thumbnail

"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

Future of Coding Weekly 2025/03 Week 2

2025-03-10 00:03

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

Two Minute Week

🎥 Assembly Retrospective 🎮💻 AUTOMAT DEVLOG 8 via Marek Rogalski

🧵 conversation

Youtube Thumbnail

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

Vimeo Thumbnail

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

Youtube Thumbnail

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

big-picture.png

chessboard.png

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

image.png


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

Future of Coding Weekly 2025/03 Week 1

2025-03-03 11:28

🛸 [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

Youtube Thumbnail

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

Youtube Thumbnail

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

Youtube Thumbnail

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

Future of Coding Weekly 2025/02 Week 4

2025-02-23 22:26

📢 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

Знімок екрана 2025-02-18 о 10.55.32.png

💬 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

Youtube Thumbnail

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.

🤔 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:

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

Future of Coding Weekly 2025/02 Week 3

2025-02-16 23:01

🎙️ 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

Youtube Thumbnail

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.

workflow sketch.drawio.png

💬 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

Youtube Thumbnail

Worth watching even just because of this :D

Screenshot 2025-02-10 at 1.55.30 PM.png

💡 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

Youtube Thumbnail

🎥 Deep Dive into LLMs like ChatGPT via Oleksandr Kryvonos

🧵 conversation

Youtube Thumbnail

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

Future of Coding Weekly 2025/02 Week 2

2025-02-10 00:09

📝 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

Знімок екрана 2025-02-09 о 00.05.35.png

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

Youtube Thumbnail

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.

Screenshot 2025-02-06 at 9.21.01 pm.png

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

Future of Coding Weekly 2025/02 Week 1

2025-02-03 11:01

🎥 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.

P1270001(1).jpg

💻 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

Youtube Thumbnail

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

Youtube Thumbnail

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

Future of Coding Weekly 2025/01 Week 4

2025-01-27 18:10

🎥 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

Vimeo Thumbnail

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

Youtube Thumbnail

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

Youtube Thumbnail

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.

image.png

📝 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.

Screenshot 2025-01-20 at 12.05.13 PM.png

💬 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

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

Youtube Thumbnail

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)

Tweet Thumbnail

💡 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

Contents © 2025 Mariano Guerra - Powered by Nikola