🎙️ FoC: Mary Shaw • Myths & Mythconceptions 🥕 Elliot Evans 2023 projects 📑 Malleable Systems Collective 2023 Digest

Our Work

🐸 World’s first full-stack tadi website via Lu Wilson

🧵 conversation

I wrote an overly in-depth write-up of how I built a dashboard.

It was the first time I've tried to build something a bit more ambitious using the new "tadi web" principles that got 💬 #devlog-together@2023-12-20 a few days ago.

📝 Being Stuck in Someone Else’s Theory via Jimmy Miller

🧵 conversation

The perhaps most melodramatic thing I've ever written about software. Sat in my to publish folder for a while. But I realized I am just a bit melodramatic, no one will care :)

Theory creation, world-building, and crafting software are all one in the same activity. Removing any of these elements eliminates the very value you hired software engineers to provide. But it does more than that. It forces these software engineers to make a difficult choice: fight to create the world they believe in, or give up and live in a world they are no longer invested in.

🎙️ Future of Coding • Episode 69 • Mary Shaw • Myths & Mythconceptions via Ivan Reese

🧵 conversation

𒂶 futureofcoding.org/episodes/069

In the spirit of clearly communicating what you're signing up for, this podcast episode is nearly three hours long, and among other things it contains a discussion of a paper by author Mary Shaw titled Myths & Mythconceptions which takes as an organizing principle a collection of myths that are widely believed by programmers, largely unacknowledged, which shape our views on the nature of programming as an activity and the needs of programmers as people and the sort of work that we do as a sort of work , and where by acknowledging these myths the three of us (Mary Shaw primarily, and by extension Jimmy and I, those three people, that's it, no other people appear on this podcast) are able to more vividly grip the image of programming with our mind's eye (or somesuch) and conceive of a different formulation for programming, and in addition to these myths this paper also incudes a number of excellent lists that I take great pleasure in reading, beyond which I should also note that the paper does a job of explaining itself and that hopefully you'll find I've done a similar job, that's the spirit, please enjoy.

Devlog Together

🎠 Building an equation plotter via Kartik Agaram

🧵 conversation

Combining charting with the pinch-zoom gesture

I've written a couple of programs now that have felt too large for this particular devlog, which I've been trying to limit to a size I can comfortably edit on a phone, around 200 lines or so.. 🤔

🎥 carousel plot

🎥 Quicksort with visualization and decorators build using my own visual programming system via Maikel van de Lisdonk

🧵 conversation

In this video I show an implementation of the quicksort algorithm using my visual programming system and not only that, but also the different steps of the output of the algorithm are visualized using a node tree.

One thing I noticed when making these kinds of algorithm flows, that they tend to grow horizontally quickly. So, to help prevent that, I've introduced the concept of "decorators" (they are in the "stacked" nodes). Decorators can be added before or after node-types that support this.

Now at least flows can also grow vertically a bit more. In the future I also want to be able to combine multiple nodes in a component or grouped node.

There are currently only 2 decorator types: expressions and sending data to the node-tree. Editing is not yet possible via the editor itself but only directly in the underlying json data of a flow. Also I needed to improve the way scoped variables work with regard to recursive functions, the same for the "merge"-node-type. Each node receives a scopeId depending on the scope within it is executed (every call to a function creates a new scope, this scopeId is passed to the function-node which passes it through to its connected nodes and so on).

💬 Kartik Agaram

🧵 conversation

💬 Jason Morris

🧵 conversation

Thought about a new architecture for my tool that would make it play better with LLMs, so as to get more help with generating code. Built an MVP version of it over the last week, or so, with just text-based code, and it works well enough that I'm going to have to re-implement my visual language in the new architecture.

Thinking Together

💡 I think programming, software engineering, and computer science are three different things via Stefan Lesser

🧵 conversation

Can we make this a top-level discussion please?

[December 29th, 2023 6:17 AM] jack529: A mythconception that chaps my bottom: I think programming, software engineering, and computer science are three different things, but people insist on using the terms interchangeably. :disappointed:

I’m not so much interested in what the “correct” way of distinguishing those three is, more in how people distinguish them, in their idiosyncratic ways.

So what do you think makes ~programming~ different from ~software engineering~ different from ~computer science~ ?

Content

🥕 Elliot Evans 2023 projects via Mariano Guerra

🧵 conversation

• Polytope is a rich and composable experimental code editor that combines text and visual coding; structured and unstructured (I call this mixture "ummm-structured") representations of code; and symbolic and direct manipulation of code.
• Caretope: I began working on adapting text editor caret navigation to visual editors in 2022 as a part of Polytope. I slowly realized that caret navigation is a rich topic in and of itself so I seperated it into its own project: Caretope!
• Made a small experimental bidirectional programming language
• Made bidirectional parser combinators which were used for the bidirectional programming language
• Ended the year working on a bidirectional+recursion library.
• I'm currently using it to make some interactive recursive visuals. It is inspired by Lu Wilson's ScreenPond and Toby Schachman's Recursive Drawing. Talking with Lu, Ivan, Sharon, Josh, and Marcel has helped me think about this project quite a bit.

• Nudging is about exploring a large space of values by making local movements through that space. Constraints limit large spaces to smaller ones, and change how those spaces are navigated.

• This year I made a bidirectional nudging with constraints demo.

• I also made an equation plotter. This plotter will be used to visualize constraints. It will also add visualization to complement direct manipulation of constraints and values.

📑 Malleable Systems Collective 2023 Digest via Mariano Guerra

🧵 conversation

• Collaborative work on malleable software
• A World Without Apps
• Joyful Creation
• Window management
• Smooth Gradients of Composability, or Old Man Yells At Compilers
• Freewheeling apps
• understandability => malleability
• Tangible Functional Programming
• SUSN: Simple Uniform Semantic Notation
• An interesting quote about the origin of MVC and event handling
• Tiddlywiki
• Thoughts on WebAssembly / Component Model / WASI?
• Empowering users by inverting three key relationships
• What Lies in the Path of the Revolution
• Götz Bachmann’s Ethnographic Research on Dynamicland
• Fengari
• Beyond Web 2.0 and the Browser?
• UXN and Varvara
• Mu: designing a safe computing stack from the ground up
• The future of software, the end of apps, and why UX designers should care about type theory

🖨️ A Core Calculus for Documents. Or, Lambda: The Ultimate Document via Mariano Guerra

🧵 conversation

There are no theoretical tools for reasoning about the design of a document language. Programming language theorists can use the lambda calculus to reason about the design of general-purpose programming languages. No such formal model exists for document languages.

Our work addresses this issue by providing a document calculus , or a formal model of the programmatic aspects of document languages.

🛸 Retrofuturistic software systems 👓 Touch Designer 📘 The Architecture of Open Source Applications

Two Minute Week

🎥 Datalog notebook via Peter Saxton

🧵 conversation

I built a datalog notebook. I want to try and tie this to some public data sources and see how end user friendly it is as an interface

Our Work

📝 Apps considered harmful via Duncan Cragg

🧵 conversation

"Apps considered harmful"

(or "I can't believe how you all tolerate apps")

My latest: Apps considered harmful

📝 LLVM IR: Playing around with LLVM IR via FreeMasen

🧵 conversation

Wrote up a little post about learning LLVM's Intermediate Representation

🎠 The Lua Carousel "productivity suite" via Kartik Agaram

🧵 conversation

4 primitives that can be composed into little productivity apps for yourself, particularly on a phone or tablet.

I think the next major piece I'm missing is images 🤔

🎥 A tool to augment creative problem-solving. via Vardnan Sivarajah

🧵 conversation

Hey everyone! 👋 I’m a student who’s been working on a side project to explore how LLMs may augment creative problem solving.

I’ve synthesised everything into a rough concept I would love to hear your perspectives on:

~Here is a quick demo:~ A tool to augment creative problem-solving.

Initial inspirations include Jef Raskin’s “Archy”, Mozilla’s old “Ubiquity” project, the thinking of Vannevar Bush, and recent tools like “mymind”. There are still many ideas and user experience concerns to be properly fleshed out, but hopefully it’s an interesting direction.

🌳 Grapher via Nilesh Trivedi

🧵 conversation

I had helped build this tool to create civilizational tech trees so that resources (like talent and funds) can be directed where they are most impactful.

Foresight institute has used it to map the tech tree in 5 domains: Intelligent Cooperation, Spacetech, Neurotech, Molecular Machines, and Longevity: foresight.org/tech-tree

SVG-based interactive graph dataset editor with live real-time collaboration. Powers Foresight Institute's civilizational tech trees: https://foresight.org/tech-tree/ and http://LearnAwesome.org|LearnAwesome.org's learning roadmaps: https://learnawesome.org/#/roadmaps

Devlog Together

🎠 New version after 9 days via Kartik Agaram

🧵 conversation

I built a little voice recorder in Lua Carousel last night

One little detail here involves Android permissions. I almost ended up asking for microphone permissions in Lua Carousel. Luckily I managed to stop and ask myself what the user experience is. "Hi, I'm Lua Carousel, could I please have access to your mic?" Ick! It seems like a bad idea to ask for a permission for the whole app just in case some single script uses it. Probably affects the conversions from this particular blog post, but I don't want to feel like I'm contributing to the general fatigue over apps asking for permissions. 🤷

💬 Paul Tarvydas

🧵 conversation

aside: The whole issue of passwords and permissions is a huge UX issue that deserves a long discussion on of-end-user-programming. Users should be allowed to just use a device without being forced to answer a bunch of questions about technical issues and needing to keep a bowl full of anti-anxiety meds nearby. Imagine if my refrigerator required me to perform some ritual before allowing me to put my recently-bought lettuce into the crisper.

💡 TadiWeb via Ivan Reese

🧵 conversation

I've been enjoying the "tadi web" approach Lu has been espousing lately. I also had some nice discussions at Strange Loop with Devine and a few others about minimizing friction / dependencies / build steps, both broadly but also specifically pertaining to publishing one's personal site. So in this spirit, I've been reworking my personal site a bit. I plan to finally add RSS and, even though it goes against the spirit of Lu and Devine's approaches, add a more complex build process that enables some functionality I've long wanted.

💬 Kartik Agaram

🧵 conversation

Starting to get back into the reason I got roped into developing for mobile in the first place: my friend is a doctor trying to use his iPad to analyze datasets like this plot of Covid concentrations in waste water in two random testing stations over 2 months.

💬 Kartik Agaram

🧵 conversation

I've been figuring out some improvements to the live programming environment for my apps. Some little videos in 🧵

🎠 One finger to pan, two fingers to zoom via Kartik Agaram

🧵 conversation

Pan and zoom gestures on a multitouch screen

Thinking Together

💬 Kartik Agaram

🧵 conversation

A large codebase is a realm ruled by the iron fist of legalism. In addition, it is a patchwork of many different jurisdictions, each with their own overlapping but subtly different laws. And it's incredibly easy to spawn a new jurisdiction!

Content

🛸 The Medley Interlisp Project via Mariano Guerra

🧵 conversation

The Medley Interlisp Project: interlisp.org

a retrofuturistic software system

What did we leave behind on the path to developing today's computer systems? Could there be lessons for the future of computing hidden in the past? Enter the Medley software environment to explore these questions.

📝 Designing a Programming Language to Speedrun Advent of Code via Nilesh Trivedi

🧵 conversation

github.com/betaveros/noulith

background: blog.vero.site/post/noulith

🎥 Redeeming Open Source with ABE - Sid Kasivajhula, feat. Michael Ballantyne - RacketCon 2023 via Kartik Agaram

🧵 conversation

This looks tantalizing for the economic angle in particular: Redeeming Open Source with ABE

The repo for that is github.com/drym-org/dia ~, but sadly there's no documentation yet~ github.com/drym-org/foundation. If anybody has more details or pointers please chime in.

(Thanks Konrad Hinsen.)

Present Company

🕹️ Mobile Suit Baba via Ivan Reese

🧵 conversation

Free (for the moment) game from the maker of Baba Is You, in which Baba pilots a mech suit (a la Into The Breach)

📘 The Architecture of Open Source Applications via Daniel Buckmaster

🧵 conversation

I was exploring a domain outside programming today and thought "gee, I wonder if somebody has written a detailed end-to-end case study about this?' Then, I wondered, "gee, has anybody written a detailed end-to-end case study about a software project?"

I always think of software as a very open and sharing community, where we talk about our work and learn from each other without too much secrecy. But I struggled to think of examples. Of course, we seem to be constantly publishing tiny, focused case studies as blog posts. And this is incredible and valuable. But my curiosity is now piqued about this other thing.

AOSA comes to mind, but what comes to others' minds?

👓 TouchDesigner: a visual development platform via Eli Mellen

🧵 conversation

Today I learned about TouchDesigner

Derivative is a software company that offers TouchDesigner, a visual development platform.

💻 The Future of Cloud Computing 🚰 The life and times of Yahoo Pipes 🐸 CellPond: Spatial programming without escape

Our Work

👓 LookAtThat: Render source code in 3D, for macOS and iOS. via Ivan Lugo

🧵 conversation

Hey all! All abuzz that I’ve finally pushed the alpha version up of my Metal-based 3D code visualizer apps. After many months, I’ve finally gotten in my place:

• A brand new and extremely amateurish Metal rendering “engine” focused primarily on character glyphs.
• An, “is this a joke?” UTF8->UTF32->UnicodeGraphemeCluster GPU based text parser and basic layout engine.
• Download GitHub repositories in-app and view arbitrary textual files.
• Reset your atlas if you stumble into new languages online 🤓

If you’ve got an iPhone, iPad, or Mac device, I’d be happy to invite ya to the TestFlight to give the app a whirl where you’d like. Desktop builds and releases coming upon next coffee intake ritual.

📝 Shader Park is Kinda Neat - Untested via Rafał Pastuszak

🧵 conversation

I wrote a quick intro to Shader Park (a JS-like DSL for programming shaders) which gained some traction on similar forums:

📝 Shader Park is Kinda Neat - Untested

💻 The Unison™ Cloud Platform | Say hello to the future of cloud computing via Stew O'Connor

🧵 conversation

I've been working for Unison for the last three years. I got hired start and head up the Unison Cloud project, which today we are starting to open up to early adopters: unison.cloud The idea is that we want to make it as easy as possible to go from some function from HttpRequest -> HttpServer to a deployed service, but we also want to give a rich and modern distributed programming interface to that function. Hit me up if you want to get access to the Beta!

Say hello to the future of cloud computing. Deploy with a function call. Call services as easily as local functions, verified by the typechecker. Access typed storage as easily as in-memory data structures.

🏕️ Local-first software: You own your data, in spite of the cloud via Anton Podviaznikov

🧵 conversation

I'm currently working on a set of simple tools to make data from the apple products available on the traditional web.

• montaigne.io - create website from apple notes
• public.photos - publish photos online from apple photos. a bit on pause
• kiwi.page - publish apple notes online. a bit on pause too

There are few interesting moments here for me:

• liberate data from apple products
• explore idea of local first software but in a different way. what is cool with this approach that data lives locally on your devices and then I just sync it to the web where it can be viewed and used by everyone

It's not super challenging programming wise, but interesting to think about in terms of how software can be written

Devlog Together

🎠 Lua Carousel via Kartik Agaram

🧵 conversation

💬 #share-your-work@2023-11-23 is starting to contribute to Rectangle World

Pushing objects around in a dozen lines of code

🎥 aabb collision

📝 Handling cascading collisions via Kartik Agaram

🧵 conversation

🎥 slide

🧮 App for drilling addition problems via Kartik Agaram

🧵 conversation

Yesterday I turned a couple of my unused kids apps into just scripts you could run on Lua Carousel.

git.sr.ht/~akkartik/sum-grid.love

git.sr.ht/~akkartik/spell-cards.love (exercising my phone's microphone for the first time)

Both qualified successes. I didn't uncover any bugs, but the programs were 250 and 350 lines long, which starts to feel too long for my implementation of scrollbars.

🎥 Advent of Code 2023 day 5 part1 using visual programming via Maikel van de Lisdonk

🧵 conversation

I heard that day-5 part two was a curveball, so I really want to be able to implement it using my visual programming system... which failed so far. Using a brute force solution would mean that the program would run very very long. And my current "speed run" solution wouldn't suffice for this.

Part one actually provided a big challenge for my vps as well, running the program with the small test dataset can be seen in the video: youtu.be/td0QeePvfGQ . I've spend a lot of time adding more new node-types this weekend (like handling a while-loop and improved array handling) and making changes to the variable-nodes and expressions. Also the variable scoping (needed for local function variables) that I implemented had some flaws, so I fixed that as well. You can now define global and scoped variables. I've also made some simple variable visualizers that better show the data for data types like dictionary/array and grid.

My current vps solution works better than the flow-based vps that I was building last year. A big difference is that the data that is send from node to node is now just a single value. That value can still be of different types (number, string, array).. and special variable-nodes are needed to keep track of data. These variables also have a type like number, string, array, dictionary, grid. Often working with a single value is not enough and that's why these variables are needed. They can be referenced from within expressions. Also being able to run some flow-parts in parallel or sequentially helps a lot. This starts to feel much more like a regular 3rd gen programming language.

The UI is currently quite limited.. to be able to create a flow program efficiently it definitely needs a lot of work. Textual programming is much faster. I want to finish at least one of the advent of code puzzles where a grid is involved .. so today's puzzle (17) seems like a good fit. I'll probably work on that next weekend.

🧬 Re: Conway's game of life via Kartik Agaram

🧵 conversation

One nice reusable abstraction my LÖVE apps have all converged on is an immediate-mode button primitive. I draw all my buttons each frame along with all the callbacks they need, and a couple of framework-y lines of code in the mouse-press callback is all it takes to get them working. Last night I realized (while poking inside Re: Conway's game of life) that my hacky sliders in Lua Carousel's settings admit a similar abstraction (even better than the one there). The only additional complexity is it needs a couple more lines in the update callback that continually refresh the backing value as you drag the slider.

💬 Jimmy Miller

🧵 conversation

Finally starting to see a workflow come together in my editor. Here you can see Fibonacci at three different levels in the language I'm making. These functions live in three different files. Looking at them at once and comparing them isn't easily supported in any other editor I use. On the left is a simplistic symbol browser.

I'm super excited that I'm slowly getting to the point where I can do these kinds of things. Having different views of our codebases that we can switch between is something I've been wanting for years.

Thinking Together

💬 Prabhanshu Gupta

🧵 conversation

I'm making a system for working with loosely structured tables in spreadsheets. Tables/lists in sheets represent collections of things, however formulas and drag-filling works at an item-level (cell-level) abstraction. This causes a lot of problems – duplicated effort, hard to do lookups across tables, errors when new data is added. However, committing to a structure upfront (a SQL style table for example) has a big cost. An effective system would allow users to gradually introduce structure that works with whatever rich table they draw.

Right now I'm onto a language for pulling data from such rich tables. It works by manipulation of the ranges (rectangles) pointed to by Labels. Queries can be made by intersecting/unioning rectangles (in picture is a small example). What ideas/projects would you recommend looking at in this space? I've looked around a fair bit for "2D grammar" and "spatial programming language" but haven't had much luck.

💬 Ivan Reese

🧵 conversation

In linguistics, we have "denotation" and "connotation" as two forms of meaning. In programming, we have denotational semantics and operational semantics. Do we have connotational semantics? (If not — may we?)

Content

🚰 lovely tribute to Yahoo Pipes via Ivan Reese

🧵 conversation

A lovely tribute to Yahoo Pipes written by the inimitable Glenn Fleishman appeared on the Retool site today.

Every Pipes’ mapping was public; every Pipe could be copied and modified. “That was design principle one for us, and I think that had a lot to do with making it accessible to non-developers,” Sadri said. This openness that encouraged—really, required—knowledge-sharing embodied some of the internet’s best qualities that were on the verge of being lost at that time.

📝 The subjective experience of coding in different programming languages via Jimmy Miller

🧵 conversation

Different programming languages feel viscerally different, right? I can’t be the only one. It’s so embodied.

When I’m deep in multiple nested parentheses in a C-like language, even Python, I feel precarious, like I’m walking a high wire or balancing things in my hands and picking my way down steep stairs. It’s a relief to close the braces.

🐸 CellPond: Spatial programming without escape via Mattia Fregola

🧵 conversation

As a Cellular Automata and design tools aficionado I loved this whole thing from Lu Wilson .

(saw some shared essence with Apparatus and Netlogo)

📝 ln.hixie.ch/?start=1700627373&count=1 via Andreas S

🧵 conversation

Hello 🙋‍♂️ future of coding.

I came across this some time ago but I still think it’s worthwhile sharing,

It showed for me how one the one hand the ethical decline of google went from “don’t be evil- to… what ever it is today that’s their guiding principle. But also more importantly how a change in company culture also reflected on technical innovation.

Present Company

💬 Nilesh Trivedi

🧵 conversation

Today, is there a way to build state-driven UI components (like React/Vue/Svelte) where some of the state, but not all, can be persisted periodically in the backend perhaps as an event log which would enable things like playback of past interactions? How would you go about creating something like this with usual tools like Javascript, REST and Postgresql? 🤔

🤖 Visual exploration of inference in a LLM 📑 Functional Reactive Programming Resources 🗨️ Conversational UI for Interactive Components

Two Minute Week

🎥 Add and Use Union Kit via Dany

🧵 conversation

This week I'd like to show how a new union type is added to miqula. See description under video. (no audio)

Our Work

🎥 Motion Extraction via Chigozie Nri

🧵 conversation

I really liked Posy's latest video so I just put a version of the motion extractor on replicate: replicate.com/chigozienri/posy-motion-extraction

📝 chigozienri/posy-motion-extraction – Replicate

Extracts motion from video

🎥 birds

🗨️ Gloodata: An Extensible Conversational UI for Interactive Components via Mariano Guerra

🧵 conversation

First public release of Gloodata: An Extensible Conversational UI for Interactive Components

Builds for Linux (x64) and Mac (Apple Silicon) here: gloodata.com/download

Overview: youtube.com/watch?v=f-txlMDLfng

Let me know what you think!

🐦 Chigozie Nri (@chigozienri) on X via Chigozie Nri

🧵 conversation

🐦 Chigozie Nri (@chigozienri) on X: These boids are very rude

🎥 Parabola

📝 The Wizardry Frontier — Sympolymathesy, by Chris Krycho via Chris Krycho

🧵 conversation

Writing a bit about moving the state of the art—this piece itself isn’t doing it, but I kind of hope this framing is useful for people who are trying to do it.

For 75 years, programming languages have steadily raised the baseline of what “normal” programmers can express in their languages. They can still.

Devlog Together

💻 bugfix: only check for settings menu when open via Kartik Agaram

🧵 conversation

This bug I foisted on myself today was a real "things are not as they appear" puzzle.

🗓️ qemu-advent-calendar.org/2023 via Kartik Agaram

🧵 conversation

So Mu was on the advent of Qemu calendar yesterday, and I totally missed it.

💬 Kartik Agaram

🧵 conversation

🎥 Kinopio To Markdown via Paul Tarvydas

🧵 conversation

Status video about Kinopio2md (Kinopio to Markdown). What is not said is that the blue boxes are source code for the app (the compiler compiles the drawings to executable code). I deal with a bunch of different programming languages, picking the best one for each step along the way (approximately 10, if you include English). I want to document more deeply the use of the Transpiler in, say, the “Escape Whitespace” Component (and others), but, I haven’t gotten around to it yet

🫶 Playing with LÖVE's physics engine for the first time via Kartik Agaram

🧵 conversation

I've been making a little program every evening with my new toy. Today:

akkartik.itch.io/carousel/devlog/647726/playing-with-lves-physics-for-the-first-time

🎥 Physics Game

🎥 Advent of code day 7 implemented in my visual programming system via Maikel van de Lisdonk

🧵 conversation

Oh boy.. it was a lot of work being able to solve advent of code puzzle 7 (part 1) in my visual programming system.. as you can see in the video youtu.be/kkgJQdJXFtk. I had to implement a lot new node-types for handling dictionaries and a new scoped-variable type. This scoped-variable can have different types.. currently just a regular value or a dictionary. This dictionary is used in a function-flow to determine the hand type which is needed in this puzzle. Also custom sorting was needed (I implemented a Schwartzian transform in the sort node-type). Running the flow for the full puzzle input takes a long time so I don't show that in the video (although I've added a "full-speed" mode that helps a bit). I've also added some colors to better show when some nodes are active, especially handy for nodes that run longer like a foreach, function-call, map or sort.

Thinking Together

📝 Code layout for programming via Paul Tarvydas

🧵 conversation

I believe that VPLs are better than TPLs. I include some observations that led me to that conclusion. meta: I choose to believe that this channel “thinking together” means that half-baked ideas are to be tossed out for brainstorming, pushback, discussion and revision. guitarvydas.github.io/2023/12/04/Code-Layout-for-Programming.html (discussion of 1D, 2D, 3D, 4D program syntax)

Content

🤖 bbycroft.net/llm via Mattia Fregola

🧵 conversation

Pretty awesome visual exploration of inference in a LLM

💻 VSCode LLVM Compiler Explorer via Shubhadeep Roychowdhury

🧵 conversation

This is a tool for compiler developers of LLVM. This vscode extension can support exploring LLVM IR and machine IR after each pass

📑 Functional Reactive Programming Resources via Alex McLean

🧵 conversation

List of Functional Reactive Programming resources:

A chronological collection of academic resources on the practice of functional reactive programming. Great care has been taken to respect copyrights - no files are directly hosted and...

💬 Kartik Agaram

🧵 conversation

This is absolutely fascinating. Tally marks are a little visual language that has coevolved with the textual context.

I don't have a link, but links appreciated.

🤖

💬 Nilesh Trivedi

🧵 conversation

What if web frameworks offered a standard way to discover capabilities that are then given to AI as tools? A document.getTools() perhaps?

This could be achieved simply with plugins for NextJS, VueJS, SvelteKit etc. Small convention that eliminates a lot of brittleness when web agents try to discover capabilities and invoke them.

👓 VR visual/spatial programming 👁️‍🗨️ Explore, collect & play with live visual programs 🗓️ Adventual activities

Two Minute Week

🎥 Enter a Subnet via Dany

🧵 conversation

Last week I worked on entering a subnet, this is used for condition, match, filter, map etc.. See description under video. (no audio)

Our Work

📝 Recursive grammar literals via Jason Priestley

🧵 conversation

Hi all, I've been inactive here for a long time. Progress on my big project, a collaborative mobile-friendly development environment, has been very slow. However, along the way I've built some libraries which may be of interest to some people here.

On the languages and parsing side, I've built recursive grammar literals which lets you write CFGs as normal javascript functions. And church-cat which lets you compute over a tree structure, e.g. annotate a parse tree.

On the UI side I've built imperative which is a frontend javascript library much like React, but based on generators and structured concurrency. And most recently I've been working on Palimpsest which covers the backend of web development with a more functional or "event-sourced" style where data sources are computed as folds over input streams. My interest there is to allow stateful applications to be more easily shared, forked, and extended by their users etc.

🎥 Statecharts papers we love video via Paul Tarvydas

🧵 conversation

Statecharts - my reading of Harel’s original paper in video format (26 minutes) . (In case it’s not obvious, IMO it’s worth knowing about Statecharts, even if you believe that VPLs are a dead end).

📑 wigwam.directory: curated list of small-but-mighty projects via Taylor Troesh

🧵 conversation

Howdy friends! I recently published the beginnings of a new project: wigwam.directory

I'm looking for projects that reduce public reliance on bloated/crumbling infrastructure. Any suggestions?

🌱 The sustainability doughnut of scientific software via Konrad Hinsen

🧵 conversation

I have written a short essay on software sustainability, and I'd love feedback from this community:

The sustainability doughnut of scientific software

It's written in the specific context of computational science, but it readily translates to other application domains.

🎥 Plato Demo Video by Michael Gummelt

🧵 conversation

We just published a new demo of Plato's PBD subsystem. Much more powerful than our previous implementation.

PBD is historically difficult to generalize and make practical, but it seems that once you take it out of the desktop metaphor and apply it to relational data where queries are more explicit, it does quite well.

I suspect this could become the most prevalent way of automating app logic without coding.

🎥 Plato Demo Video

👓🎥 Pebble Graphics Trailer via Irvin Hwang

🧵 conversation

Hi All

I’m almost “done” with my VR visual/spatial programming app, Pebble Graphics 🎉 (“done” because I still see a lot of things that could be improved, but there are other projects I’m excited to start so I’m shipping what I have). It’s a VR version of turtle graphics with some interactive program stepping and 3D visualizations of things like state change and execution history.

I made a trailer you can watch (and listen to 🎶) here Pebble Graphics Trailer. If you have a Quest headset and want to try it out, I set up a Beta release while I try to get it into Meta’s App Lab app store. This link meta.com/s/2Rlda8ess should work otherwise feel free to DM me the email address associated with your Oculus/Meta account.

I also have some time-stamped/annotated videos later on in this Youtube Playlist in case you want to see more.

I’m more of a lurker in this slack, but it’s a community I enjoy checking on and it’s really cool to see it grow!

Pebble Graphics is a 3D visual and interactive programming system that lets you create and explore geometric patterns in virtual reality. Using simple commands, you can control Pebbles the dog to draw lines and shapes with programming. You can also step through your programs interactively, and see unique 3D visualizations of how things change over time. Pebble Graphics is a fun and creative way to learn basic ideas in programming.

Devlog Together

📝 Version ao: saving your programs across restarts via Kartik Agaram

🧵 conversation

I released the hopefully final feature last night for my mobile-friendly REPL: file loading and saving.

Version ao: saving your programs across restarts

From here on out I only want to work on UI polish and accessibility. Let's see how long it can stay running without incompatibilities that require upgrades.

This feature was very difficult. Lua Carousel launched without the ability to save to and load from files because I struggled to juggle two constraints: Reliability. I spent a long time trying to make...

👁️‍🗨️🐦 Samuel Timbó (@io_sammt) on X via Samuel Timbó

🧵 conversation

Hi FoC, just posting here some of my latest work in Unit. unit.tools is my current take on how to search for units (live programs) online and collect your own. It is still a prototype, bear with me. unit.tools

🐦 Samuel Timbó (@io_sammt) on X: Officially announcing the second project I am building in public: https://t.co/BsxYrY7UiX

It is a marketplace to explore, collect and play with live visual programs built in Unit.

📝 Version ap: a lot less jittery via Kartik Agaram

🧵 conversation

I'm starting to acquire some respect for small UX niceties like a visual 'clicked' state. It's unnerving to click 'save' and not know for sure that stuff got saved. Particularly on a small mobile screen where it's easy to fat finger things.

No new features, only fixes for bugs. From most to least embarrassing: * If you selected some text and then hit the 'clear' button the app would crash. * Dragging the mouse/finger around on top of the...

📝 Version as: major improvements to the scrollbar via Kartik Agaram

🧵 conversation

More lessons from the school of hard knocks about the value of usability in software: Version as: major improvements to the scrollbar

Taps near the top of the editor sometimes failed to move the cursor. It turns out this was only happening soon after a drag of the scrollbar. Lua Carousel's scrollbar has always felt a little jumpy. I...

🎥 Advent of Code 2023 day 1 using visual programming via Maikel van de Lisdonk

🧵 conversation

Last year I used the advent of code to test the visual programming environment that I was building at that time.. and it helped me to come to the conclusion to start over.. which I did at the beginning of this year. So... the time has come to test my new environment and let advent of code help me improve and extend it. Hopefully this year I won't need to decide to start over😅. To finish the first challenge I needed to extend my vps with new node types or tweak some other stuff like be able to execute regex expressions and load external files as input to a flow. For the second part of day 1 a special node needed to be created to handle the sneaky replace string functionality that was needed. A very nice update that I made is the possibility to run parts of flow in parallel instead of sequential and use the results in the upstream nodes.

And talking about upstream nodes... since last week it's also possible to drag all upstream or downstream nodes at once when reorganizing a flow using UI elements(it can be seen in the video).

In the flow-engine I also use standalone nodes that represent global variables which can be used in other nodes.

I'll definitely not make it to the AoC leaderboard (it's not a goal anyway).. however.. I think I am getting a lot of value out of this already..even on day 1.

💬 Jimmy Miller

🧵 conversation

Been making slow, but steady progress on my editor. I can properly zoom in and out on the canvas. I can have some panes that represent sub-file things. The power usage when idle is basically non-existent (down from 100% cpu usage always). I finally feel like things are starting to come together and that I can finish up some parts and then really start focusing on actually making the flow and features fit how I code.

Hopefully soon I can start using it for a project that isn't coding itself so I am forced to add all the features I've been ignoring.

🎥 Devlog

Thinking Together

💬 Mariano Guerra

🧵 conversation

Where's the emacs people in this text centric brave new world?

Context: the most interesting stuff done on text always happened on emacs, and it makes sense to use a text centric malleable software platform to experiment by adding LLMs to everything, I haven't seen much done there.

💻 scrapscript.org via Guyren Howe

🧵 conversation

But have y’all seen this? scrapscript.org

This is my kind of thinking.

💬 Nilesh Trivedi

🧵 conversation

Thinking about a modern agent orchestration / business process modeling / workflow language. Here is how the standard BPMN example might look like:

# Tasks are enqueued jobs to specific queues. They emit events like started, success, failure, cancelled as well as custom intermediate events.

# Tasks cannot consume events. Task invoker can cancel those tasks.

# Tasks are triggerred by specific events indicated by their corresponding "when" clause.

# Process is a stateful workflow which orchestrates tasks based on events.



process pizza() do

    x = @customer.select_pizza when $start

    y = @customer.order_pizza(kind: x.kind) when x

    z = @chef.make_pizza(order: y.order) when y



    p = y.order.line_items.map do |item| # array processing

        subprocess procure(item: item) #invoke a subprocess

    end when z

    q = @clerk.pack when p.all?



    w = @delivery_boy.deliver_pizza(to: y.address) when z

    u = @customer.pay_for_pizza when w

    v = @customer.eat_pizza when u

    success $hunger_satisfied when v



    r = @customer.ask_for_pizza when (y or r[-1] + 60.minutes) and w.pending?

    s = @clerk.calm_the_customer when r

end

Present Company

💬 Mariano Guerra

🧵 conversation

hi! tinyletter (the service I use for the FoC newsletter) is closing down, to finish the last stage of going completely self hosted I plan to export the subscriber list, put it in a csv, do a for loop and use some mail api to send it. Also a form somewhere that appends to that csv. But before adopting this webscale architecture ™ I wanted to ask you

if there's any interesting idea to improve the newsletter now that I'm doing the migration .

💼 Spreadsheets & Small Software 🎠 Lua Carousel 🗺️ Embark: Dynamic documents for making plans

Two Minute Week

🎥 Wrap and unwrap expression via U03U0SCU5LH

🧵 conversation

Last week I worked on Wrap / Unwrap Expression. See description under video. (no audio)

Btw. if somebody has a better verb instead of wrap.. let me know.

Our Work

💼 Spreadsheets and Small Software via Prabhanshu Gupta

🧵 conversation

I’ve been researching spreadsheets and writing one for a couple months. I wrote a bit about the what and the why, give it a read!

blog.nilenso.com/blog/2023/11/10/spreadsheets-and-small-software

I wasn’t able to cover many specifics here – writing about the work seems like a lot more work than doing the actual work 😅. There’s a lot to cover and I’m hoping to get to it slowly. Until then please shoot thoughts and questions here, I’d love to answer.

🎥 Arroost: Normalise sharing scrappy fiddles via Lu Wilson

🧵 conversation

Watch my new talk!

It's about a music-making node-based language tool for feeling.

ARROOST: NORMALISE SHARING SCRAPPY FIDDLES

📝 Let's Build a Programming Language via Mike Austin

🧵 conversation

I've demoed my Kopi language and Rect-Desktop projects a few weeks ago. In my experience writing Kopi, I've always wanted to write a "How to Write a Programming Language" tutorial based on it, since the core language is simple and familiar (infix operators, assignment, anonymous functions, etc.). Here's the start of something (written in Markdown, presented using the React-Desktop Markdown app:

Let's Build a Programming Language

It's in an early draft. I like presenting ideas very incrementally, and being able to see and even interact with each small change. You can modify any of input or parser code and see the result value change.

🎠 Lua Carousel via Kartik Agaram

🧵 conversation

Lua Carousel: A lightweight programming environment for desktop and mobile devices that you can make changes to while it's running.

repo: git.sr.ht/~akkartik/carousel.love

🎥 Lua Carousel Demo

💬 Daniel Garcia

🧵 conversation

Followup on my ~_*Colorful types*_~ project. I’m trying to create a ~_*map*_~ for a codebase with different zoom levels.

I have been thinking about having 3 zoom levels:

• Level 1: Only colors for both types & functions
• Level 2: Colors and names for types, functions and parameters
• Level 3: Shows the entire source file (maybe with some extra color sugar on top?)

Here are a couple of screenshots of level 1 & 2, and video of the WIP interface.

PS. Anyone have good recommendations of typescript codebases with a couple dozen source code files which I can use for testing?

🎥 Demo

Devlog Together

💬 Kartik Agaram

🧵 conversation

More progress on a lightweight programming environment that runs on Linux, Windows, Mac, Android, iOS. Also modifiable live while it runs (though not on mobile devices).

The seed design constraint here was to structurally prevent the pop-up keyboard on a touchscreen from ever blocking my typing. That led to this design of a multi-line commandline editor in the top half, fixing the non-editable output buffer in the bottom half. Independent commands/scripts then expanded in the only other direction available: left/right.

🎥 Carousel Shell

💬 Kartik Agaram

🧵 conversation

🎥 Carousel Shell Slider

🗺️ Dispatch 001:On Embark and Lude via Duncan Cragg

🧵 conversation

Hiya, I just read this new newsletter from Ink'n'Switch:

inkandswitch.com/newsletter/dispatch-001

And it says:

Solo independent researchers we know often discuss the challenge of working alone. Being part of a research group can create community, social accountability, provide feedback, and just give you someone to talk to when you’re feeling stuck or bored. This is why we started our Researchers-in-Residence program.

Which made me think "this could be something we set up in FoC!"

And then I came right here to say that, without thinking it through any further...

🎥 Creating html for nodes using gpt4 api in a visual programming system via Maikel van de Lisdonk

🧵 conversation

Hi, in this weeks video I show a new node type in which a prompt can be entered which is used to create HTML via openai gpt4. It's quite powerful .. the created nodes can receive and visualize input data from another node. This is offcourse inspired by makeitreal from tldraw which uses gpt4-vision-preview. I have been playing with the prompt to get the result that I wanted, although the results are not consistent when recreating the html using the same prompt. Still, very cool that this is possible.

💬 Kartik Agaram

🧵 conversation

Achievement unlocked: I've built an app large enough[1] that it crashes my programming environment that puts all the code on a spatial surface.

The problem: I do this snazzy initial animation (see video) that takes in the whole thing before zooming back in somewhere. That animation works by drawing the whole surface to an in-memory canvas before transforming it. Turns out drawing to a canvas still uses the video card, and I don't have enough video RAM for a virtual "monitor" of this resolution.

[1] Or spread out enough. It's not really about lines of code, just how much area the code occupies.

🎥 bf codemap

Reading Together

💬 Beni Cherniavsky-Paskin

🧵 conversation

I was leafing through my father's old books when this diagram caught me off-guard.

We're so used now to having an OS with apps, that it's weird to think of OS-level transitions (login->shell), inter-apps transitions (shell->vi) and inside-app transitions (vi's command<->append modes) as similar things. 🙃

But to a user new to computers, yes these are all "modes".

💬 Janne Aukia

🧵 conversation

I think that often the most difficult part of programming is debugging: humans aren't very good at "seeing" how an app operated when it failed. You get some log output that might or might not have references to the correct file locations.

I don't see any reason, in the long term, why humans would be better than machines at debugging. How to make that happen? I assume somebody is building this already. Would it help if an AI with a large context window + access to the VM could see the whole call logs/tree and see exactly what is going on? AI could learn from other users, see everything that happens in a run without debugger/console.logs, try multiple solutions in parallel, and fix issues while you sleep.

Thoughts on this?

Content

📝 Spreadsheets and Small Software - nilenso blog via Benji York

🧵 conversation

"We wanted tools to make sheds, we got tools to make skyscrapers."

🗺️ Embark — Dynamic documents for making plans via Ivan Reese

🧵 conversation

Ink & Switch just released a new essay: Embark — Dynamic documents for making plans.

Starting from a desire to "unbundle the app" in the name of malleable software, they explore using a bullet-point outliner as a substrate for dynamic properties, computations, and views. They ground the work with a specific use case — trip planning — and they hard-code a bunch of stuff that ought to be pushed into user space, granted. But it's easy to look at this, imagine how it could be expanded, and see some really compelling possibilities for a different way to approach creating and distributing software.

Congrats to Paul Sonnentag, @Alexander Obenauer, and Geoffrey Litt!

💻 Pickcode | Make cool stuff with code via Mattia Fregola

🧵 conversation

Pickcode – a visual language to teach kids to code.

🧶 There are no strings on me via Justin Blank

🧵 conversation

An essay on the challenges of image based/live systems: There are no strings on me

📝 Lua Carousel: create little programs on desktop or mobile devices via Walker Griggs

🧵 conversation

A saw a friendly face on the front page of lobsters this morning

🎥 Bootstrap yourself into conviviality by writing your own Forth via Kartik Agaram

🧵 conversation

I just found an absolutely ancient bit of advocacy for convivial tools. From 2008!

via muforth.nimblemachines.com

Jonathan Edwards Were y'all aware of this when you organized 2020.programming-conference.org/home/salon-2020?

🎙️ FoC 68 Philip Wadler: Propositions as Types 🧠 Neurosymbolic Programming 🐟 The Object Network for goldfish

Our Work

🎥 New Jersey Cards via Mariano Guerra

🧵 conversation

🗂 New Jersey Cards: Worse Cards are Better

Simple textual format to keep practice notes.

📝 Capture & practice content in Markdown-ish

• Question -> Answer & Optional Notes

🎼 Extensions to display guitar chords and music scores with ASCII-art

📟 Runs on anything that can serve static files

💻 github.com/marianoguerra/nj-cards

📝 The Object Network for goldfish via Duncan Cragg

🧵 conversation

Hiya - my latest article - "The Object Network for goldfish" - is out!

I tried to simplify the message down to the bare minimum. Let me know if that works for you! You may have to be a goldfish to understand it, mind.

An OS with no apps frees our data from the "app trap"

🎙️ FoC 68 Philip Wadler: Propositions as Types via Ivan Reese

🧵 conversation

The subject of this episode’s paper — Propositions as Types by Philip Wadler — is one of those grand ideas that makes you want to go stargazing. To stare out into space and just disassociate from your body and become one with the heavens. Everything — life, space, time, existence — all of it is a joke! A cosmic ribbing delivered by the laws of the universe or some higher power or, perhaps, higher order. Humanity waited two thousand years, from the time of the ancient Greeks through until the 1930s, for a means to answer questions of calculability, when three suddenly arrived all at once:

• General recursive functions by Gödel in 1934, with functions of sets of natural numbers.
• Lambda calculus by Alonzo Church in 1936, with anonymous single-variable functions.
• Turing machines by Alan Turing in 1937, with a process for evaluating symbols on a tape.

Then it was discovered that these three models of computation were, in fact, perfectly equivalent. That any statement made in one could be made in the others. A striking coincidence, sure, but not without precedent. But then it was quietly determined (in 1934, again in 1969, and finally published in 1980) that computation itself is in a direct correspondence with logic. That every proposition in a given logic corresponds with a type in a given programming language, every proof corresponds with a program, and the simplification of the proof corresponds with the evaluation of the program.

The implications boggle the mind. How could this be so? Well, how could it be any other way? Why did it take so long to discover? What other discoveries like this are perched on the precipice of revelation?

Philip Wadler is here to walk us through this bit of history, suggest answers to some of these questions, and point us in a direction to search for more.

And we are here, dear listener, to level with you that a lot of this stuff is miserably hard to approach, presented with the symbols and language of formal logic that is so often inscrutable to outsiders. By walking you through Wadler’s paper (and the much more approachable Strange Loop talk), and tying it in with the cultural context of modern functional programming, we hope you’ll gain an appreciation for this remarkable, divine pun that sits beneath all of computation.

Devlog Together

💻 MiniIDE: live code inside a LOVE app via Kartik Agaram

🧵 conversation

I seem to have renewed my collaboration for a tablet-friendly programming environment. For the current version, my partner led and pushed for preserving LÖVE primitives. For example, the LÖVE event loop calls functions you define called love.draw , love.keypressed , etc., and it seems desirable to continue to support those for familiarity's sake. This can seem impossible if the environment is also built in LÖVE and uses those same functions for providing its infrastructure, but since Lua is a dynamic environment there are tricks to make it work reasonably nicely.

Lately I've been taking the lead on a riff of that project, and I find I'm advocating strongly to not do this. I want to define new handlers like shell.draw and shell.keypressed that programs within my environment will have to call. And I finally figured out why I feel so strongly about this:

• LÖVE has a function to return the bounds of the device/window. You typically can draw between x coordinates 0 and some width. And this information is often used to draw UI elements near the edges and corners. So should we now override functions like line to adjust coordinates and keep them in the client area? There's a lot of surface area to cover here. Bugs will inevitably happen, and when they do our attempts to create a seamless abstraction will cause more confusion.
• Ranting more broadly, the desire for a "seamless experience" is a disease. The provider wants to "own the customer relationship," so that the user can forget there's anything in the universe but themselves and the app. Just like a casino. I'd rather not pretend we can wish the universe away with its possibility of errors. Let's me and the user treat each other as grown-ups, and not hide irreducible complexity in our supply chains. Here are the functions I provide, here are the functions LÖVE provides. I recommend you use my stuff where possible, but you don't have to. Yes, it's confusing. Welcome.

💬 Kartik Agaram

🧵 conversation

Last night I built a little program to help first-graders drill on addition -- and promptly found a bug while recording this 😂 (You can see me show the generated solution at the end. It's wrong!)

(Fear not, this will go through usability/correctness testing with the teacher/mother before the kids are subject to it.)

🎥 Sum Grid Demo

🎥 Creating a basic glsl shader using a pull-based flow via Maikel van de Lisdonk

🧵 conversation

Hi, since I've started building visual programming systems, I have always used a push-based approach where a node triggers another node that follows it. This is much inspired by flow based programming. But since I want to build a generic visual programming system, I think that it is also important to support different ways.. basic statecharts I already support, but a pull-based system is not yet something that I had build with my system. Until now! .. so in this video you can see how I construct a flow that is used to construct a glsl fragment shader. Here the output node pulls in the data from the node's cominh before it in the flow, so working backwards through a flow.

Although it's not my goal to build a full product around this alone.. a lot better and much more extensive applications already exist for building shaders this way. But still helpful to look at my project from a different perspective, which leads to some refactoring, bug fixing, insights and inspiration.

Yesterday I was really in doubt if this was the right route for this week's time spent on my project because of the awesome demo that tldraw made with gpt4-vision api, very cool! So,I also had to play with it together with my own application and was also amazed with the possibilities! Probably my next video will have this as a topic. Anyway, for now, enjoy my short video where I construct a very simple shader which runs on the GPU via webgl.

💬 Kartik Agaram

🧵 conversation

I'm finally starting to think about scrollbars.

🎥 Scrollbar Demo

Thinking Together

💬 Gregor

🧵 conversation

Is there a good catalogue of programming languages? Preferably with the option of searching by feature or comparing languages on some dimensions?

📝 Life-critical side projects via Tom Lieber

🧵 conversation

Kartik Agaram It wasn’t on-topic in the thread you started a while back, my but first thought when considering building software like that is “Writing a social media app is frightening” (or more generally, “Storing user data is frightening”), as this post just reminded me: Life-critical side projects

💬 Tom Lieber

🧵 conversation

I built a Magic Inky interface at work a while back. A metadata editor that presented as a nested bulleted list of English sentences with clickable words, like:

“From [time T1] to [time T2], an [event type] happens with [property P], and it’s very [adjective].”

The event descriptions are highly multi-dimensional and resonate well with this information design, though the timestamps suffer a bit. They want to be on a timeline, but I didn’t have the budget. Despite this, the UI has saved us loads of time and people ~love~ the sentence-based configuration compared to the forty-column table of dropdowns they envisioned when I started the project.

The biggest failure was that enforcing a few global constraints was ~also~ outside my budget. Lacking those has led to data loss—never more than a few minute’s worth, but still. I felt bad. Thankfully, someone else recently picked up the project and will be correcting those omissions.

But we disagreed immediately on how to do it! I thought we should ~present~ the errors: “These events overlap!” The other person thought we should make the errors impossible: when you edit a timestamp, you implicitly edit all the others that are involved in the constraint.

I generally agree with their approach. I mean, it’s baked into the rest of the UI. When you change an event type, it changes the rest of the sentence. But if you change the type back, the sentence structure is restored and your previous values all come back. Cascading edits are more destructive than that. They force you to be careful about what you change and to be observant of unintended side-effects.

The block editor problem of representing invalid states is another way to look at it. Sometimes the most efficient path between two valid states passes through an invalid one. If you want to reorder two events, for example, a first step might be to copy the start and end times from one to the other, as part of an “a = b; b = oldA” sequence. They overlap until you’re done. To do the same without ever breaking global constraints requires user ingenuity or a more featureful editor with a “swap events” button. Requiring user ingenuity wastes a lot of time and energy and happiness over the lifetime of the UI, but observing users and adding features to address every desired editing operation takes a lot of dev time too, and it has to happen ~now~ , or else people editing this data will be blocked whenever they find an impossible edit.

Anyway, not too many answers here, but I thought it was an interesting case study, with thought-provoking ~questions~ at least!

🐦 Tweet from @mrmkrs via Scott

🧵 conversation

An idea is starting to form for me around prototype-based modeling being a good metaphor for programming effectively with LLMs. Essentially you can provide an example of a patttern/component/class/etc and have it return a version of it modified in specific ways, which can then be used as a prototype for future generations/instantiations.

A version of this idea can be seen here with tldraw where he generates the next more specific interface step off the previous one.

Another I'm kind of using this in my agent framework: generate_sublayer_agent_agent.rb where we generate new agents based off a simple agent template (and works surprisingly well).

I know Hofstatder digs into this concept in GEB and Steve Yegge calls it the Universal Design Pattern

Does this resonate with anyone here? Is anyone familiar with any other writing about prototype-based modeling/prototypal inheritance/etc for me to take this further?

Content

📝 I’m excited to see where this 3rd party screen-reader for macOS goes. via Eli Mellen

🧵 conversation

I’m excited to see where this 3rd party screen-reader for macOS goes. On windows there are 2 first-in-class options available outside of the OS, JAWS and NVDA. On macOS there is only the system provided VoiceOver.

I think VoiceOver is a pretty solid competitor to NVDA, but, it is very very very opinionated, and makes some unusual choices. I think this has a knock on effect where, since VoiceOver is the easiest screen-reader for most web devs to reach for, a lot of implementations end up being hyper-focused on supporting VoiceOver’s specific flavor of handling the accessibility tree. Having more diversity in the space, I think could hopefully mitigate this. While this isn’t directly related to the future of coding as we normally talk about it here, I think projects like this are just the sort of thing that can help to shape things for years to come.

🎥 Editing Motion Graphics Video via Motion Vectorization and Transformation via Jack Rusher

🧵 conversation

Inferring SVG animations from motion graphics videos, then providing various tools to edit the inferred material

🎥 Neurosymbolic Programming - Yisong Yue via Dany

🧵 conversation

This may interest you. It talks about combining programming by example (ML) and traditional means.

📝 Designing a Programming Language to Speedrun Advent of Code via Eli Mellen

🧵 conversation

“shouldn’t this have been published a few months ago?” yeah, probably. I even considered submitting it to the AoC contest. time is a real beast. The title is clickbait. I did not design and implement a programming language for the sole or even primary purpose of leaderboarding on Advent of Code. It just turned out that the programming language I was working on fit the task remarkably well. I can’t name just a single reason I started work on my language, Noulith, back in July 2022, but I think the biggest one was even more absurdly niche: I solve and write a lot of puzzlehunts, and I wanted a better programming language to use to search word lists for words satisfying unusual constraints, such as, “Find all ten-letter words that contain each of the letters A, B, and C exactly once and that have the ninth letter K.”1 I have a folder of ten-line scripts of this kind, mostly Python, and I thought there was surely a better way to do this. Not necessarily faster — there is obviously no way I could save time on net by optimizing this process. But, for example, I wanted to be able to easily share these programs such that others could run them. I had a positive experience in this with my slightly older golflang Paradoc, which I had compiled into a WASM blob and put online and, just once, experienced the convenience of sharing a short text processing program through a link. (Puzzle: what does this program do?) I also wanted to write and run these programs while booted into a different operating system, using a different computer, or just on my phone. ...

🎥 CrystalConf 2023 via Paul Tarvydas

🧵 conversation

practical Diagrams as Syntax for program development at Kagi.com

🤖

💬 Marcelle Rusu (they/them)

🧵 conversation

I don't know much about LLMs, so I'm purely asking out of ignorance.

AFAIK Open AI has a powerful LLM system in large part due to large compute power.

Is there a future where small business / people can compete with mega-corps in the LLM space, or will we be renting GPT (or similar) until end the of time?

📝 OpenAI announces leadership transition via Josh Cho

🧵 conversation

📝 Humane officially launches the AI Pin, its OpenAI-powered wearable via Daniel Garcia

🧵 conversation

📢 Algorithmic Pattern Salon 2023 🎼 Notation Must Die 🌲 The Expanding Dark Forest & Generative AI

Two Minute Week

Our Work

📢 Algorithmic Pattern Salon 2023 via Alex McLean

🧵 conversation

An online event I'm co-running - Algorithmic Pattern Salon 2023

Talk sessions over five days, exploring contemporary and heritage algorithms in weaving, braiding, music, typography, live coding, juggling, etc etc

💻 Levlo via Jarno Montonen

🧵 conversation

It's still early, but what do you all think about levlo.com? Any feedback is welcome, but I'd especially love to hear how do you understand the product based on the messaging on the site. What would you build with it?

Levlo is a textual no-code platform that allows you to create, share, and monetize expert applications without coding. Start building your app today!

📝 Personification of computer processes via Tomaz Zlender

🧵 conversation

I've published an essay Personification of computer processes where I introduce a metaphor that will allow us to program computers in a game-like (and also in "Dynamic Land"-like) environments. The website Latent Centers is a digital garden I started recently where I will continue to publish related work. The aim is to invent computing that makes us feel more alive.

I'm looking forward to hearing your thoughts!

📝 Turning the Blob inside out via Duncan Cragg

🧵 conversation

Hi everyone, my latest article on The Object Network and OnexOS is out:

📝 Turning the Blob inside out

Idiosyncratic apps come between you and your data...

It discusses "The Blob" - apps - and how we can free our data by "simply" not having those nasty apps coming between us and our precious digital stuff...

▶️ Introducing Macros: Automate Apps with Record and Replay via Michael Gummelt

🧵 conversation

We're experimenting with a novel form of "Programming by Example", similar to Excel macros: plato.io/blog/introducing-macros

I think it can scale quite well to a complete programming system with branching, looping, etc.. Thoughts?

🎥 Macro Demo

📱 Shady Phoney via Gregor

🧵 conversation

I have started experimenting with a mobile shader editor and wrote about it over on my blurgh: dflate.io/shady-phoney

You can play with it here: shd.is

And if you wanna signal boost me: mastodon, bsky & twtr

But most of all I'd be curious to read your thoughts, associations, etc. 🙂

💭 by Kartik Agaram

🧵 conversation

Now that I've started inserting coroutines into my apps (💬 #two-minute-week) to make them more debuggable, I'm starting to find and plug gaps in error recovery:

• I have to be careful to check the results of coroutine operations, because the underlying coroutine might have thrown an error.
• Errors in Lua include a call stack, but errors within coroutines don't return the stack by default.
• If I create a higher-order helper to abstract away the coroutine munging just to smear a computation across frames, does that impact the quality of debug information in the call stack? (Answer: no it doesn't in Lua, but it wasn't obvious.)
• Call stacks returned by LÖVE aren't quite as clean as plain Lua.

💭 by Kartik Agaram

🧵 conversation

I've cleaned up the code for my debug infrastructure of 💬 #two-minute-week and improved the error flow; now you get decent call stacks even if there's a coroutine in the middle somewhere.

The debug infrastructure lives on the surface. I frequently tinker with it while debugging.

Thinking Together

💬 Arcade Wise

🧵 conversation

Does anyone know of any systems that let you take the output value on a repl, edit it, and then edit the code so that your edit is true?

💬 Dane Filipczak

🧵 conversation

What are some examples of successful UIs over constraint solving systems?

I'm about to do a bit of research on this topic but thought I'd start here.

Off the dome I can think of excel (numerical constraints) and rhino grasshopper (architectural / physical constraints).

I realize this is vague, but what I have in mind is a UI that allows for constraints to be defined which are then composed together and solved behind the scenes.

In particular, I'm wondering how to represent the case where there are multiple valid solutions and offer cycling through them to the user.

💬 Xavier Lambein

🧵 conversation

I'm thinking about ways to represent/interact with a (computational) graph. I could come up with three different interfaces off the top of my head: 1) names/identifiers and application, 2) combinators/stack operations, and 3) boxes and wires. I'm curious to know if y'all can think of any other?

Content

📟 django-tui via Mattia Fregola

🧵 conversation

Really interesting looking tool – though admittedly for a very niche use-case.

🎥 Notation Must Die: The Battle For How We Read Music via Mariano Guerra

🧵 conversation

🐦 Grasshopper 2.0 (@CapsuleWire) / X via Mariano Guerra

🧵 conversation

Go check twitter.com/CapsuleWire (Version 2 of the Grasshopper Algorithmic Modelling plugin for Rhinoceros 3D). for some real world node-and-wire-core inspiration.

🐦 Grasshopper 2.0 (@CapsuleWire) / X: Version 2 of the Grasshopper Algorithmic Modelling plugin for Rhinoceros 3D.

🎥 THROAT NOTES via Ivan Reese

🧵 conversation

I've been looking for an excuse to share this somewhere, so it might as well go here.

It's a beautifully animated film by Felix Colgrave titled Throat Notes. While all of his recent animations are breathtaking and delightful and worth your attention (since, like Jacob Collier, Felix is just frustratingly talented), this video in particular will be of interest to the FoC community for its contributions to classic GUI design.

🤖 GitHub Next | Copilot Workspace via Nilesh Trivedi

🧵 conversation

Repo-wide code writing by AI

GitHub Next Project: How can developers overcome the high effort of getting started on complex tasks and truly collaborate with AI to make progress quickly?

🎥 The Essence & Origins of Functional Reactive Programming • Conal Elliott • YOW! 2015 via Alex McLean

🧵 conversation

I enjoyed this talk by Conal Elliott on Functional Reactive Programming (FRP)

and also enjoying some previous discussion about Conal's version of FRP here

• Does anyone know the current state of the art in functional reactive animation?

🤖

🌲 Talk: The Expanding Dark Forest and Generative AI via Lu Wilson

🧵 conversation

I keep directing people to this talk: maggieappleton.com/forest-talk

@Maggie Appleton explores it better than anyone else

An exploration of the problems and possible futures of flooding the web with generative AI content

🎧 Future of Scrappy Music ⌨️ Wordplay Beta 🎥 Demos with Squares, Disks & Loops

Two Minute Week

🎥 Debug Coroutine Demo via Kartik Agaram

🧵 conversation

I've been experimenting with ways to debug my live programs.

(Kind of a follow-up to archive.org/details/akkartik-mu-2021-05-17, if you squint.)

🎥 Debug Coroutine Demo

🎥 Projected AR by Arcade Wise

🧵 conversation

Not quite 2 minutes, but a fun little set-up for messing around with projected AR concepts!

🎥 Projected AR

🎥 Rectangle World by Kartik Agaram

🧵 conversation

Rectangle World, a little test bed for exploring easy versions of some problems, along with techniques for writing easy-to-debug programs.

🎥 Rectangle World

Our Work

⌨️ Wordplay beta via Amy Ko

🧵 conversation

Wordplay beta is live! We’d love your feedback on everything (language design, APIs, tools, editors), and your contributions, if you’re so inclined.

• Blog
• Repo
• Discord

🎨 MightyMeld: a future kind of dev tool via Steven Schkolne

🧵 conversation

Hey everyone -- long-time lurker, first time poster. Thrilled to share the open beta launch of MightyMeld, a visual dev tool for React I've been building with some friends of mine. mightymeld.com

Just posted this blog post telling the story and why I'm excited -- mightymeld.com/blog/open-beta

Would love to hear your thoughts! I'm a former academic who's been driven into industry out of a desire to make the theoretical practical. MightyMeld is a "visual coding" that is not like any kind of "visual coding" i would've imagined if we hadn't've built this thing starting from real production code and saying "how can we make this more visual".

📝 From app trap to freedom space via Duncan Cragg

🧵 conversation

Hiya, if you're interested in:

• End-User Programming, Declarative languages
• Digital Gardens or Personal Knowledge Managers/Graphers
• Decentralisation

Then you clearly need to read my latest fine work: From app trap to freedom space

TL;DR: we can break free of the "app trap" by simply building an OS without apps !

(Don't forget to subscribe so you won't miss future updates, right into your mailbox...)

🎧 arroost.com via Lu Wilson

🧵 conversation

Hello everyone I've been making a new tool called arroost. It's for making scrappy music. Please do make something in it and send it to me.

I will post some examples of its use in the replies

Devlog Together

📝 Experimenting with chatgpt as my ghost writer via Paul Tarvydas

🧵 conversation

I’m developing a cutting-edge tool that leverages ChatGPT to ghost-write prose based on my point-form outlines, particularly focusing on ‘new ideas’ that the AI wasn’t trained on. The challenge lies in preventing hallucinations and incorrect extrapolations from the outline. Early experimental results have been promising prompting me to create a dedicated workflow tool. This tool enables me to swiftly input point-form outlines, using the user-friendly Kinopio platform for brainstorming. I then paste the outline to ChatGPT, transforming it into coherent and readable prose. Join me in revolutionizing idea development and content creation with this innovative solution! [ChatGPT]

🎥 Rectangle World II via Kartik Agaram

🧵 conversation

Today's follow-up to 💬 #two-minute-week@2023-11-03 as I try to come up with more pleasing random arrangements in Rectangle World.

🎥 Poisson Disk Sampling Debug UI via Kartik Agaram

🧵 conversation

Some satisfying debug UI for Poisson Disk Sampling (sighack.com/post/poisson-disk-sampling-bridsons-algorithm; thanks Jack Rusher for pointing me at it)

Couple more videos in 🧵

🎥 Poisson Disk Sampling Debug UI

🎥 Creating new flow using a "back-loop" and placing the "back-loop" connection on a separate layer via Maikel van de Lisdonk

🧵 conversation

Hi, the last month I've been focussing a lot on fixing some bugs in the way nodes are connected and improving the different path types that are used.

This small demo video (Creating new flow using a "back-loop" and placing the "back-loop" connection on a separate layer) shows creating a very small flow from scratch, the functionality of the flow is not important here.. but the thing I wanted to show is the way a "backloop" is created. The system uses a different svg path for backloops: normal nodes are connected using a bezier curve but when the output node is placed before the start node, the path changes to a "back-loop".

Another thing to notice is the layering.. the back-loop is placed on its own layer, hopefully keeping bigger flows more clear. You can toggle which layer is in front.

Thinking Together

🧑‍🎨 music thing via Arcade Wise

🧵 conversation

I've been working on learning UI design, what do y'all think of this? music thing

💬 John Flockton

🧵 conversation

Hey folks! I'm doing some research into code formatters/pretty printers, with a view to potentially building my own. Does any one have any examples of code formatters that they've found especially fast, or that they know of which have a special focus on performance?

I'm interested in learning about some of the potential techniques at play - what sort of caching and parallelization is being done, are they doing incremental parsing like tree-sitter etc..

💬 Mike Austin

🧵 conversation

Over the years, I've thought about different ways of creating an interactive tutorial about writing a simple programming language. For example, you can create a "wizard" style with next and back buttons, or you can create one single page with the code floating on the right side of the content (possibly sticky). One detail is that each example would grow in size (for the complete code), but would only focus on one sub-section. I thought about collapsing sections already covered, but being able to expand them, or just have a single button to expand all the hidden code. Has anyone had experience or have seen articles that use a "build from small to large", showing code along the way?

💬 Arcade Wise

🧵 conversation

This is a cute little section from the wordmaster manual :>

I did in fact get the 12 lines

considered harmful?

🤖

💬 Nicolay Gerold

🧵 conversation

Hey 🙂

I am looking for inspiration in building frontends with LLMs. I am looking for companies, which have LLMs (their own or wrappers around GPT) deployed in customer-facing applications (B2B and B2C) at some level of scale.

Something like Sudowrite and Jasper.

Also if you know some impressive solobuilders, feel free to name drop them 🙂

I would appreciate any link or name dropped in the thread 😉

🖼️ Drawing Images Explains Programs 🐰 Data Exploration, Visualization & Learning 💡 Is generic code just hopeless in practice?

Two Minute Week

Our Work

💬 Daniel Garcia

🧵 conversation

I’ve been working on a tool to get a high level view of an entire typescript codebase to help me understand/navigate it.

It shows all the functions and interfaces. Every interface is represented by a color, and the signature of a function is shown with these colors.

I need some help with a better algorithm to transform the name of the type into to a color. e.g. the type string -> blue, int -> green, etc.

The problem is that I’m not sure what I want the output to be, how should the color space be distributed? how should colors be clustered?

I think I can copy what code editors use for semantic highlighting , but I haven’t been able to find an implementation of it.

Does anyone have ideas on what I should search for?

Happy to explain more, if it’s not clear.

PS. Here is how a codebase currently looks. White rectangles are files, interfaces are shown on the top, and functions on the bottom

Devlog Together

📝 ALDs compatibility with code projection focused of concatenative code via Kartik Agaram

🧵 conversation

Some nice original research by Lukas Süss: 💬 #thinking-together@2023-10-24T22:28:03.239Z

[October 24th, 2023 3:28 PM] lukas.suess: <@U01ULCCJB7X> I spontaneously decided to project your example to an ALD mockup to get a bit of a feeling for inhowfar ALDs are compatible with your code projection focused of concatenative code. Seems pretty good.

★ One nice thing with ALDs is that library functions are threated exactly the same as argument values. They come in as semi-implicit arguments via the grey collection abstraction-line. ★ One annoying (but I think good) restriction of ALD is that functions (and definitions in let sections) can only ever have just one single value-line as their final output (except one cheats a bit as I've done here with memocurry :smiling_imp:).

💬 Kartik Agaram

🧵 conversation

Ok, I think I've tapped into a rich new vein of pointless demos.

🔗 unit.land via Samuel Timbó

🧵 conversation

The time has come for “the bot” to leave main unit.land 🥲

📝 unit.land

Local First Open Source Distribuition of the Unit Programming Environment.

📝 Samuel Timbó on X

Doesn't unit.land feel lonely without the bot?

Thinking Together

📝 Using computers more freely and safely via Kartik Agaram

🧵 conversation

Replacing authentication with visual identity

Background: I'm starting to think about building a new forum. Given my past, it won't surprise anyone that I mean to do this outside the morass of non-convivial software that is the modern web browser. My broad plan is:

• LÖVE v12 will support https, and release candidates are already quite stable. Good enough to start building on.
• I'll build my forum out of a server-side API in Lua and a client in LÖVE v12. (Should be easy to support Windows, Linux, BSD and Android. Mac and iOS will require some annual contortions to build LÖVE for oneself.)
• The server side will of course be open source just like the client. In addition, all post/comment data will be published to a git repo on something like a daily basis.

The one major open question concerns authentication. How can we have stable identity? The above architecture is intended to allow anyone to host the forum (without trying to build galaxy-brain merkle trees, federated protocols or CRDTs), and I would prefer to not take a position of power as the source of everyone's hashed passwords (an intrinsically centralizing architecture).

A few months ago someone showed me this ancient essay called "attacked from within", and I find myself thinking about it often. The whole thing is worth reading, but for this thread the crucial list of bullets halfway down is:

• Registration keeps out good posters.
• Registration lets in bad posters.
• Registration attracts trolls.
• Anonymity counters vanity.

A provocative worldview that seems at least worth exploring. Keeping this in mind, I have a hazy idea that looks like this:

• When you run the client you get to choose your handle, but it's not unique (cf. Zooko's Triangle)
• When you run the client for the first time, it creates an RSA keypair for you.
• When composing messages, the client signs the message with your private key (description on Wikipedia)
• When rendering messages, the client validates the signature against your public key and shows something like an identicon of the public key.

Implications of this setup:

• No registration
• Your "password" (private key) never leaves your device(s).
• When reading a thread you see a handle like spiralganglion . However, the handle is not authoritative. Next to it is an identicon that is authoritative.
• It's easy in a thread to see if there are ever two people with the same handle but different identicons.
• Since the client platform is starting from scratch, accessibility and internationalization will be a challenge for a long time 😕

No guarantees this is all doable. It's quite possible the cryptographic operations will be untenably slow when implemented in Lua, and a native library for them would complicate the simple install story that is LÖVE's greatest strength.

But I'm curious to get people's thoughts on this idea in principle.

💬 Matthew Linkous

🧵 conversation

Maybe more of a general coding question but how do you y’all feel about database/stores that add fields to your documents that insert?

E.g. you insert { name: 'Titanic', director: 'James Cameron' } into movies and when you fetch it you get back {_id: 1234, _col: 'movies', name: 'Titanic', director: 'James Cameron' }

Does that bug you? Don’t care?

Are there any ways to get around this so there aren’t won’t ever have collections between user defined fields and internal metadata?

💬 FreeMasen

🧵 conversation

One of the things I am curious about is how a11y relates to the future of coding. So far it doesn't seem to come up in the discussions on the podcast but I think there is something to be said about the advancement in a11y in computing over the last 25 years and a large part of this is due to a movement away from some of the more creative interface designs (ala Magic Ink). Is there a future of code that is more accessible to people with different abilities?

🧮 Lambda Diagrams via Lukas Süss

🧵 conversation

Here's the big omega combinator as annotated lambda diagram.

Plus showing how the (here non-terminating) evaluation could be fluently animated. 🤤

( John Tromps unannoteed version here: tromp.github.io/cl/diagrams.html )

💡💬 Marcelle Rusu (they/them)

🧵 conversation

In the past year or 2, I got interested in OO and I find even its basic form within a mainstream language very powerful.

Yet, when I try to advocate for using polymorphism in almost any context, I get "this is too unfamiliar"/"that's not how we do things in framework X" instead advocating for switch statements or similar.

And it really gets me thinking, if we don't even understand OO after 30 years of mainstream adoption (in some form or another) and are still doing "structured programming" with lambdas & objects, is generic code just hopeless in practice? Is there an education problem? Is it just indicative of how poor standards are that few people have the privilege to do any amount of design for their systems before developing?

If so, how does "future of coding" even matter if any form of real adoption feels impossible.

💡💬 Jimmy Miller

🧵 conversation

Forking @Marcelle Rusu (they/them)’s thread onto this bit

If so, how does "future of coding" even matter if any form of real adoption feels impossible.

(Making a new thread about this because the other one has become about OO instead of this bit)

I feel this deeply. It can often feel as if things don't get adopted. That programming doesn't change for the better. I have so many thoughts on this, it is hard to summarize.

First, I do think we can get others to adopt the things we value. It is almost never an education issue, imo and instead a value question. (I am intentionally leaving aside the OO frame here). Think about the impact that Rich Hickey has had on how many people code, not just clojure people, but in the industry broadly. How did he do it? Through Simple Made Easy, a talk largely about values, not techniques. The same is true of Bret Victor's influence on the future of coding community. He communicated values that others adopted.

I've found this to be true in practice as well. Trying to convince people to change their coding style requires diligence, communicating values, and showing how code improves because of these values. Conflict often happens when people implicitly hold very different values. I'm going to bet that is the case in the original example given.

But I also want to step back and ask, what kind of adoption, by who, by how many people? I'm willing to bet a lot of people in this slack listen to some genre of music that isn't completely mainstream. Have those genres failed because of the lack of becoming mainstream? Would they be better if they became mainstream?

💬 Arcade Wise

🧵 conversation

Have y’all heard about the PLATO computer system?

💬 Gregor

🧵 conversation

I’m looking to learn more about a space, that I’m not sure exists. Does this word comob trigger associations to existing projects: spreadsheet, schema, hierarchy?

🐰🎥 "No Code" Intro to Data Rabbit for Visualization & Dashboarding (for non-Clojure peeps) via Qqwy / Marten

🧵 conversation

What do people here think about the REBL (read-eval-browse-loop) and the ‘Data Rabbit’ project which evolved from it?

Both are tools originating in Clojure, but where the REBL is about mixing writing/running Clojure with having a graphical interface to drill down into the output data (e.g. a natural ‘visual programming’ evolution of a REPL),

I’d describe Data Rabbit as the opposite: A data inspection/‘dashboard creation’ tool where you can do most tasks visually, only dropping down to Clojure if you want to do really custom things (or create new types of ‘blocks’/interactions).

💬 Qqwy / Marten

🧵 conversation

And in not totally unrelated fashion, there’s PureData (FOSS) / Cycling76' Max (paid), which are reasonably successful graph-based programming languages for digital music synthesizers.

I expect that in that particular case graph-based programming is so successful because it is a direct translation of how (analog) modular synthesizers used to be patched together, flattening the learning curve for musicians.

Content

🐍 pythontutor.com via Marcelle Rusu (they/them)

🧵 conversation

pythontutor.com

Anyone play around with this? I was given this back in first-year comsci, and I think honestly there's few tools which top it.

🖼️🎥 Kaleido Demo via Joshua Horowitz

🧵 conversation

Kaleido lets a Processing programmer draw a picture to map out different parts of their program

This idea is so simple and “unsophisticated” and it looks utterly transformative. (I’ve never seen anything like it!)

🤖

☠️ Meet Nightshade, the new tool allowing artists to ‘poison’ AI models with corrupted training data via Chris Maughan

🧵 conversation

📝 Peo generative ail via Paul Tarvydas

🧵 conversation

A.I. is simply pattern matching - a summary of a talk I attended …