🎙 FoC #65 Interpreting the Rule(s) of Code 💡 Freewheeling Apps 🧘 Calm Tech

Two Minute Week

🎥 Adding eval and supercompilation via Peter Saxton

🧵 conversation

I've added eval to my language in the last week. Trying to get my head around supercompilation so I can precompute terms that are evaled and then have typesafe string.format Does any language make use of this eval at compiletime to reduce untypable functions, like eval.

Our Work

🎙 Future of Coding #65 Laurence Diver • Interpreting the Rule(s) of Code: Performance, Performativity, and Production via Ivan Reese

🧵 conversation

The execution of code, by its very nature, creates the conditions of a “strong legalism” in which you must unquestioningly obey laws produced without your say, invisibly, with no chance for appeal. This is a wild idea; today’s essay is packed with them. In drawing parallels between law and computing, it gives us a new skepticism about software and the effect it has on the world. It’s also full of challenges and benchmarks and ideas for ways that code can be reimagined. The conclusion of the essay is flush with inspiration, and the references are stellar. So while it might not look it at first, this is one of the most powerful works of FoC we’ve read.

📝 A 3D operating system without apps via Duncan Cragg

🧵 conversation

Freeing our digital stuff from the "app trap"!

Hiya - I've got a new article in my Object Network "Lab Notes" Substack

💡🎥 Hands-on with Freewheeling Apps via Kartik Agaram

🧵 conversation

A 20-minute video on my lived experience with Freewheeling Apps

💻 author.quickpoint.me via greg kavanagh

🧵 conversation

I’ve been working on a DSL for creating mixed media pages. Markdown meets YAML and we’re about to hire some real designers to make it look normal… however if anyone would like to play with it while it’s weird and wonky you can check it out at author.quickpoint.me

📝 How to design a CLI via Tyler Adams

🧵 conversation

I'm restarting my programming productivity blog, here's the latest on CLI tool design

Vercel’s a got a great system for deploying serverless JS web apps. It Just Works(TM). Vercel’s CLI however…is a learning example. We’ll go over some of their interesting and noteworthy design choices, and then, describe what other option we could take.

Devlog Together

💬 Jason Morris

🧵 conversation

Doesn't look like much. But under the hood it's a demo of an LLM-powered langchain agent using my Blawx software's public API to generate an answer based on a human-validated symbolic encoding, fully explainable with reference to source materials, and zero risk of hallucination. All of the usability upside of ChatGPT, none of the opacity and horseshit. It BARELY works with 3.5-turbo, some of the time. I need GPT4 API access to really generalize it, in addition to a few changes to Blawx to add natural language meta-data that can be used in prompts. If anyone has any tips on how to get access to GPT4 faster without breaking any laws, that'd be great.

💬 Oleksandr Kryvonos

🧵 conversation

I am creating and interpreter for AST stored in JSON (see picture) (Lisp-idea--style) and I am playing with partial & reactive evaluation (Excel--style) for it

Reading Together

📝 Myths and Mythconceptions: What does it mean to be a programming language, anyhow? via Srini K

🧵 conversation

Enjoying this read, love the term “vernacular programmer”

Thinking Together

💬 Duncan Cragg

🧵 conversation

Dynamicland could be done better with Augmented Reality specs. All that frayable, water- and fire-damageable stuff. No version control? No backups? Those little test tube doodads will fall apart after a few months. Plus with AR you can actually use that amazing innovation they call the Inter Network. Argue away, humiliate me for my lack of Bret Victor worship!

📝 System and method for combining text editing and tree encoding for computer programs via Jarno Montonen

🧵 conversation

I run into this fairly recent (sent 2017) patent that seems to just describe an incremental parser which is used to 'enrich' textual program code with syntactic and semantic annotations. I don't really understand what the patent tries to protect and what is supposed to be the patent worthy invention here as for example tree-sitter existed in 2017 already. I'd be interested to hear any thoughts on this.

💬 Hamish Todd

🧵 conversation

I'm interested in the concept of a "spread", which I have seen discussed by Toby Schachman and Joshua Horowitz partly in the context of dynamicland, though I forget where, anyone got a link? In my own system, I'm thinking I'll have them.

📝 Save Your Twitter Likes Without Using the API via Sam Butler

🧵 conversation

I want to be able to post microblog style content, and have it cross-post to different platforms (e.g. Twitter, Mastodon, LinkedIn, Facebook) — in a way that is resilient to corporate api hijinx. (Perhaps aligned with the approach/philosophy of this project, getting into browser automation? mschmitt.org/blog/save-liked-tweets-without-twitter-api. Or this approach, based on local device automation?) I also think it would be cool to explore pulling content from multiple platforms and synthesizing them into a single alternative feed — sort of like an RSS for your Twitter, Facebook, LinkedIn, Mastodon, Reddit timelines. Again, in a way that is resilient to corporate api hijinx. Is anybody interested in exploring this? I would also be interested in low-energy and low-data/bandwidth approaches to doing this, because that's the world we're moving towards (hopefully)

💬 Eli Mellen

🧵 conversation

around these parts we talk a lot about the technical aspects of the future of coding — what are some of the social or cultural aspects of the future of coding folks see?

• See either holding us back from doing more future of coding flavored stuff out in the wild yonder
• Or see in the future, allowing for new sorts of stuff

📝 Debugging Lisp Part 4: Restarts - malisper.me via Tim Lavoie

🧵 conversation

Hi all. I just finished listening to the episode, "Interpreting the Rule(s) of Code by Laurence Diver". I wasn't sure it was going to hook me, but am so glad it did. I had a few thoughts bounce around as I was listening, though dog-walking on a trail. Hopefully they make some sense now.

Where Ivan was talking about the problem of a program only being able to handle conditions for which it was designed, with no escape hatch, I wondered about exposing something like the restarts that Common Lisp has in its REPL. This probably isn't something you would offer to a user that you didn't trust with a REPL, but perhaps encountering a problem could default to selections of alternate solutions that are offered to the user. When restarts are offered in CL, the program execution is paused, so the choices for the user have all the context of what is on the stack at the time. Rather than just aborting (which is one option), one might take an extra step back and try something different. Web checkouts typically have a weak form of this, but I thought that perhaps very binary conditional checks could often be replaced with "one of" or combinations of options. Don't have that right address? (RR 2, Pfff!). Include some other means of providing a location that is accepted. Maybe some form of fuzzy logic, albeit unfashionable these days, guides the programmer into accepting a combination of responses that satisfy their fraud-prevention algorithm when taken together.

malisper.me/debugging-lisp-part-4-restarts

Also, the whole concern makes me think of the eventual corporate destination, "Computer Says No" from Little Britain.

This is part four of Debugging Lisp. Here are the previous parts on recompilation, inspecting, and class redefinition. The next post on miscellaneous debugging techniques can be found here. Many languages provide error handling as two distinct parts, throw and catch. Throw is the part that detects something has gone wrong and in some way […]

🎥 Little Britain USA - Computer says no

💼 regular spreadsheet via Beni Cherniavsky-Paskin

🧵 conversation

Say, has anyone ever tried BASIC's non-consecutive numbers for spreadsheet coordinates?

We programmers always laugh at spreadsheet's use of coordinates ("like machine code without assembly") but few users avail themselves of features to name ranges / structured/hierarchical data etc.

But there are real annoyances with what-you-see-is-what-you count consecutive coordinates: They mostly shift correctly on insertions/deletions, BUT one needs to grok $A4 vs. B$7 notation, which I suspect many don't. Getting range E3:F34 boundaries for formulas exactly right is always a hassle.

So I wonder if features like named ranges are "premature formalization" then maybe "structured numbers" in the BASIC's style could serve as more accessible "semi-formalization"?

BASIC users quickly learnt conventions like "increment by 10, start functions on hundreds, big modules on thousands". And this allowed them to avoid re-numbering almost entirely!

(This was good UX in teletype line-editor era 🖨, and of course now we have full-screen editors and can insert/delete — no need to "increment from 10 to 20 so you can later insert 15".

But a 2nd aspect that imho was really genius was the numbers were stable , helping your brain 🚲🧠. Your transcript 📜 had partial LIST ings, followed by chains of edit actions (poor man's git) + REPL experiments, and the fact that line 60 remains 60 throught helped you mentally interpret that history — making you a better debugging detective 🕵️‍♀️. It's insane to remember what GOSUB 437 means; easier if you assign semi-systematic round GOSUB 2100 .)

So, suppose spreadsheets let you use higher numbers/column names freely, by skipping display of unoccupied rows/columns.

• If you have a long table that might grow, you won't put =SUM(...) computation directly beneath it; you put it at next 100 or 1000 — but it will still display close to its bottom. And you can type the range as 10:99 from the start.
• With some foresight allocating "big enough" ranges for tables, you might never run into situations where $B7 vs. B$7 matters. (This means spreadsheet should become smarter yet in renumbering on insert/delete — do shift rows/columns, but stop at next unoccopied "moat".)
• To introduce users to the idea, don't show consecutive numbers/letters. Even in an empty spreadsheet, after some rows/columns, skip to some far-away numbers like 100 and 1000!
• Perhaps it might also subsume the feature of "freezing" some rows/column from scrolling? mockup below has one fake "scrollbar" to suggest a portion could be scrolled separately.

attaching a mockup to this thread (drawn in a regular spreadsheet😉)

🧘 calmtech.com via Martin Shaw

🧵 conversation

Been reading a lot about Calm Tech (calmtech.com), technology designed to require a minimum of the user's repeated attention. Products/projects which make information available to the user on the user's request and not the other way around.

As someone who has wasted plenty of time on social media, I find the design ideas fleshed out on the site and related projects fascinating. Does anyone else have an interest? Seems like a positive (for once) way 'back to the future' of useful home-based tech.

💬 Martin Shaw

🧵 conversation

I know that it doesn't necessarily implement many of the points from the 'manifesto' and televisions are still attention sinks, but I always thought that the Samsung 'The Frame' TV was interesting because it move the centerpiece of the lounge from a big, cold, out-of-place television to an inquisitive wall of artwork until the user chooses that they want to watch television.

💬 Ivan Reese

🧵 conversation

I'm suddenly bothered by the fact that code comments are always the same size .

Sure, I've seen some people play with rich text in their code editor, applying bold or font size the same way you apply color. Atom's CSS was great. But that's outside the code. Your font size tweaks aren't going in the repo. (That'd be a tabs vs spaces fight for the ages!)

But… what if I want to leave a little pocketbook tucked into the back flap of a function? Unobtrusive. It's there as a reference when you need it. Within, you can fully explain why things are the way they are. You can talk about the history of this code. It's the sort of stuff that you'd put into a wiki, or spread across a series of commit messages — but it's right there in the codebase, but it's tiny and off to the side. There when you need it, easy to ignore when you don't.

Makes me wonder about other ways that being able to choose the size of representation in a program — independently from typical size units of code (ie: lines) — could be useful. Eg: at the main entry point of a well-factored complex program, where you're dispatching off to various other subsystems, things deserve to be quite large.

Makes me wonder about other things that ought to live inside the codebase. To start: every feature of Github? (Consider that it serves their interests that, say, the discussion around an issue or PR lives on their cloud, not in the repo.)

💬 Grant Forrest

🧵 conversation

Only halfway through the latest podcast ep but my imagination is piqued. Is there a version of, like, unit testing, where the software generates some randomized states based on its internal state and unknown inputs, presents the outcome as part of a report, and asks humans to correct any erroneous assumptions or missing contingencies? IDK how to even describe what I'm thinking of but I feel like it must exist, or maybe be theoretical in the emerging AI models of creating software.

Kind of fuzz testing, I guess. My brain is going somewhere bigger with this, though, maybe I'll check in with it again once I find time to finish the podcast.

🧵 conversation

Another thing. My wife worked at a legal research company for a while and she kept pausing the podcast (I subjected her to) to comment on the legal side of things. One thing she pointed out is that civil law is about codifying and interpreting laws to judge situations, but common law is basically a series of precedents. You try a case, if it's novel you invent a judgment. If it's similar to a previous case you adopt/adapt the previous judgment and it becomes a new more refined precedent for future situations.

Not sure the mapping here. I'm imagining when Ivan puts in his address to buy a ticket, instead of "invalid address" and end of story, the software responds, "this format of address is new to us, please await trial" and forwards it to the Airline Judge who renders judgment that is then encoded as precedent in the software itself.

Content

🖊️ An update on Dynamicland via Ivan Reese

🧵 conversation

📝 Bad software sent postal workers to jail, because no one wanted to admit it could be wrong via Ivan Reese

🧵 conversation

Something something ruleishness something something legalism something something

(Via Kartik Agaram)

The software was used as evidence that employees stole money

📝 The Development of the C Language - Dennis M. Ritchie via Shubhadeep Roychowdhury

🧵 conversation

💡 Viewpoints Research Institute 👓 How to Work, Play & Thrive in Cyberspace 📙 Programming Language Myths and Mythconceptions

Two Minute Week

🎥 Apps, new effects & Shallow effect handlers via Peter Saxton

🧵 conversation

Web apps, New effect types in code sandbox (HTTP, Async and Log) and Shallow effect handlers added to my language.

Devlog Together

💬 Jason Morris

🧵 conversation

The people using my software as a back-end for their web project are running machines that are not allowed to use docker, but are allowed to use "podman". Podman does not implement the feature of docker-compose.yml files that allows you to build an image from a github repository. So this week I need to learn how to publish docker images of my alpha software that nearly no one uses. Having users is the best/worst.

Thinking Together

💬 Shalabh Chaturvedi

🧵 conversation

Hi everyone, I’ve been thinking about using hypertext instead of text files as the medium to represent programs and their executions .

Programs contain a lot of cross references that are resolved only after the parser/runtime have had a go. IDEs also redo this parsing work to simulate the same cross references for easy editing. The idea is to embed these references in the medium itself. So, get rid of import statements, file boundaries and such. Each textual reference - function name, type name, any identifier really - would be link to the object it references. Unlike strongly structured environments, this allows some flexibility in representing partial and possibly invalid structures. I’m interested in implementations you know of that match this idea.

💡 VPRI via Jan Ruzicka

🧵 conversation

Recently, I realised that despite “vaguely knowing” what VPRI was doing (and trying to do), I never bothered to thoroughly read their reports and papers. Now that I took the time to read them, I feel like overall it’s been time well spent (I got inspiration and encouragement for some projects).

I’d like to know if you know about the VPRI undertaking, and if you do, whether you read (some of) their papers/reports - see poll below. I’m also interested in similar experiences you had with other projects (thinking you know what they do, then having this understanding deepened by looking at their work more carefully).

Content

📝 Everyone excited for Fortran 2023!? via Walker Griggs

🧵 conversation

Everyone excited for Fortran 2023!? Only mostly joking, but I just noticed today that fortran is scheduled for a new standard release next month. I got a big smile at some of the proposed imporvements

• Trig functions that work in degrees
• Using integer arrays to specify subscripts and section subscripts
• Enum types

🐦 Tweet from @double__glitch via Mattia Fregola

🧵 conversation

It looks like Figma is secretly – not so secretly 😛 – starting to turn code into design, and plugged in a mini-structured editor along the way.

(Attaching a couple of screenshots from the og file)

👓 Scientific American — Special Issue, 1991 via Ivan Reese

🧵 conversation

Scientific American — Special Issue, 1991

Communications, Computers and Networks — How to Work, Play and Thrive in Cyberspace

Featuring articles by Tesler, Cerf, Kay, and more. (Requires a free Internet Archive account)

🧑‍🏫 Programming Languages and Operating Systems via Duncan Cragg

🧵 conversation

Got interested in the conceit of a fringe-conference called "Programming Languages and Operating Systems", then read the CfP which seems to be aiming to pre-stifle any thoughts you may have had that innovation outside the familiar borders would be acceptable:

Suggested paper topics include, but are not restricted to:

• domain-specific and type-safe languages for the OS;
• the design of language-specific unikernels;
• language-based approaches to crosscutting system concerns, such as security and run-time performance;
• PL support for system verification, testing, and debugging;
• synthesis of OS code;
• static/dynamic OS configuration and specialization;
• PL support for OS integration of modern hardware (NVM, HBM, FPGAs, accelerators, RDMA, etc.);
• the use of OS abstractions and techniques in language runtimes;
• verification and static analysis of OS components;
• critical evaluations of new programming language ideas in support of OS construction; and
• experience reports on applying new language techniques in commercial OS settings.

🎥 Barliman: trying the halting problem backwards, blindfolded - William Byrd, Greg Rosenblatt via Paul Tarvydas

🧵 conversation

I found myself referring to this (2016) video. In case all y’all (the plural form of “y’all”) haven’t seen it…

📙 Myths and Mythconceptions: What does it mean to be a programming language, anyhow? via Konrad Hinsen

🧵 conversation

A paper worth reading that (among other topics) argues that end-user programming should better be called vernacular programming

💬 Ivan Reese

🧵 conversation

#past-company

When the industry switched over from mainframes and minicomputers to personal computers, how big a regression was the performance of a typical PC versus that of a mainframe / mini at the time? (Keeping this question vague because I'm not quite sure how to phrase it. Feel free to interpret it however you like.)

🌐 Object & Named Data Networks 🐘 IvanReese.GPU 🔌 Nodes & Wires IRL

Two Minute Week

🎥 Nette Zen Mode: A quiet corner for your linear explorations via Pawel Ceranka

🧵 conversation

A super simple demo, of a super simple feature.

(more of an experiment really)

The assumptions is that an infinite canvas is great for creative / generative tasks .

But then for processing a linear workflow, might be better / more natural / impose less cognitive burden .

That is what we’re trying to explore with ‘Zen Mode’ 😉

Our Work

🎥 Explaining effect types with examples via Peter Saxton

🧵 conversation

I've been developing documentation for my language. The nice thing about it is that all the code snippets are embedded editor instances that allow you to run and play with the examples.

This week I've been writing a page to document effect types. There one of the key features of it. I've made a video where I play around with them.

Let me know if this does a decent job of explaining effect types, and particularly effect handlers.

🌐📝 Welcome to the Object Network research lab! via Duncan Cragg

🧵 conversation

Hiya fellow futurists! I've started a Substack for my "Lab Notes". Please consider subscribing!

The Object Network Exploration Lab welcomes you in, to see what I'm thinking about and working on...

Devlog Together

🐘 posting more regularly on Mastodon via Ivan Reese

🧵 conversation

My overall goal for the year is to —finally— learn how to do real work on the GPU. As a motivating short-term goal, I'm building a visualization of magnetic fields, as VFX for a video about regenerative braking that my company is producing. I'm doing all this (bear with me) inside a new drawing app that I'm developing, which heretofore rendered to SVG, but which I'd like to abstract so that it can render in a more API-agnostic way, as a prelude to making it portable (with an eye to Swift+Metal, perhaps eventually Vision Pro). Then (continue to bear with me) I'll have a nice foundation for continuing some of my visual programming experiments. So no, these screenshots here aren't strictly FoC-relevant. But it is stuff that I'm building as a test case… within a new graphics tech stack that I'm building… with a goal of supporting some new visual programming stuff that I'd like to do.

I won't be posting much stuff here until it becomes more directly FoC relevant, but if you'd like to follow along regardless I'll be posting more regularly on Mastodon.

🎥 Demo Video

💬 Paul Tarvydas

🧵 conversation

Aside: Magnetic fields are actually 4D phenomena (x/y/z/t). We use equations to think about fields by reducing fields to 2D so that we may scribble our thoughts down onto clay tablets and papyrus. There is this new medium - called “computers” - that might let us break free of 2D-only expression of 4D phenomena, using, say, 3D (x/y/t) while expressing the 4th D (z) using a trick that humanity invented, called “perspective”. Fields might be more-than-4D phenomena but our brains can only perceive 4 dimensions at this time.

Thinking Together

💬 Eli Mellen

🧵 conversation

when you all work on a Future of Cod ing flavored tool, do you think about ways to bake in certain sorts of interactions.

As example:

React lets ya build accessible, localized experiences, but it also lets ya make something that is wholly inaccessible, too. It is sort of agnostic on that front. Could a tool “force” an accessible experience, or be more strongly biased towards something like that?

This line of thinking isn’t restricted to accessibility, it just seemed like an easy fruit to reach for when writing an example. Is this the kinda thing other folks think about when designing stuff? Do you have examples of it?

🌐 Named Data Networking via Kyra

🧵 conversation

I have always thought Named Data Networking (a future infrastructure project older than IPFS) is really promising: named-data.net

Think instead of naming locations, naming the data you're requesting, so it can be pulled from any host as efficiently as possible

Content

👩‍🔬 Communal Computing for 21st Century (by Bret / Luke of Dynamicland) via Srini K

🧵 conversation

🔌 Let's Play TOKYO HIGHWAY! | Overboard, Episode 39 via Ivan Reese

🧵 conversation

Node wire programming

Without text

With an involved type system

Where humans are the execution units

💡 Inventing Mario on Principle 📙 Live Coding User's Manual 🤖 Generative all the Things

Two Minute Week

🎥 Nette Generate: Start With A Word via Pawel Ceranka

🧵 conversation

Generating initial content for an any workspace.

We are, by design, about non-linear explorations, in that setting it’s not always easy to start.

A bit like sitting in front of a blank page. This feature is like priming / toning the canvas 😉

I personally think visually a lot of the time (spatially / moving pictures), but the trigger for starting a thread of thought is quite often a word, term, phrase or a sentence .

This feature is about that kind of exploration, you drop a word and it ripples out into all kinds of useful directions.

(of course, being useful is the trick here, this is very minimal atm)

The way the app is set-up it’s not difficult for us to generate those workspaces (the blocks are Clojure maps in a re-frame db), so if it turns out that it’s useful we’ll probably generate more content.

Our Work

📝 BASIC to JS Compiler via Kevin Greer

🧵 conversation

Not my main work, but a fun little programming project that's relevant in a number of ways, despite apparently being more about the Past of Coding, than the Future.

I wrote a small (<500 lines of code) BASIC to JS compiler, that lets me run the programs from the class book 101 BASIC Computer Games from 1978. It's interesting for two reasons I think: 1. for those who want to learn about languages and compilers, this provides a very simple example 2. philosophically, I think BASIC really exemplifies the Worse is Better approach outlined by Richard Gabriel and covered in a FOC podcast. It is a terrible language in many ways, but it was small enough to be stored in a 4k ROM and be used to to useful things on an early microcomputer with only 4k of RAM. If we had waited for machines with enough memory to run Lisp, Smalltalk or Algol, the microcomputer revolution would have been delayed by a decade or more. Source: github.com/kgrgreer/foam3/tree/429f2fd2b4cef0e37996a4c4ad35cdf5f83a8b97/src/foam/demos/basic

Online version:

📝 BASIC to JS Compiler

A BASIC to JS compiler that lets you compile classic programs written in the BASIC programming language to JS and then run them in your browser. To us...

🐦 Matt Webb 🌸🌼🌸 on Twitter via Matt Webb

🧵 conversation

I’ve been sketching multiplayer UIs. Folks who came to the most recent London meet will recognise these from my demo. I’m trying not to converge on anything right now — how we interact with AI NPCs is still so open.

I made a new one today, with spatial multiplayer chatrooms and an NPC inhabiting each. It’s on Twitter

An archive of all of my sketches, including a bonus gesture-controlled lamp actsnotfacts.com/made/multiplayer

🐦 Matt Webb 🌸🌼🌸 on Twitter: what if you had one chatroom with an AI for wild ideas... and another next door for a dose of reality?

and you travel between AI NPC chatrooms like a spatial map?

yeah and it's all multiplayer so your friends can be there too?

oh yes ALSO one of the rooms is haunted 👻

📝 Multiplayer sketches

A series of software sketches exploring multiplayer UI.

👮 lintrule.com: Let the LLM review your code. via Evan Conrad

🧵 conversation

with encouragement from @Joe Grossberg, down to share what I’m doing…

I make lintrule.com, a little CLI for having a language model do your code review.

You write rules in plain text, and then it checks them against your code, like a test framework. Here’s an example rule that runs on SQL migrations:

include: ["migrations/*.sql"]




Make sure our postgres migrations follow these rules:



1. ensure new tables are at least 3NF (third normal form). If they're not, fail and give an example of what's wrong, assuming the reader does not know terms like "BNCF", "3NF", "BCNF", and so on.

2. make sure that all tables have a created_at and updated_at

3. make sure migrations don't have breaking changes. For example, removing a table, removing column, and so on.

   3.1 It's okay to have a breaking change if there's a comment on the migration that explains why it's safe to have that change.

4. prefer 'uuid' over 'serial' or 'int' for primary keys. Ignore this check if it's primary key made up of two columns.

Devlog Together

💬 Maikel van de Lisdonk

🧵 conversation

Worked on a prototype for visualizing a map operation on arrays using the visual programming system that I am working on, hopefully it's clear from the video what is going on, at least that is the intention 😅

🎥 Demo Video

Thinking Together

💬 Matthew Linkous

🧵 conversation

I’m been thinking about this concept of a “full-stack” database. I’m curious what connotations that invokes for folks here and what features you might imagine a futuristic, “full-stack” database would have? Bonus question: is it “fullstack”, “full-stack” or “full stack”?

💡💬 Kartik Agaram

🧵 conversation

Are people here aware of Super Mario Maker 2 ? I somehow totally missed the memo that one part of Bret Victor's Inventing on Principle has been productionized.

Screenshots from:

• Bret Victor - Inventing on Principle
• Making a Super Mario Maker 2 Course with Trial and Error!

📝 Emily Dickinson’s Apple Computer House via Ibro C.

🧵 conversation

A look at Folk Computer (ofshoot from Dynamicland by Omar Rizwan and Andrés Cuervo) through Emily Dickinson’s poetry

The 19th-century poet, whose verse still resonates with its open-ended sense of how language produces meaning, is a model for a group of Brooklyn coders inventing a more humane computer.

📝 Live Coding: A User's Manual via Josh Justice

🧵 conversation

Coworker just shared this book and I was surprised not to see it in the search history here (maybe I missed it). I thought this group would be interested: livecodingbook.toplap.org/book/#

To give some scope:

In asking “What is live coding?,” our intention is not to fix or define but rather to explore how live coding opens up . Live coding is about people interacting with the world, and each other, in real time, via code. Live coding is about making software live .

The first part is more practice focused, offering an account of the origins, development, and aspirations associated with the evolution of live coding alongside presenting documentation and examples of live coding practice. The second part is more speculative and conceptual in its register, allowing space for discussion of the many ways live coding reflects and informs wider cultural and political concerns.

📝 Live Coding: A User's Manual

Live Coding: A User's Manual, published by MIT Press

🤖

💬 Greg Bylenok

🧵 conversation

This might fall under "thinking-together", but I'm throwing this here as it specifically relates to AI. For context, I've been working to integrate an LLM into an existing application. If "prompt engineering" is part of the future of coding, here are some challenges to expect:

• Non determinism: I can repeat a prompt and get back drastically different results, in both content and format.
• Capabilities: I feel like I'm constantly probing to discover the capabilities and limits of the model. Every interaction is similar to being presented with a blank canvas: What should I ask? What can I ask? Is there something that I could ask that I am forgetting about? Can I reword my prompt slightly and (potentially) get better results? This leads to a lot of experimentation.
• Expectations: We are tricked into believing the LLM comprehends what we are saying, when it's really just a giant prediction table. Then we are disappointed when it gives less-than-satisfactory replies.

Compare this to programming against a traditional API:

• On in the input side, an API constrains the vocabulary. With an LLM, everything is fair game.
• On the output side, I can guess (or learn) the effect of a given API call. With an LLM, it's all probabilistic.

Curious about others experiences here, ways to reason about these models, techniques for overcoming, etc...

💬 Jarno Montonen

🧵 conversation

What are good web based node-based programming environments for implementing simple arithmetic and boolean logic?

🍏 Eyg: Fault Tolerant Structural Language 🗓 Workshop on Live Programming 2023 💓 Emotions & Programming

Two Minute Week

💻 github.com/hitchdev/hitchstory via Colm

🧵 conversation

HitchStory is an open source bolt-on for pytest that, lets you build integration tests which autogenerate scenario-based documentation about your app.

The tests are written in type-safe StrictYAML. In the website example, running the tests generates screenshots and a GIF of the user story from playwright. These are all combined into step-by-step markdown documentation that non developers can follow that explain how your app works.

More here: github.com/hitchdev/hitchstory (including locally runnable code examples testing a REST API and a command line interface).

🍏📢 Introducing Eyg via Peter Saxton

🧵 conversation

This weeks development actually sharing my language so other people have a chance to use it.

🎥 22/05/2023, Introducing Eyg

Our Work

💓📝 Using computers more freely and safely via Kartik Agaram

🧵 conversation

I've been working on a talk summarizing my past year or so

Thinking Together

💬 Paul Tarvydas

🧵 conversation

• Are games more robust than other kinds of end-user software? Why?
• Are games in 2023 more robust than games in 1980? Why?

💬 Jason Morris

🧵 conversation

I am going to need to come up with a more robust way to allow my users to edit legislative text in a way that is user friendly, and forces them to stick to a predefined data structure. I'm wondering if anyone has tried to use tools like slate.js or ProseMirror for that sort of thing, or have other suggestions. It's legislation, so I want the editing environment to be as text-like as I can manage.

💬 Paul Tarvydas

🧵 conversation

Software Engineers do not write code.

Implementors (coders) write code.

Engineers think (deeply) about what code needs to be written, and, what trade-offs need to be made to simply make the system work.

Production Engineers think about making trade-offs so that the system is “efficient” along one or more dimensions (speed, space, cost, etc.), but, only after the initial system is working and shown to satisfy end-users’ needs.

Current popular programming languages, like Rust, Haskell, Python, etc., conflate all of these issues together, thus, making the code more difficult to design. Conflating issues together like this has a name: “cottage industry”.

Then, there’s Software Architecture, Maintenance, Testing, Q/A, Security, etc., etc.

The above pattern is visible in other, older professions, such as building construction. Software might re-use these ideas and re-purpose them for creating electronic machines.

Note, too, that more-established professions use diagrams to augment the use of written words when communicating designs (blueprints, schematics, molecular diagrams, etc.).

Note, too, that more-established professions use elements that are completely isolated and decoupled from one another. This assumption (of inherent non-coupling) is violated by most popular programming languages.

Content

📢 The Ninth Workshop on Live Programming LIVE 2023 via Mariano Guerra

🧵 conversation

The Ninth Workshop on Live Programming LIVE 2023

LIVE programming workshop. Deadline July 12.

LIVE is a workshop exploring new user interfaces that improve the immediacy, usability, and learnability of programming. Whereas PL research traditionally focuses on programs , LIVE focuses more on the activity of programming .

👓 unit.md via Kartik Agaram

🧵 conversation

@Samuel Timbó’s unit.md seems worth promoting to the top-level from 💬 #thinking-together

..a re-exploration of the Unix Philosophy in the context of modern Software Engineering and Web Development.

..similar in concept to the Unix shell; for a seasoned programmer, unit should feel like the 2D evolution of the Command Line Interface (CLI) where units' (commands) inputs and outputs (stdin/stdout/stderr) can be piped together into a graph (script).

..designed to feel visual and kinesthetic, giving the perception of Direct Manipulation of Live Virtual Objects.

Some tantalizing demos at github.com/samuelmtimbo/unit/blob/main/src/docs/start/README.md

🎥 Arc boosts let me create the aesthetic web I didn't know I wanted via João Araújo

🧵 conversation

I think this counts as making end-user programming easier

🎥 Arc boosts let me create the aesthetic web I didn't know I wanted

🎥 "Investing in Tools" Round Table Part 2 via Christopher Shank

🧵 conversation

Our conversation is split into two parts. In this part we discuss: paradigm shifts in programming tools, the viability of visual programming for general purpose programming, the pros and cons of tight coupling of tools into one bigger tool, usability possibilities that have not been explored for visual programming systems, and the things to watch out for when exploring functionally infinite design spaces.

💓📝 The Computer is a Feeling - Tim Hwang and Omar Rizwan via Jimmy Miller

🧵 conversation

The computer is a feeling, not a device.

🎥 Indigitalization: Indigenous Computing Theory - Jon Corbett via Christopher Shank

🧵 conversation

Indigitalization: Indigenous Computing Theory - Jon Corbett (at Causal Islands)

🖌 Beautiful Software via João Araújo

🧵 conversation

Have you folks heard of buildingbeauty.org/beautiful-software ? Sounds cool, but also they recommend you take the more architecture focused courses, which increases the overall cost and which I’m not sure I would be able to do 😅