devlog-together

💬 Tom Larkworthy

🧵conversation

Lopecode is still horribly difficult to use. One step in the right direction is LSP support. So this sniffs the live runtime for auto-complete information. There are no types to source from, so this is the dynamic language version of it. Quite cool that it can autocomplete on data (it has its disadvantageous too, not sure if I can figure out function arguments dynamically for instance)

💬 Tom Larkworthy: http://lopecode.com/

🧵conversation

I now own http://lopecode.com/ and I am putting on a notebook discovery feed for Notebooks hosted on atproto... and the landing page itself is a Lopecode document, itself hosted on atproto (https://did-plc-j7nm3lrd5h7fm3sfhcv3lhfv.lopecode.com/r/3mkxrk7yt4m2c). As Lopecode is primarily local-first, you can download anything to local file and work there. I have clear no mechanism to upload a file, hence this is definitely a devlog entry!

linking-together

💬 Tom Larkworthy: @sebastian.eurosky.social on Bluesky

🧵conversation

This post exemplifies why I am quite excited by atmosphere, in multiple ways.

@sebastian.eurosky.social on Bluesky

Cloud data sharing across apps, and the author has their social data hosted on European servers.

💬 Konrad Hinsen: A desktop made for one – Geir's Everything

🧵conversation

Vibe-coding your own desktop environment: https://isene.org/2026/05/Audience-of-One.html
As this toot points out, however, this personalization comes at the price of making oneself dependent on a coding agent.

of-ai

💬 Kartik Agaram: Ashe Vazquez Nuñez

🧵conversation

The thing I want to impress with this article is the consistency with which we as a species underestimate our own willingness to give up our culture, economy and autonomy to AI, even without monetary incentives.

-- Ashe Vazquez Nuñez

(Take out the "to AI". It's cleaner.)

present-company

💬 Ivan Reese: April 2026 - YouTube

🧵conversation

Would you look at that!

share-your-work

💬 Ivan Reese: Feeling of Computing • Episode 80 • Technical Dimensions of Feedback in Live Programming Systems

🧵conversation

Feeling of Computing • Episode 80 • Technical Dimensions of Feedback in Live Programming Systems by @Joshua Horowitz

The podcast is back!! Woof this one took a long time to edit. But, the good news, the good news: this paper is a banger, and I'm not just saying that because I've gazed longingly into Josh's eyes (and I'm not saying I have done that, either). More good news — several of you probably know that this paper is a banger, for reasons that will become clear to the rest of you as you listen. (Have I said too much? Is it too easy to figure out all these secrets? Keep mum.)

What's the paper about? I mean… you have live programming systems. They give you feedback on your program as you edit it. The design of the feedback mechanism(s) is an interesting space to explore, and there are tradeoffs and (Margaret) qualia to balance and stretch and enrich. In the paper, Josh maps out the space and gives us hints as to how to make live programming systems way the hell better. Personally, I left this paper wanting feeling super jazzed to go make even wilder visual programming systems. Hopefully you'll find it similarly exciting.

And I hope you enjoy the podcast. Let me know what you think — sincerely.

💬 Nilesh Trivedi (QwikBuild): [2605.04637] SWE-WebDevBench: Evaluating Coding Agent Application Platforms as Virtual Software Agencies

🧵conversation

Building an open benchmark - SWE-WebDevBench - for evaluating AI coding platforms like ourselves but also Replit, Lovable etc for real-world webapp development on complete software dev lifecycle.

Created a "lite" version for now, and did a comparative run against 6 major AI coding products. The Arxiv paper describes the framework.

https://webdevbench.com/

💬 Mariano Guerra: Can a Stochastic Parrot Learn new Tricks? Introducing Tutuca-Bench

🧵conversation

Can a Stochastic Parrot Learn new Tricks? Introducing Tutuca-Bench

Ask coding agents to use a new framework not in the training set* to solve 3 problems:

• Todo-MVC
• Temperature converter
• 7GUIs CRUD

Results:

1. Claude Code
2. Gemini CLI (best style)
3. OpenCode + Big Pickle

Codex required identity verification so it was disqualified

• Using skills and a framework CLI to guide them

thinking-together

💬 Kartik Agaram: The Intolerable Hypocrisy of Cyberlibertarianism

🧵conversation

Your inability to imagine a world where you don't get exactly what you want becomes a manifesto.

The Intolerable Hypocrisy of Cyberlibertarianism

💬 Jasmine Otto: wanix.site design document and sketch implementation from claude. origin: https://claude.ai/share/1458e67f-3d39-4fdf-b7f4-00f681e7d27b · GitHub

🧵conversation

latest on wanix from progrium: a local first fork/exec model for websites. feels very close to @Tom Larkworthy's Lopecode goals

ive been thinking about this design after apptron's built-in offline support for public pages, while also trying to think about a more gist-like version of apptron projects. i was also inspired by the #web/caches wanix fs that lets you interact with the caches api used with service workers for offline sites.

wanix.site design document and sketch implementation from claude. origin: https://claude.ai/share/1458e67f-3d39-4fdf-b7f4-00f681e7d27b · GitHub

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

devlog-together

💬 Tom Larkworthy: @lopecode/lopefeed

🧵conversation

I now own http://lopecode.com/ and I am putting on a notebook discovery feed for Notebooks hosted on atproto... and the landing page itself is a Lopecode document, itself hosted on atproto (https://did-plc-j7nm3lrd5h7fm3sfhcv3lhfv.lopecode.com/r/3mkxrk7yt4m2c). As Lopecode is primarily local-first, you can download anything to local file and work there. I have clear no mechanism to upload a file, hence this is definitely a devlog entry!

linking-together

💬 Konrad Hinsen: A desktop made for one – Geir's Everything

🧵conversation

Vibe-coding your own desktop environment: https://isene.org/2026/05/Audience-of-One.html
As this toot points out, however, this personalization comes at the price of making oneself dependent on a coding agent.

📑 Resources

• A desktop made for one – Geir's Everything
• Tiago Peixoto: "The idea of writing extremely customized software…" - social.skewed.de

💬 guitarvydas: Leanpub GhostAI

🧵conversation

This looks very interesting. I attended the Leanpub GhostAI workshop yesterday. I write blogs, but tend to get frustrated when trying to outline and compose whole books (I've never studied book-writing). These Claude Code skills seem to have been written by someone who knows how to structure books. I have only begun using the skills and already feel a useful arc emerging.
Leanpub GhostAI (open source, MIT license)

💬 curious_reader: Epistrons: Knowledge Artifacts for Hyperproblems - Hyperproblems

🧵conversation

https://hyperproblems.com/3mkigxsrjls2s?auth_completed=true that looks interesting, in particular „universities reorganising into platforms“ . What do you think? One of the many evolutions coming from Bret Victors exploitable Explanations leading into the many avenues of DeSci https://www.kernel.community/en/build/desci https://atproto.science

📑 Resources

• Epistrons: Knowledge Artifacts for Hyperproblems - Hyperproblems
• Kernel Community
• Empowering science communities with open, democratic, researcher-owned infrastructure. - ATproto Science

💬 Ivan Reese: There is no information content in Alan Kay - YouTube

🧵conversation

This is cute. "There is a little information content in the idea that the future is in our hands and we can do something about it"

💬 Konrad Hinsen: Wikipedia and the Semantic Web: Celebrating 20 Years of Co-Development and the Future

🧵conversation

"Wikipedia and the Semantic Web: Celebrating 20 Years of Co-Development and the Future": keynote talk by @Denny Vrandečić
Wikipedia and the Semantic Web: Celebrating 20 Years of Co-Development and the Future

share-your-work

💬 Mariano Guerra: Can a Stochastic Parrot Learn new Tricks? Introducing Tutuca-Bench

🧵conversation

Can a Stochastic Parrot Learn new Tricks? Introducing Tutuca-Bench

Ask coding agents to use a new framework not in the training set* to solve 3 problems:

• Todo-MVC
• Temperature converter
• 7GUIs CRUD

Results:

1. Claude Code
2. Gemini CLI (best style)
3. OpenCode + Big Pickle

Codex required identity verification so it was disqualified

• Using skills and a framework CLI to guide them

💬 guitarvydas: From State Machine to Python

🧵conversation

I walk through a simple three-state state machine and show how it is converted to Python code. This technique works for other languages. I use Python only as a lowest common denominator for this simplified example.

💬 Murat Kasimov: https://muratkasimov.art/Ya/Articles/Transformations,-functors,-categories/

🧵conversation

Hi everyone again! 👋 I published an introductory article on using natural transformations, functors and categories in Я - extremely composable embeddable programming language.
This order in the title is not accidental - functors start making sence in context of natural transformations and categories are rarely interesting without reasoning in terms of mappings between them i.e. functors.
In this article I briefly introduce these concepts and demonstrate how to use other categories in Я besides Arrow (regular functions) - Scope category and Event precategory; along how they are related to each other:
https://muratkasimov.art/Ya/Articles/Transformations,-functors,-categories/

💬 Mariano Guerra: Tutuca Update: Web Component integration, new CLI, llm.txt, more lints

🧵conversation

Tutuca Update: Web Component integration, new CLI, llm.txt, more lints

• Eject button in playground
• llm.txt
• CLI

• Web component & custom event example

• Linter hints about unused alter/input/computed definitions

• Lint string template placeholders
• Lint macro args not in macro definition

• Check function

• Component memoization when using dynamic bindings

• Dynamic binding example
• Pseudo x node
• Don't mangle identifiers in minified build

thinking-together

💬 curious_reader: Ghostty Is Leaving GitHub – Mitchell Hashimoto

🧵conversation

Big one ☝️, Dezentralisation is coming.
And it's a good thing
Ghostty Is Leaving GitHub – Mitchell Hashimoto

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

devlog-together

💬 Kartik Agaram

🧵conversation

A visualization of the Sieve of Eratosthenes

Each number on the x axis shows its largest prime factor in the y axis. When the largest prime factor is itself, the number is prime and the bar is highlighted in blue.

You can see multiples of prime numbers if you scan at any particular height from left to right.

The usual 2D arrangement is necessary on paper or a non-interactive medium, but if you have a touch screen with pan and pinch zoom it seems nicer to spread the numbers out in a single line.

There's an overlay always visible to show you which number each bar is for. Where the bar occludes the overlay it's easy to deduce from neighboring numbers on the overlay.

Each composite mentions its largest prime factor, so you can see at a glance why it's composite. And scanning to the left also gives you a visual "proof" of compositeness; you can see the grey bars of that height stretching leftward at a regular cadence.

📑 Resources

linking-together

💬 Medet Ahmetson: Flipbook

🧵conversation

Flipbook

Did you see it? Anyone knows similar but for interfaces?

💬 Dennis: x.com liamflannery56 status

🧵conversation

I think this belongs here x.com liamflannery56 status

present-company

💬 Jasmine Otto: Liveness + Agency – Stochastic Labs

🧵conversation

Sharing a CFP for Stochastic's summer residency in Berkeley, CA. The tech-art scene in the East Bay is super lively, here's a way to live it for two months. Also a great excuse to chat with @Max Kreminski or with Joel Simon about your proposal - they're good folks. https://stochasticlabs.org/liveness-agency/

reading-together

💬 Karl Svartholm: 55 • Man-Computer Symbiosis by J.C.R. Licklider

🧵conversation

Just relistened to the 4 year old FoC episode on Man-Computer Symbiosis by J.C.R. Licklider: https://feelingof.com/episodes/055/
Sort of uncanny now. The skepticism made sense then, but post-LLMs it feels a lot more like Lickie was describing the thing starting to arrive now...

share-your-work

💬 Scott: aland — artifact.land from your terminal

🧵conversation

Also something else that might be interesting to some of you here - I'm playing around with this UX idea of "bring your own claude code" or "bring your own agent" - instead of me setting up any inference or AI on my site, it's designed so that you can point your claude code at it and build things rather than having to pay for a subscription and buy credits and all that nonsense... I gave a talk about it yesterday to another group but also happy to share more here if anyone is interested... the start of the idea is here: https://artifact.land/cli

💬 Scott: Artifacts Are Alive (And Photographs are Dead)

🧵conversation

I've been pretty addicted to getting Claude to build the little standalone html/javascript artifacts lately and a few of my friends have caught the bug. I feel like there are a lot of possibilities with them - beyond just creating tons of Bret Victor-style explorable explanations (which is also a ton of fun). Wrote up a little piece about it and this idea around a social network for software that might become possible: Artifacts Are Alive (And Photographs are Dead)

💬 Ivan Reese: this lil interactive art project

🧵conversation

I've spent the last (checks time machine) six months chipping away at this lil interactive art project to celebrate the 10th birthday of Ink & Switch.

Would love for you to go play with it, then join the FoC virtual meetup next Wednesday to learn some of the cool inner workings.

💬 Mariano Guerra: Tutuca Update: Storybook in Storybook

🧵conversation

Tutuca Update: Storybook in Storybook 🐢️

• Storybook component
• Drag and drop support on mobile
• Performance improvements, removed generators, iterators, indirection and allocations
• Detect and avoid infinite recursion
• Fix a bug with computed properties inside a render-it directive

thinking-together

💬 curious_reader: Folk Tech Showcase! - April 2026 - Project Show & Tell · Luma

🧵conversation

Hey 👋 ,
has anyone heard of Folk Tech Showcase! - April 2026 - Project Show & Tell "Folk Tech"? Is that related to the Folk Computer?

💬 Jasmine Otto: explainers/css-spatial/explainer.md at main · WebKit/explainers

🧵conversation

@Brandel Zachernuk's team has launched a css-spatial proposal with an elegant page vs. portal metaphor - whether components are above or beneath the screen plane. Portals enable techniques like parallax, a powerful 2.5D effect used in sidescrolling videogames for decades. Excited to see it on the web.
https://github.com/WebKit/explainers/blob/main/css-spatial/explainer.md

💬 Konrad Hinsen: Slack Thread

🧵conversation

Another discussion in this thread reminded me of a paper on linguistics and programming languages that I read a while ago. The paper is in French, but in the days of automatic translation that shouldn't be a problem any more (OK, I admit I never tried to have a whole paper translated). It discusses the differences between formal languages used in CS theory (e.g. lambda calculus) and formal languages used to write actual programs, and notes that the latter have many characteristics of natural human languages that one wouldn't expect in formal systems from a purely formal point of view. Examples given are traces of historical evolution, such as traces of K&R C in ANSI C, redundancies such as multiple formally equivalent loop constructs (while / until etc.), expletives such as no-ops and comments, etc. Another argument is the existence of a "literature", e.g. the Unix source code as a literature for C.

💬 Jason Morris

🧵conversation

I'm trying to wrap my head around the idea of "MCP Apps", but I'm having difficulty knowing if any of the metaphors track. It's an app interface in an iFrame in your AI chat. So if it's a coding environment app, it is sort of like an inversion of "an agent in your IDE" to "an IDE in your agent". Does that matter? It feels like it might just because conversation is the dominant interface, and that is going to be more approachable for more people. But I don't know what it means about the ephemerality of the IDE inside the chat. Like, at what point is it no longer expected to maintain state with the repository? When it scrolls out of view? When there's a newer one? Does anyone have an intuition for it they can share? Interactive read-only views seem easy enough to integrate into that workflow, but having stateful apps feels really weird. Conversations are append only.

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

announcements

💬 Ivan Reese: April Virtual Meetup · Luma

🧵conversation

April Virtual Meetup • Wednesday the 29th at 18:00 UTC • RSVP

The feeling of virtual meetup. It's almost a routine at this point. Almost. It's almost a wake up, pour a glass of cranberry water, take a spoonful of omega-3, multivitamin, b12, maybe another pill every second day. Play bicross while the kettle boils and coffee brews. Put your hair up. Moisturize. Floss. Think about the part of Clipse's 2002 song Virginia where Malice says "Don't ask about my music and how that's comin' 'bout / Don't ask about my album, or when's it comin' out". The song plays perfectly in your mind, Koji Kondo's iconic production bouncing off the ghostly tree trunks. Oh, it's patch day! Yay, patch day.

Is this the feeling of computing? Should it be? Let's get together to look at a spiky "unknown" array language with a musical REPL, and at a system for automatically parameterizing SVGs to make them interactive, and a secret little silly project from Ink & Switch.

Demos from resident heartthrob Eli Mellen, reigning virtual meetup champion Tom Larkworthy, and somebody I am every morning, routinely, or who I'll be by then, Kokiri.

📑 Resources

• Wednesday the 29th at 18:00 UTC
• April Virtual Meetup · Luma
• Bicross Daily
• The Ocarina of Rhyme: Team Teamwork - Clipse - Virginia (Lost Woods) - YouTube

devlog-together

💬 Jimmy Miller

🧵conversation

Finally got some time to play with something I've always wanted, a whiteboard that actually makes your system come to life. Very early days. Very simple. But I have so many ideas for how I could make this actually useful and good.

Ideally I want to not only sketch distributed systems things but simple models of programs. Hopefully will have time to play and expand this in to more and more expressive territory soon.

📑 Resources

• whiteboard

linking-together

💬 Konrad Hinsen: The Computing Historian Recovering Ideas We Threw Away

🧵conversation

Interesting interview by @Sam Arbesman with Paul Rony, on lessons from the history of computing: The Computing Historian Recovering Ideas We Threw Away

💬 Geert Roumen: Spatial Pixel

🧵conversation

Super cool work by Violet Whitney and William Martin on spatial computing with some llm to “speak human” with artificial intelligence and spatial computing. Think mixed reality without the glasses.

Spatial Pixel

share-your-work

💬 Eli: kiki learn

🧵conversation

since that blog post about kiki, I've focused on addressing feedback from the array programming discord, and also making a bunch of stuff to make kiki more approachable (because it is sharp and pointy)

• learn
• hymns (intro material to kiki's live coding environment)

💬 Medet Ahmetson: Whitepaper

🧵conversation

I released the Ara's whitepaper: Whitepaper, Bitcointalk forum, Website.

Although the whitepaper approaches this from a blockchain perspective,
Ara is not crypto project in a traditional sense. Instead, it redefines blockchain as a protocol agreement that carries software's semantics and acts as the decentralized recommendation engine.

The Ara's goal is the "software ownership" for the users. Or in the decentralization community sense "Web3 as the creative digital workspace built on collective wisdom".
Technically, it's a desktop shell where users can change the software itself. For developers who submit open-source projects, Ara gives a funding, and a feedback for refactoring projects toward MVC pattern: data lives on the user's computer, the view is on their screen, and the application itself is simplified into a remote service that does concrete thing.

Possible future
For me, the real use case for AI is embedded and possibly trained by the user, residing in the workspace, allowing to customize them. It also gains the semantics of the applications allowing for the extended Siri on the desktop.

Also, Ara redefines the metaverse as MVC-split software with spatial data blending all applications together.

There are Utopian ideas beyond the metaverse, but I kept those in the appendices of the whitepaper.

AraTalk:

• This post is to discuss the idea, criticism and collaboration are welcome.
• For the blockchain related questions (technical, economical etc) visit Bitcointalk post (requires sign up to write)
• For the open-source sustainability model, and Ara from the open-source maintainer's perspective, visit the SustainOSS discourse.

💬 Mariano Guerra: Tutuca Update April 13 2026 - YouTube

🧵conversation

Tutuca Update:

• Install immutablejs custom formatter if not detected
• Log transaction information
• Playground time travel slider
• API Docs tab auto-generated on each run
• Lint tab updated on each run
• Common mistakes example in the tutorial

thinking-together

💬 Jason Morris

🧵conversation

I'm trying to wrap my head around the idea of "MCP Apps", but I'm having difficulty knowing if any of the metaphors track. It's an app interface in an iFrame in your AI chat. So if it's a coding environment app, it is sort of like an inversion of "an agent in your IDE" to "an IDE in your agent". Does that matter? It feels like it might just because conversation is the dominant interface, and that is going to be more approachable for more people. But I don't know what it means about the ephemerality of the IDE inside the chat. Like, at what point is it no longer expected to maintain state with the repository? When it scrolls out of view? When there's a newer one? Does anyone have an intuition for it they can share? Interactive read-only views seem easy enough to integrate into that workflow, but having stateful apps feels really weird. Conversations are append only.

💬 H3X4G0N: H3X Framework Presentation Fix

🧵conversation

hi guys. on the topic of thinking and especially thinking ahead, i started with the "project" in the presentation link almost a year ago, solo, because an idea sparked an avalanche of discoveries. Sadly i a m in no position to publicly disclose anything technical for security reasons.. think in terms of CRISPR. however i have this barely finished presentation which is aimed at general public. some slides are missing but all audio is there.. would love to hear you feedback.

H3X Framework Presentation Fix

💬 guitarvydas

🧵conversation

Today, I spent much of my time bouncing ideas of an LLM (Claude) and using the LLM as a foil. I'm interested in "language" design, hence, my line of thinking went down this path...

The interesting corollary

If the text-as-notation choice was driven by hardware weakness — keyboards and line printers being the available I/O — then the arrival of bitmap displays and pointing devices in the late 1970s and 1980s should have triggered a paradigm shift toward diagrammatic programming. It didn't, for exactly the tooling-gravity reason discussed earlier: by then, text-based languages had accumulated compilers, libraries, communities, and curricula. Smalltalk gestured toward something different. Sketchpad had already shown in 1963 what a diagrammatic computing medium could look like. But the gravity of text was already too strong.

We may be at the first moment where that gravity is genuinely weakening — not because hardware changed again, but because LLMs make it possible to build the tooling layer for new notations without the decades of infrastructure investment that previously made it prohibitive.

💬 guitarvydas: Understanding Smallness and Speed - by Paul Tarvydas

🧵conversation

Understanding Smallness and Speed Understanding Smallness and Speed

💬 guitarvydas: Slack

🧵conversation

@Konrad Hinsen's link spawned this thought, among others, as I watched:

TL;DR — Old code is dying. The code isn't the problem. The business rules embedded in it are. LLMs can extract those rules into a factbase. A factbase can be rewritten into any target language. This is Design Recovery, and it is the right job for LLMs.

LLMs as Design Recovery Engines

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

🧑‍💻️ RISC-V Linux BusyBox Single Board Computer 📑️ Federated Wiki 📐️ Parametric SVG

linking-together

💬 Geert Roumen: Spatial Pixel

🧵conversation

Super cool work by Violet Whitney and William Martin on spatial computing with some llm to “speak human” with artificial intelligence and spatial computing. Think mixed reality without the glasses.

Spatial Pixel

share-your-work

💬 Duane McLemore: Train Trees

🧵conversation

I can't take credit for anything here, it's all Claude's doing. But I wanted to share because I thought you all might enjoy.

I am a long time user of a programming environment called Grasshopper in the Rhino3d modeling program. It uses a node-based graph editor. And recently I realized that part of why I have been drawn to the array languages in the past few years is because Grasshopper also uses nested data structures to organize and manipulate the data.

In Dyalog APL I am still getting my head around Train Trees as a way to view the order of operations in trains, but I love the economy and poetry of how they work.

Anyway - as I learn more APL, I've always wanted more specifically graphical ways to view the results of an expression. So I thought I'd combine the two. This is APL Sandbox, a node-based graphical environment for the viewing of APL expressions.

It is fully vibe-coded at this point, and there's a lot more I would want to do to it. Change the direction to match APL's right-to-left application, with ⍺ and the result on the left and ⍵ on the right. Getting "boxing" and other visual indicators of the nature of the arrays produced going is another important one. A way to collapse two nodes into one is another item I'd like to implement. And so forth.

So, even though it's very much a toy at this point, I thought maybe some of you might be interested to see it. Enjoy!

GitHub - duanerobot/APL_Sandbox: A visual node-based APL sandbox — wire glyphs, trains, and dfns together and inspect results at each step. Requires Dyalog APL. · GitHub

💬 Eli: Oatmeal - kiki

🧵conversation

I've been working on a little array programming toy for a little bit.

Published an intro blog post to it last night.

I've spent the last few years smitten by array programming, but always finding it a tad bit unapproachable outside of profoundly boring (to me) corporate contexts. I'm attracted, though, to how spiky and terse array programming is, which feels very different to me than where I usually live in JS land.

To make it more approachable, I made a little set of learning features loosely inspired by maria.cloud's approach.

You can make tiny songs with it, too.

📑 Resources

• Oatmeal - kiki
• kiki learn
• kiki sing

💬 Mariano Guerra: Tutuca: Zero-dependency batteries included SPA framework

🧵conversation

There comes a point in every man’s life where he releases an open source frontend framework. That day, for me, is today.

Tutuca: a zero-dependency, batteries-included SPA framework

https://marianoguerra.github.io/tutuca/

Would love your feedback on the framework, the landing page and the tutorial

💬 guitarvydas: Little Language Case Study - Generating Code for Simple State Machines

🧵conversation

We've spent decades building programming languages that try to do everything — general-purpose, Turing-complete, expressive, fast, safe, concurrent. ...
But the ambition to make one language handle every problem has a shadow side: it makes us reach for that one language even when a smaller, more targeted tool would serve us better.

Little Language Case Study - Generating Code for Simple State Machines

💬 Konrad Hinsen: Federated Wiki - Catalog - Malleable Systems Forum

🧵conversation

I have written an entry on Federated Wiki for the catalog of the Malleable Systems Collective, because I believe that it deserves to be better known: Federated Wiki - Catalog - Malleable Systems Forum

💬 Dennis: WordWell — a visual word explorer

🧵conversation

Tangentially related, but made a visual word explorer that shows you 'interpolated' words or phrases between 'wells' of meaning on a canvas. You can play with it at wordwell.so

📑 Resources

• Screen Recording 2026-04-06 at 4.53.57 PM.mov

💬 Tom Larkworthy: Parametric SVG

🧵conversation

A Feelings of Computing one.

This is the 2nd time I have returned to the idea of using inverse kinematics to manipulate graphics. But I have moved to plain SVG now, thinking that that is somewhat of a universal representation.

And the new thing is reflecting on a reactive dataflow graph to discover parameterization automatically, and also extracting the params -> svg from the computational graph automatically, so the author only has to write parameterized SVG, and choose location of drag anchors, and the system can figure out how the anchors related to the SVG parameterization via numerical differentiation magically, so the drag handling is all free.

https://tomlarkworthy.github.io/lopebooks/notebooks/@tomlarkworthy_parameteric-svg.html

You can get a lot of expressivity out of this for not much investment. You can choose how your parameters affect your SVG, it can be quite weird. Not sure how to handle something like a normal drawing program though with multiple objects. I think I there is still something missing though. I generally want to make drawing diagrams easier, this is very finite dimensioned though.

📑 Resources

• crank.mov
• Parametric SVG

💬 Geert Roumen: GitHub - lemio/ReverseProjection: Project using a camera · GitHub

🧵conversation

Reverse projection as a way to do spatial computing.

This is a demo of js-ar-toolkit5 connected to leaflet or tldraw that uses a camera to project stuff on smartphones. Inspired by dynamicland, but replacing the paper with phones and the projector by a camera. It makes the phone more a tool for creation instead of consumption and makes use of our ability to move (ourselves and our phones) around to create meaning.

Curious to learn if there is other use cases where this could make sense; currently thinking more about brainstorms or museum exhibitions where visitors can contribute to the exhibition and what other experiments are done in this space.

The source code can be found there https://github.com/lemio/ReverseProjection and can just be tested when ran on a laptop and a phone. The source code is very vibe coded; more to get a working result than to make it ‘good’.

Multiple phones does not work reliably at the moment, but is on my todo list; other types of hardware like a bluetooth keyboard with some marker would also be cool; so it becomes easier to ‘type in space’.

Reverse Projection - YouTube

two-minute-week

💬 Tom Larkworthy: RISC-V Linux BusyBox Single Board Computer

🧵conversation

The easter holidays I got sick and vibe coded a

RISC-V Linux BusyBox Single Board Computer
https://tomlarkworthy.github.io/lopebooks/notebooks/@tomlarkworthy_linux-sbc.html

in a single HTML file. Its quite different to Fabrice's jslinux, it is a JS emulator of the Risk V instruction set, rather than a WASM emscripten toolchain approach.

I wanted to understand the linux boot process. Vibed with my new Claude code plugin for notebooks which is incredibly productive albeit still with a fair few rough edges.

📑 Resources

• linux.mov

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

📢️ New conversations archive, open any 🧵conversation link and let me know what you think!

linking-together

💬 Tom Larkworthy: @larkworthy.bsky.social on Bluesky

🧵conversation

@larkworthy.bsky.social on Bluesky

💬 curious_reader: Clojure: The Documentary [OFFICIAL TRAILER] | Coming April 16th! 🚨 - YouTube

🧵conversation

💬 Pandi Lin: Notes on Notation — Christoph Locher · Interaction Designer

🧵conversation

find a very inspiring article: Notes on Notation — Christoph Locher · Interaction Designer

share-your-work

💬 guitarvydas: The Spherical Cow We Forgot We Were Riding

🧵conversation

The Case for Composable Notations
We don't need to start over. We need to start composing.

1 of 5 The Spherical Cow We Forgot We Were Riding
2 of 5 The Restrictions That Came With the Cow
3 of 5 State Isn't The Enemy
4 of 5 Ease of Expression Is the Whole Point
5 of 5 UNIX Already Showed Us the Way
6 of 5 WIP - Notations in Progress

thinking-together

💬 Jacob Pfeifer: @pfeif.garden on Bluesky

🧵conversation

@pfeif.garden on Bluesky
Some folks on bluesky are circling around a new metaphor that I hope is in the family of Feeling of Computing.

Would love for y'all to add input here. This idea is pretty exciting to me. I'll have more longform thoughts on what I'm building and where it fits soon, but figuring out this metaphor together is an important way to start. A collective mental model is the first step towards collective action.

If you want to participate in the Ecological Computer, we're on our way.

two-minute-week

💬 guitarvydas: Schmitt trigger

🧵conversation

Your description reminds me of a Schmitt trigger used in electronics. One can implement a Schmitt-trigger-like action in the digital domain with a state machine:
S1: when a 0->1 event occurs, go to state S2.
S2: when a 1->0 event occurs go back to state S1.
(I think of the timer variant as a Schmitt trigger that deals with analog signals).

💬 maf

🧵conversation

I guess observable enthusiasts around here may find this one interesting! I'm designing a way for object to "act together" in a more natural way. This involves objects that do stuff (as opposed to simply computing a value) and that can generate their own events. Examples on the video are a Timer (which can be started/stopped and will stop itself automatically after some time) or a KeyPresser (which can be pressed down/released, based on the physical keyboard's keys but may also generate synthetic events, according to notifications received from other objects).

On the video you can see a simple Timer-based limiter, that releases the space after half a second. I can press the key myself, and that will cause Automat to start the Timer (you can take a closer look at the hand over the Key Presser - it shows whether the key is pressed or not). And then after some time, Automat will release the key for me. If I release the key sooner, the Timer is cancelled. You can see that the flow of information is multidirectional. The direction is indicated by the movement of belts between gears. That's the first half of the video.

One fundamental issue of these observable systems is that the computation would loop forever if the objects just announced their new state on every change. Typically they are only evaluated once, according to some topological sorting (most observable systems don't allow loops) and they also store & compare their state to prevent redundant updates (optional optimization in loop-free reactive systems but absolutely necessary if loops are allowed - it's the stop condition).

(terminology: many people call this "feedback loops" and treat this as an undesired behavior, but IMO there are places where feedback loops are a sound solution, so I'll call this "reactive echo" - it's when an object changes state but then notifies the source of the change of its change. Another reason is that "reactive echo" doesn't really need to cause a loop - the issue is that a change notification is accidentally sent back)

None of this is new - it's a pretty well known pattern. Fun things start when the OS is involved & objects start to flip-flop fast. This happens when I create a loop with the Timer. This is the second part of the video. The Timer switches itself off & on - but it happens pretty much instantly. This off/on switching still generates notifications for the Key Presser - so it sends the events to the OS. And some time after, the OS sends these events back to Automat. There is a delay caused by the OS. The events differ from the internal state tracked by the Key Presser, so they must be announced to other synchronized objects, causing the Timer to stop & restart instantly. The flow of events is:

• I press the key down => "ON" notification sent to the Timer
• Timer completes => "OFF" notification sent to the Key Presser, which posts a synthetic "release key" event
• Timer restarts => "ON" notification sent to the Key Presser, which posts a synthetic "press key" event
• OS sends back the "key released" event to Key Presser => "OFF" notification sent to the Timer (uh oh! it's a reactive echo!)
• OS sends back the "key pressed" event to Key Presser => "ON" notification sent to the Timer (again - it's a reactive echo!)

The last two events should not be there. But the causal chain of reactive echo escapes the process and arrives back with a delay so it cannot be reasoned about in a local fashion. There is no portable way to distinguish synthetic vs natural events so they cannot be simply ignored. I cannot even attach anything to these events explicitly. They're pretty much indistinguishable from real user events.

As you can see on video, it actually works fine - this is because Automat is now using a completely different way to prevent the reactive echo (Automat has five different echo cancellation mechanisms, lol). I like this one the most because it's using a strategy known from biological neurons. You won't find it in the artificial ones! The real biological neurons have an inhibitory period that they enter after firing. This allows them to prevent back-flow of information in a completely distributed fashion - without the need for a central orchestrator that will sequence their activations in topological order - and without the need to track & compare any internal "value" (neurons store no bits - they just "fire" & rest). The way it works in Automat is that whenever a Key Presser sends an event, it records a timestamp - it's the start of its inhibitory period. For the duration of this period it will ignore the next event received from the OS. Very simple solution actually, and widely used in nature - but not so much in engineered reactive systems. But if you think about it - it could be!

📑 Resources

• 2026-04-01 15-11-03.mp4

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

devlog-together

💬 Ivan Reese

🧵conversation

i'd like to add some more vaguely "private" pages to my website. private in the "obscure" sense, not "secure". like, i'm going to leave breadcrumbs so interested people can find them, and i'm legit fine with anyone finding them, but i don't want them to be out in the open.

the site source is going to be on indexed code-hosting social networks (like github), but i don't want shit coming up in search results. i'm thinking of doing, like, rot13 in a git hook? that might be fine?

curious what ya'll would suggest i do instead.

linking-together

💬 Konrad Hinsen: Web Tiles

🧵conversation

These "Web Tiles" look interesting: https://webtil.es/
Source (and short thread describing them): @robin.berjon.com on Bluesky

present-company

💬 Ivan Reese

🧵conversation

Hey, let's do another virtual meetup this month, on the 25th. Need some demos! Any takers?

💬 chris.shank.23: Bluesky Map

🧵conversation

Someone mapped out the social graph of bluesky, which is fun to interact with. Most of the FoC community seems located on the edges of the web dev galaxy and I added labels to smaller clusters within.

@chee noticed that we are more closely situated with designers than software engineering

Bluesky Map

share-your-work

💬 guitarvydas: DIY Forth - Forth Haiku Analysis Part 1 - by Paul Tarvydas

🧵conversation

.. The current trend in sports psychology towards flow (staying “in the zone”) affects programming, too. ...

... Building compilers as shown in previous articles regarding Forth Haiku, is super-simple. ...

Compilation Using Two Stage Code Emission

💬 Eli: Oatmeal - Screen readers

🧵conversation

I updated my page that suggests a mental model of how screen readers work for developers (especially web developers). I’d love to know how it hits/if it leaves you with any questions!

💬 mariano: MargaUI: A No-Build, Native Tailwind 4 Port of DaisyUI

🧵conversation

MargaUI: a port of daisyUI that can generate Tailwind and daisyUI CSS live in the browser.

MargaUI: A No-Build, Native Tailwind 4 Port of DaisyUI

Live Editor

Component examples with theme switcher

💬 Ezhik: (AI) Slop Terrifies Me – ezhik.jp

🧵conversation

wrote a blog about "craft software" and slop (not necessarily the ai kind)

what if end user programming is our only out?

(AI) Slop Terrifies Me – ezhik.jp

💬 hamish todd: 3D interaction/"AR" using Folk Computer! - YouTube

🧵conversation

Hello folks! Here's a recording of a presentation I made at Feeling of Coding London 🙂 3D interaction/"AR" using Folk Computer! - YouTube

💬 Daniel Coutinho Ribeiro: GitHub - creact-labs/creact: Use JSX to automate durable workflows

🧵conversation

Hey fellas, just launche v0.3 of CReact alongside a new demo

Framework: https://github.com/creact-labs/creact
Demo: https://github.com/creact-labs/ai-powered-aws-website-generator

📑 Resources

• GitHub - creact-labs/creact: Use JSX to automate durable workflows
• GitHub - creact-labs/ai-powered-aws-website-generator

thinking-together

💬 Naveen Michaud-Agrawal

🧵conversation

Saw this quote on a recent Quora answer from Alan Kay "since the computer could simulate anything that could be described — it was a true metamedium, and that meant there were likely media on the computer that could only exist because of the computer".

What kind of media could only exist on a computer? A few I can come up with - simulations of phenomena, games, pretty much anything with a time based dimension (except 2D+time, like movies, those existed before)

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

devlog-together

💬 Tom Larkworthy

🧵conversation

I have serialized Lopebook into a single string you can paste into the console. Here I am editing an notebook inside google maps, lol (trying to think of good demos for serializability)

linking-together

💬 Dev Hayatpur: LIVE 2026 | Workshop on Live Programming (LIVE)

🧵conversation

Hi everyone,

The LIVE Programming Workshop will be held online Oct 17. Submissions due July 21. https://liveprog.org/ LIVE welcomes a broad range of submissions on new programming interfaces. Submissions can take many forms, from a traditional paper, a web essay, or a video. Happy to chat if you've any questions!

PS: The website (on desktop) has a little easter egg:)

📑 Resources

• LIVE 2026 | Workshop on Live Programming (LIVE)

💬 gtlpd21: Building a New VR Universe - Resonite - YouTube

🧵conversation

Just thinking I won't say resonite has a very novel programming language, but the way it really incubated a thriving community for the language ecology do feels very inspiring for me: Building a New VR Universe - Resonite

📑 Resources

• Building a New VR Universe - Resonite - YouTube

💬 Arcade Wise: Antonymph

🧵conversation

If for some reason you have a deepseated aversion to My Little Pony, don't check this out, but otherwise, please do. It's possibly the coolest thing I've ever seen someone do with a browser.

https://lyra.horse/antonymph/

📑 Resources

• Antonymph

present-company

💬 Ivan Reese: Feeling of Computing · Events Calendar

🧵conversation

The London FoC meetup is thriving!

There's a new domain to burn into your brain: https://feelingof.london

📑 Resources

• Feeling of Computing · Events Calendar

share-your-work

💬 Eli: Oatmeal - Constraint propagation for fun

🧵conversation

Tried to write a vaguely technical blog post about how I’m using constraint propagation in a game I recently made…I’d rate it a mixed success

📑 Resources

• Oatmeal - Constraint propagation for fun

💬 guitarvydas: Make Programming Distributed and Asynchronous Again

🧵conversation

Trying to describe an asynchronous system using reactive components programmed in the synchronous programming paradigm is too low level. We need a “GOTO Considered Harmful” moment in distributed programming.

Make Programming Distributed and Asynchronous Again

📑 Resources

• Make Programming Distributed and Asynchronous Again

💬 guitarvydas: Make Programming Fun Again

🧵conversation

Trying to make a sketch of my opinion of what constitutes fun programming…

Fun

• JIT type checking, Full REPL, GC

Not Fun

• AOT type checking, manual memory management, manual type checking, stunted REPL

Make Programming Fun Again

📑 Resources

• Make Programming Fun Again

💬 guitarvydas: Why Modern Software Is So Bloated

🧵conversation

I've been dissecting Forth Haiku, mentioned on the Handmade discord. This rabbit hole just strengthens my convictions about bloatware...

Here’s an uncomfortable truth: nearly all modern programming languages are essentially the same. They’re variants of CPU assembler—synchronous, sequential, and built around the function call paradigm.

Why Modern Software Is So Bloated

💬 gtlpd21

🧵conversation

One more clarification about the motivation.

Most end-user systems and programming models are still shaped by a
personal-computing assumption: one user, one machine, one isolated
environment.

It is normal for one individual nowadays to operate across 3 to 5 computers and
devices (for example a laptop, phone, tablet, and nearby or embedded
machines), and in many real situations several people and many computers
coexist in the same physical and social space. Computing is increasingly situated, shared and continuous,
rather than isolated.
At the same time, software built around personal computing makes it
cumbersome to actually use this abundance of devices and computers
together, or to let them meaningfully participate in the space and
situation we are physically inside in an infrastructural level.
What I am interested in is this question:

what would it look like if we built a programming language that provides a
single, shared and persistent environment across multiple peers?

Therefore this is an attempt to build such an environment as an infrastructure, and
to use it as a foundation for experimenting with different ways of
building, sharing and coordinating software in multi-device and social
settings.

thinking-together

💬 guitarvydas: do we need a new programming language for the AI era?

🧵conversation

AI can now port code between programming languages with surprising accuracy. This capability raises an intriguing question: should we create new languages specifically designed for directing AI?

do we need a new programming language for the AI era?

two-minute-week

💬 mariano: Event Fabric Quick Overview

🧵conversation

Ten years ago in 2 minutes 😄

Event Fabric Quick Overview

Skip the intro and jump to the demo section with this timestamp link

👨🏽‍💻 By 🐘 @[email protected] 🦋 @marianoguerra.org

💬 Not a member yet? Check the Feeling of Computing Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Feeling of Computing Podcast

📢 First release with a brand new set of tools, let me know if something is broken (aside from new format)

devlog-together

💬 Oleksandr Kryvonos: GitHub - uprun/web-console: expose your terminal as a web-page

🧵conversation

I am trying to program on my Android tablet
with stylus and mostly on-screen-keyboard well mostly
first I used external keyboard to write some basic server in go-lang
I exposed my terminal as a web-page and now I can do way more from my browser https://github.com/uprun/web-console
since then I realized that I was chasing keyboard productivity though when I program I rarely need fast typing
... I am more of a thinker ,,, very slow thinker
.. so yes I decided I can avoid external keyboard and focus on using a stylus input.

📑 Resources

• GitHub - uprun/web-console: expose your terminal as a web-page

linking-together

💬 Jasmine Otto: Coem, a poetic programming language.

🧵conversation

a poetic esolang by Katherine Yang
https://coem-lang.org/about/

Examples of esolangs that have particularly inspired this project are:

• Sukanya Aneja’s in:verse, “a programming language and environment for exploring the conflux of poetry, visuals, mathematics and code”,
• William Hicks’s Esopo, a family of “poetically or literarily interesting esoteric programming languages”, and
• Zeb Burke-Conte’s Shakespeare Programming Language, “designed with the goal of making its source code look like William Shakespeare’s plays”.
  has an online editor as well

📑 Resources

• Coem | About
• in:verse
• GitHub - wphicks/Esopo: Poetic esoteric programming languages
• Shakespeare Programming Language
• online editor

of-ai

💬 wtaysom: GitHub - urug/rubowar

🧵conversation

I have a simple self-contained episode of coding agent programming, I'd like to share with you all. Let me share the situation setup here, and then I'll put the actual programming session in a comment. First an example of what running the problem looks like...

At a local Ruby meetup we played this game Rubowar game https://github.com/urug/rubowar the other night. Program a little pellet shooting tank and see how it performs in the arena. macOS inopportunely forgot that it knew how to use the internet. Weird cascading failure. I had to restart and install an update, so by then I was an hour behind. Luckily, I pulled out my custom coding agent to try some stuff. Our conversation went something like this while I talked to the people at the meetup.

Me: How about you CGP Grey this one for me?

They: After 15 generations...

Me: Only 15.  Be realistic!  Evolution of fourteen parameters is going to take at least 1,500.

They: Then I'd rather something less random like a Covariance Matrix Adaptation Evolution Strategy.

Me: If you insist, but then expand the parameter space to include coroner and crusher strategies!

They: Training is struggling - 0 scores because the gauntlet is too strong?

Me: Try a subtler evaluation: how long it survives.

... few minutes later ...

Me: Wait! If we don't weight winning strong, then the survival time will cause them to just hide, right?

The evolved bot did fine. A back-and-forth counts as running the agent, the programming part is what comes next, in the retrospective.

📑 Resources

• GitHub - urug/rubowar

💬 wtaysom

🧵conversation

Feeling the architecture astronaut, "Today, let's work on a system for reviewing the system that tunes the system that monitors the QA system."

share-your-work

💬 guitarvydas: Layered Abstraction - by Paul Tarvydas - Paul’s Substack

🧵conversation

fan-out is necessary for DX
...
I've reached the conclusion that we need to use a programming language/notation that makes it equally easy to use asynchronous message sends and function calls, so that we may choose appropriately. It is not good enough to make function calls convenient, but, to require extra work to enact async message sending.

📑 Resources

• Layered Abstraction - by Paul Tarvydas - Paul’s Substack

thinking-together

💬 Oleksandr Kryvonos

🧵conversation

today I got inspiration boost from my 3.5yo son
we went to a museum and there he saw several airplanes
he liked them a lot and we played some flight simulator
I promised to him that at home I will setup to him similar app on a phone (on my phone)
I searched in Android/Play store for a while and could not find anything appropriate
I wanted arcade flight simulator without any ads or in game purchases
after 30 minutes of search I realized that I already have an arcade flight simulator
an arcade dragon flight game that I made 2 years before he was born
the game is free and has no ads
so we played it and he liked it
and I was like - " I made this and this and that .. I made everything here"
so "how is this relevant to this community?"
---- here is a punch line
yeah graphics are outdated but I crafted it and my son loves it
so this brings a feelings of computing, as a medium for an interactive storytelling
and now i can craft with this new purpose in mind.

-- P.S. I avoid adding link to the game, but you can imagine a lowpoly reinterpretation of Spyro.

💬 ak: 10 PRINT CHR$(205.5+RND(1)); : GOTO 10

🧵conversation

Most beauty per unit code

Share your favorite short programs that have beautiful output.

Any output modality, any programming language, any units.

Recording of output helpful but not required.

I think a program is more beautiful that doesn't generate identical output each time. But that's just my opinion.

My candidate is ~24 lines of LÖVE or equivalent. I'll share it a little later.

I suppose 10print is another candidate.

📑 Resources

• 10 PRINT CHR$(205.5+RND(1)); : GOTO 10

📝 The Blurry Boundaries Between Programming and Direct Use 🎙️ Feeling of Computing 79 • The Computer is a Feeling 🎥 Verbs vs Nouns: The Word Order That Shaped User Interfaces

📢 Hi! I'm in Argentina for 2 months and brought my "travel machine" and forgot to sync some stuff, enjoy the retro/broken/late newsletters until I find time to fix it :)

Our Work

📝 The Blurry Boundaries Between Programming and Direct Use via Joshua Horowitz

🧵 conversation

Here’s my other PLATEAU paper (first was here):

Technical Dimensions of Live Feedback in Programming Systems

While live feedback plays an important role in many interactive programming systems, its design space remains largely unmapped, making it difficult to discuss and build on the wide range of designs explored by past systems. As a first step towards establishing this map, we present six dimensions that can be used to characterize and evaluate live feedback in programming systems: granularity, reactivity, velocity, moldability, bidirectionality, and materiality.

(This is my presentation from LIVE 2024, written up and extended and polished.)

PDF version attached below; I might make an HTML version someday but who knows.

I’d appreciate hearing any feedback, reactions, questions, etc.!

📄 feedback.pdf

💬 Joshua Horowitz

🧵 conversation

🎙️ Feeling of Computing #79 • The Computer is a Feeling by Tim Hwang and Omar Rizwan via Ivan Reese

🧵 conversation

Feeling of Computing by Ivan Reese and Jimmy Miller and sometimes others, episode 79 • The Computer is a Feeling by Tim Hwang and Omar Rizwan

This paper… is not a paper. What is it, other than a paper? Name the medium!

A relatively short list of points generally on the theme of… the Computer is a Feeling.

As Ivan wrote over on the Feeling of Computing website:

This piece makes us question what the computer means in our lives, and how that may have changed over time. Light on specifics and arguably steeped in nostalgic yearning, its series of declarative statements come out more like broadly probing questions. Is the computer feeling possessed only by those who remember the time before the internet? Are computers even required? What does
feeling this feeling
elicit one to do?

Yeah, I have no idea either.

📝 Building Software by Rolling the Dice: A Qualitative Study of Vibe Coding via Yi-Hung Chou

🧵 conversation

Hi everyone! This is my first time sharing my work here, and I’d love any feedback or future research ideas. Please let me know if my work is relevant to this community. I really enjoy seeing all the cool programming tools shared here!

I've been curious about “vibe coding” recently, so I invited some researchers and my friends to watch YouTube videos to study their behaviors. We tried not to assume it’s good or bad, and just want to understand what actually happens in practice. (Some of our co-authors thought it would democratize programming, but some of us, like me, thought it was irresponsible lol.) In our study, we saw that people often deal with long wait times and unpredictable AI behavior, making the process feel a bit like “rolling the dice.” We also noticed a lot of prompt repetition, with some vibe coders, especially those without programming experience, spending nearly 40% of their prompts just rephrasing the same thing with no new information to get the AI to behave as expected. Our work has been accepted to FSE 2026. Below is our preprint. Let me know what you think!

researchgate.net/publication/399166870_Building_Software_by_Rolling_the_Dice_A_Qualitative_Study_of_Vibe_Coding

Devlog Together

💬 Tom Larkworthy

🧵 conversation

My velocity is increasing quite a lot now, and bugs are much easier to fix. I had a problem that code changes by the inline markdown editor (or by AI) were not picked up by the code editor; its state lagged. I seeded Robocoop context with the change history , inline md editor and code editor notebooks, and asked for a fix, which it one shotted, and now all the editors are in sync by reusing the change-history trick of listening to runtime for code changes.

Architecturally this is very pleasing to me, none of the editors know about each other, they are all triggered from runtime-is-the-source of truth, and thus are radically decoupled and I can add additional methods of code authoring (doesn't have to be text based!) without having to do any plumbing to all the others. Multiple views of the same thing!

🎥 live-editing.mov

Content

🎥 Verbs vs Nouns: The Word Order That Shaped User Interfaces via Orion Reed

🧵 conversation

I am 5 minutes into Verbs vs Nouns: The Word Order That Shaped User Interfaces and enjoying it quite a bit, especially excited that the channel has a dozen videos which seem super high quality with only a few hundred views so I'm excited to have a new source of FoC-adjacent video essays which are sadly very rare.

EDIT: huh the author follows me on Twitter maybe he is in this Slack?

🎥 Verbs vs Nouns: The Word Order That Shaped User Interfaces

📝 Show HN: Blah — a blah-blah programming language via Ivan Reese

🧵 conversation

Hacker News moderator 'dang' put together an index of all the Show HN: Blah — a blah-blah programming language posts and all the The Blah Programming Language posts.

I bet there'd be at least a handful of discoveries to be had by spending an afternoon giving each of them a browse.

📝 corca.app via Mariano Guerra

🧵 conversation

corca.app

People still do math on paper.
We believe there is a better way.

We are building a

fast, intuitive

math editor

📝 Board – The First Ever Face-to-Face Gaming Console via Ivan Reese

🧵 conversation

New tangible computing system: board.fun

📝 Board – The First Ever Face-to-Face Gaming Console

http://Board.fun|Board.fun — the official site for the Board Console. Board fuses the best of board games and video games into something entirely new. A 24” face-to-face gaming console that brings everyone together to play.

📝 A deep dive into ASCII rendering via Kartik Agaram

🧵 conversation

A deep dive into ASCII rendering

Ivan Reese there's a plot twist you'll appreciate by the end, I think.

🤖

📝 Robocoop-2 via Tom Larkworthy

🧵 conversation

I was asked to compare my AI notebook coding assistant Robocoop-2 to Observable Desktop coding assistant and Claude Code. My findings are on the forum.

talk.observablehq.com/t/roboco-op-notebook-coding-assistent/9809/8

👨🏽‍💻 By 🐘 @[email protected] 🐦 @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