⚙️ Rage Against the State Machine 🚲 Structured Focused Writing 💡 Live, Rich & Composable

Our Work

🐦 Nicolae Rusan on Twitter via Nicolae Rusan

🧵 conversation

👋 howdy folks! We just shipped an integration for Linear & Github issues in Magnet (www.magnet.run) our AI coding assistant that is powered by GPT-4.

This gives you a way to quickly take an issue, and go end-to-end on getting suggestion for relevant files, having Magnet ask clarifying questions, and having it make suggestions on how to implement the feature across your entire stack, e.g. front-end, backend, and database.

Lots of fun explorations as we’ve built this, and we’re going to be diving deeper into some of the research questions that have come up in terms of how to give AI appropriate context on the task at hand

🐦 Nicolae Rusan on Twitter: Magnet (https://t.co/hyTk0nzO28) now offers Linear & GitHub issue integration:

→ Start a workflow from a Linear or GitHub issue → Magnet suggests relevant files from your codebase for that issue → Magnet poses clarifying questions, guiding you end-to-end on features and bugs

🎥 Magnet Issues Integration - Adding a new feature around meta tags via Nicolae Rusan

🧵 conversation

🎥 Here’s a Loom video of me starting from an issue in Linear and getting to a working feature using Magnet if you want to skip the thread above:

In this video, I discuss how I am utilizing magnets to enhance the process of shipping new features. I noticed that when sharing a magnet link from our blog, the title tags and images were not updated for the specific blog posts on the blog page. To address this, I demonstrate how to select the relevant files using the linear issues integration and suggest implementing the feature. Additionally, I explore the benefits of using Next SEO and explain why it is a valuable addition. Join me as we work on this feature together!

🤖 Visual Programming in VSCode: Create Discord Bots the Easy Way via Gabriel Grinberg

🧵 conversation

Hey all 👋

I just published a tutorial on how to use Flyde (flyde.dev) to build a Discord bot - Visual Programming in VSCode: Create Discord Bots the Easy Way - an attempt to provide a real-world use-case to visual flow-based programming 🚀

Looking forward to any feedback or comment 🙏

PS: It's more beginners oriented, as that's the direction I'm taking Flyde at the moment, so expect it to be laid simpler than the usual content here 🙃

Devlog Together

💬 Kartik Agaram

🧵 conversation

Yesterday was a good day. I built a little app for someone to connect to their R server, plot a dataset based on different dimensions. Pretty trivial, but hopefully easier for them to modify than other similar apps out there.

Thinking Together

🐦 John Carmack on Twitter via Mariano Guerra

🧵 conversation

What do you think about this?

🐦 John Carmack on Twitter: Despite all the effort that has gone into it, it doesn’t look like programming language design has any real compounding power. There are better and worse languages, but other market and technical forces can swamp language choices.

⚙️ State machine: Rplot via Kartik Agaram

🧵 conversation

Last night I spent some time documenting an almost-trivial state machine that I keep getting wrong: State machine: Rplot

State machines are hard !

• We usually have one in our head when we program.
• The abstract state in my head is usually made up of multiple concrete variables in the program.
• Mutations happen to variables, but it's not obvious at each how the abstract state is changing.
• The state machine in my head often evolves, which makes documentation challenging to keep up to date. Which is why I think nobody builds documents like these.

Tell me how immutability or State Charts will solve all my problems 🙂

Content

🚲 Bike Outliner: Structured focused writing app for Mac via Eli Mellen

🧵 conversation

Is anyone else using Jesse Grosjean’s Bike outliner on mac?

As an outliner it is fairly minimal. It can’t hold a candle to something like omnioutliner or org-mode by ways of features. But the text handling and rendering is pretty gorgeous, especially at input.

📝 Bike Outliner: Structured focused writing app for Mac

Use Bike to think, write, organize. Make lists, take notes, create documents. Bike's an unusually fast outliner designed for your Mac.

💻 Project IDX via Mattia Fregola

🧵 conversation

idx.dev

📝 Project IDX

Project IDX is an entirely web-based workspace for full-stack application development, complete with the latest generative AI (powered by Codey and PaLM 2), and full-fidelity app previews, powered by cloud emulators.

📝 Who Can Name the Bigger Number? via Eli Mellen

🧵 conversation

Has anyone read Who Can Name the Bigger Number? It was just recommended to me at work

💡 Live, Rich, and Composable: Qualities for Programming Beyond Static Text via Lu Wilson

🧵 conversation

This was posted here back in March but it didn't get much discussion (at least, that's what the archive says), so I'm reposting: arxiv.org/pdf/2303.06777.pdf

📝 Do Machine Learning Models Memorize or Generalize? via Kartik Agaram

🧵 conversation

Grokking

In 2021, researchers made a striking discovery while training a series of tiny models on toy tasks . They found a set of models that suddenly flipped from memorizing their training data to correctly generalizing on unseen inputs after training for much longer. This phenomenon – where generalization seems to happen abruptly and long after fitting the training data – is called grokking and has sparked a flurry of interest .

An interactive introduction to grokking and mechanistic interpretability.

📢 Founding Engineer at Val Town 💻 Wikifunctions ✊ Local-First Software

Devlog Together

📝 Rational Mechanics and Natural Mathematics via Kartik Agaram

🧵 conversation

Today I want to learn just enough topology to make sense of boole.stanford.edu/pub/ratmech.pdf

Thinking Together

💬 Eli Mellen

🧵 conversation

You know that thing when playing Pokemon games where after you throw a Pokeball you frantically tap the action button to ... do something? It is never made clear if this helps or even does anything at all.

What are other ghost-mechanics like this in games or software that you know of, where folks often take actions that aren’t clearly signposted to actually do anything?

The most immediate other example that comes to mind is swiping apps away in the iOS app switcher, but that isn’t exactly the same thing, since, even if it doesn’t free up memory, it is a direct interaction that alters state (removes options from the app switcher).

🕹️ Outer Wilds via Josh Cho

🧵 conversation

Retrofitting of Medium

I tend to think every time a new medium is introduced, all the contents of the previous medium are ported over, without regard for fully understanding the new medium . For instance, films matured when it stopped porting over books, games matured when it stopped porting over movies, etc. An excellent example of this is Outer Wilds, a space-exploration time-traveling game which is simply impossible to recreate in any other medium. It fulfills the medium.

Given that, I think two new forms of medium are being introduced in the next 5 years: LLMs and VR. If we accept the supposition that there will be a lot of retrofitting of the medium, i.e. chat into LLMs, games into VR, what are the content that will truly fulfill the mediums of LLMs and VR?

💬 Denny Vrandečić

🧵 conversation

Is there a reasonably decent JavaScript library that allows me to have a reasonably terminal-y experience in the browser, so I can implement a shell? Ideally with history, autocomplete, colors, etc. - and then with the ability to add DOM nodes too, so I can click, show images, etc. Preferably no backend necessary.

Content

🎥 Myths and Mythconceptions: What does it mean to be a programming language, anyhow? via Paul Tarvydas

💻 Wikifunctions via Mattia Fregola

🧵 conversation

" Wikifunctions is a Wikimedia project for everyone to collaboratively create and maintain a library of code functions to support the Wikimedia projects and beyond, in the world's natural and programming languages."

Includes an interesting sort-of-structured-editor in the playground too

📕 Real Life in Real Time via Walker Griggs

🧵 conversation

A new book caught my eye and maybe it'll catch yours?

The cultural ramifications of online live streaming, including its effects on identity and power in digital spaces.

Some consider live streaming—the broadcasting of video and/or audio footage live online—simply an internet fad or source of entertainment, yet it is at the center of the digital mediation of our lives. In this edited volume, Johanna Brewer, Bo Ruberg, Amanda L. L. Cullen, and Christopher J. Persaud present a broad range of essays that explore the cultural implications of live streaming, paying special attention to how it is shifting notions of identity and power in digital spaces. The diverse set of international authors included represent a variety of perspectives, from digital media studies to queer studies, from human-computer interaction to anthropology, and more.

✊ The Cloud Is a Prison. Can the Local-First Software Movement Set Us Free? via Ivan Reese

🧵 conversation

A fun but slightly puffy article about local-first in Wired

🐘 nilesh (@nilesh@fosstodon.org) via Nilesh Trivedi

🧵 conversation

Test-driven development has the potential to turn #programming into a gameplay-like experience. Add live collaborators, real-time evaluation of relevant tests, visual feedback etc.

I had built this toy more than a decade ago. The tests would be evaluated on each keystroke and visually indicated as Red vs Green. Felt like fun.

Would be great to have this as a VS code extension.

🎥 Finding Meaning in Christopher Alexander's "The Nature of Order" via Kartik Agaram

🧵 conversation

by Stefan Lesser

This is the most insightful talk I've watched in recent memory.

Transcript: stefanlesser.substack.com/p/finding-meaning-in-the-nature-of

📢 Founding Engineer at Val Town via Steve Krouse

🧵 conversation

If you're in NY and wanted to work on a FoC company full time, Tom MacWright and I are hiring at Val Town. We're trying to make programming more fun, composable, and light. I've tried to take many of the ideas I've learned from this community and package them up into a practical product that's VC-fundable. Come join!

💬 Josh Justice

🧵 conversation

(Hopefully this question isn’t too far outside of “coding” and into “using”.) I’ve always had an interest in associative data management, but I’ve never found a tool I love for my use case. What I want to be able to do is catalog and visually explore:

• Ideas in some area of research
• Sources for those ideas: who has presented them
• Chains of reasoning: person A argues that because of ideas X and Y, therefore Z is true
• Commentary on those ideas: supporting, refuting, adapting

General mind-mapping tools don’t feel structured enough, but coding it from scratch has been intimidating. It feels like this must exist and I must just be bad at finding it. Do any of you have a tool you like for this use?

🎵 Zing: Audio Integration Library 🧠 Hippocampus for LLMs 🏹 What are embeddings?

Our Work

🎵 Zing - A Simple Audio Integration Library via Chris Maughan

🧵 conversation

I recently made my audio components into a module; handles setting up audio, doing FFT, connecting to Ableton link, reading and playing midi. There's a video: github.com/rezonality/Zing

Devlog Together

📝 (Experimental) Converting Point-Form Notes into Text Summaries via Paul Tarvydas

🧵 conversation

Experiment: Converting Point-Form Notes from JSON Into Text Summaries using AI

JSON point-form notes to AI summary I created a page of "cards" in a Kinopio webpage (called a "space"). I exported this page to JSON. I uploaded the JSON to my GitHub Pages blog. I grabbed the n…

💬 Jason Chan

🧵 conversation

I’ve been re-building Subset.so to make it way easier to reuse templates directly in the editor. The idea is that you should be able to build beautiful spreadsheets without starting from scratch. For example if you want to build dashboard with a P&L and inputs, you can find both templates and drop them into the same editor. The concept is pretty common in design editors like Canva where you can look up and drop in design elements, but haven’t seen it done with spreadsheets before. Here’s a 7 second demo

🎥 hero multiplayer video

💬 Marcel Weiher

🧵 conversation

I implemented support for property paths in my native compiler.

code

So more expressive than something like sinatra, but running at cool 140K requests/s.

The dichotomy between expressiveness/comfort and performance is a false one, a bit like the one we used to have between user-friendly but crashy client-operating systems and solid but unfriendly server operating systems. Now my phone and my watch both run Unix.

Thinking Together

💬 Martin Shaw

🧵 conversation

Hi all, for those of us who have an interest in learning about how to build a more wonderful future and who wish to be inspired by those rare few actually building something different, I recommend that you visit and enjoy the Norman Foster exhibit at the Centre Pompidou which ends on the 7th of August.

Those who are unfamiliar may not see the relevance of a building architect's work to programmers and software / hardware designers, but I assure you that his long history of work is exceptionally relevant.

His designs are a deeply-considered human-scale 'high-tech' alternative to traditionalist buildings and to postmodern buildings. With tonnes of innovative features which had never been implemented before and which seemed obvious and common-sense after the fact.

This work sounds a lot like what we are working on in the software, hardware and otherwise industrial realms.

If you are in Paris or are able to get to Paris, entry is 17 euros.

I'll be going on the 7th of August if anyone is around for drinks, lunch and/or a chat 🙂

📝 Norman Foster

A major figure of world architecture who is often seen as a leader of the "high tech" trend, British architect Norman Foster has designed many iconic creations throughout the world. 

🧠 Experience CozoDB: The Hybrid Relational-Graph-Vector Database - The Hippocampus for LLMs via Peter Saxton

🧵 conversation

I've found this article on using CozoDB (A relational/graph database) as the hypocampus for AI. It's an interesting read though it's probably best to leave it explained in their own words docs.cozodb.org/en/latest/releases/v0.6.html

What do people think, is this approach plausible? Will it make a notcable different to what AI's can do? The author has also written their own knowledge management tool so interesting all round.

Content

🏹 An interesting paper on embeddings via Eli Mellen

🧵 conversation

An interesting paper on embeddings; relatively accessible to a lay audience, but lengthy.

🧰 explainshell.com via Beni Cherniavsky-Paskin

🧵 conversation

explainshell.com and showthedocs.com are a thing of beauty. Why don't we have something like that integrated in our IDEs/REPLs/terminal?

Both are interactive — go on, take a non-trivial shell / SQL command from your history and plug it there.

I'm not sure I've seen that level of doc integration in any language env, yet an interpreter/compiler doing the actual parsing and name resolution should be well positioned to offer it, no?

📐 Geometric Algebra 📢 Riverbed: build mini-apps ✏️ Convivial Text Editors 📑 Computational Culture

Two Minute Week

💬 Maikel van de Lisdonk

🧵 conversation

Hi, I am experimenting with functionality to be able to inspect "path executions" in a visual flow (the flow in the video is adding random values to an array of which the total sum is calculated): in the short video you can see me inspecting the last executed path with the slider on the bottom.. with this you can inspect the different stages of an executed path. After a flow has been run, the last path can be inspected.

With the slider on the right you can switch between paths which have been executed before.

In the beginning of the video I've pressed the 'run' button multiple times, all these executions can be inspected with this slider.. and the current execution path that is being inspected can be inspected further with the slider on the bottom.

🎥 Demo Video

🎥 JSON decoder via Peter Saxton

🧵 conversation

My language is now "JSON complete"

Our Work

📐🎥 Geometric Algebra as a tool in technical communication via Hamish Todd

🧵 conversation

Hey folks, I've been working on "Tools for thought" based on GA for a while, and I'm going to start streaming development of my current one on Tuesday at 4pm. Here's the current back catalogue youtube.com/watch?v=hR-MQm3c13Q&list=PL9a8DfUJQcuCAJ2a1vqpk3rcPW4q_Isnz&ab_channel=HamishTodd although my next one will be more about coding something new and (hopefully) answering GA audience questions 🙂 here's the link I'll be streaming to twitch.tv/hamish_todd

📢 Announcing Riverbed Beta via Josh Justice

🧵 conversation

Hey folks, I’ve just launched the beta of the side project app I shared a video about a few months ago. I’ve settled on the name Riverbed. It allows you to create mini-apps to track your personal information on cards, including columns that automatically filter your cards and buttons that allow you to configure simple actions on them. It’s maybe an “almost-no-code” system? You can choose actions from a list instead of typing in scripts.

Some of the things I’m exploring include:

• How many types of app this card-and-column UX is helpful for,
• How much we can accomplish in this domain in an “almost-no-code” approach, where instead of a scripting language we have a set of actions to choose from a dropdown, to make it more accessible to non-programmers, and
• To what degree a focus on matching the UX of non-user-configurable apps is achievable or the best use of effort

It’s free to use and OSS. More info and video here, including ideas for how I might develop it in the future; I would love any input folks in this community would like to provide! about.riverbed.app

📙 WebAssembly from the Ground Up via Mariano Guerra

🧵 conversation

Today with Patrick Dubroy we are officially launching the Early Access of our book WebAssembly from the Ground Up: wasmgroundup.com

We decided to go "digital first" to support features like interactive inspectors, code highlight on hover, REPLs for examples and other ideas from the Explorable Explanation world.

The book explores the fundamentals of WebAssembly by building a compiler for a simple programming language step by step using JavaScript and OhmJS

We would love to get your feedback!

🧲 magnet.run via Nicolae Rusan

🧵 conversation

(I shared a very early version of Magnet when it was just a Mac Desktop app - but now it fully runs on the web)

We just shipped a web version of 🧲 Magnet magnet.run - an AI coding assistant.

The sign ups are growing pretty quickly and there’s a lot of love from the early users. We think you’ll like it too. It’s free to use if you put in your own OpenAI API key, and over time we’ll charge for more advanced features like integrations and access to the latest unreleased models.

If you’re using ChatGPT to help with coding tasks, and finding yourself copying and pasting, Magnet is similar, but built specifically for working with code. You can open local code repos, connect GitHub issues, and pick files and issues as context of for the task at hand.

Try it at : magnet.run

🎥 A Quick Demo of Magnet

There are lots of interesting future of programming explorations we’re thinking about in the context of Magnet, and hoping to write more about it soon. Would love feedback from folks / suggestions on what you would like us to build next!

💡 Mariano Guerra

🧵 conversation

Some reasons to make WebAssembly from the Ground Up a digital first book:

1. Code highlight on hover

2. Interactive WebAssembly binary module inspector with "hexdump" and outline views

3. Copy code snippets as you go or "Copy up to here" on checkpoints

4. Open checkpoints in Stackblitz, run tests and play with the code

5. An interactive Wasm interpreter with builtin spec instruction reference (GIF in replies, can't attach after creation)

💬 greg kavanagh

🧵 conversation

QuickPoint. Adding a video while editing on mobile while thinking about Alan Kay, images, symbols, chickens and eggs.

🎥 Demo Video

Thinking Together

📝 What are the Steps in Creating a Compiler? via Paul Tarvydas

🧵 conversation

• What are the Steps in Creating a Compiler?
• What do we need to know to compile a piece of code?
• Why Should I Care?
• How To Cheat?

💬 Jason Morris

🧵 conversation

The default behaviour for a validated text field in Blockly is to turn the background red while the value is invalid, and if the user hits enter (or nvaigates away from the field) while the field is red, abandon the change and return the field to the previous value. This feels broken to me. In the visual interface, if you try to put something somewhere and it doesn't "fit", the piece doesn't go back where it started. It stays close to where you tried to put it, but far enough away to visually indicate that it isn't connected. So you get immediate feedback that it didn't work, and what was done instead. But in the text field, if I have "value" and I change it to "value$", and the dollar sign is invalid, the field will only turn red between when I hit dollarsign and when I hit enter, and then it will go back to the previous value, and just hope I notice that it didn't do what I wanted it to do. For people who look at the keys while typing, that's not going to work. Blockly steadfastly tries to avoid invalid state, presumably because syntax errors aren't any fun. But in the visual interface it accomplishes that by making invalid syntax impossible to generate, and when it modifies the syntax for you to keep it valid, that's easy to see. Here, it lets you type an invalid value, let's you hit enter, and the fact it didn't work is potentially invisible. It feels like it should be possible to do better. Has anyone seen an interface for entering values into a text field that solves this problem? Where the field maintains a valid value, starting with a default, but it also allows you to maintain a view on failed attempts to modify it, so that you can correct them? Should the screen just go modal, not responding to "enter" or clicks outside the editor while the value is invalid? Should the failed attempt to change it be noted somewhere? Or is maintaining valid state in text fields a silly goal, and instead you should just throw errors at a later step, or something?

💬 Mariano Guerra

🧵 conversation

do you use drag & drop on gmail?

why? why not?

Devlog Together

💬 Jason Morris

🧵 conversation

Yesterday, I got an email from someone who saw my demo asking if he could come work for me. (I don't have staff.) At the same time I was writing an email trying to persuade my boss to extend my contract for at most one more year. Just goes to show there's a big difference between success and survival.

✏️💬 Jimmy Miller

🧵 conversation

I've been working on the plugin system more for my editor. Each of these panes are a completely separate web assembly modules. The tokens and token kinds are provided by another separate module that communicates with rust analyzer. Still very early days, but exciting that I was able to whip up a simple little UI for helping me map colors to tokens rather than needing to do it manually.

Content

📑 Computational Culture via Eli Mellen

🧵 conversation

The 9th issue of Computational Culture just dropped.

As always, Computational Culture serves as a transdisciplinary forum for the development of Software Studies—a field that is growing and transforming. In this issue, there is much evidence of this process, with diverse contributions from multiple locations, using varied conceptual tools, and interacting with a wide array of broader concerns and debates.

🐦 Tweet from @cdmblogs via Florian Schulz

🧵 conversation

Interactive music programming that fits in one view. There’s something intriguing about being able to see the full system and not needing to switch between windows. Organized clutter? Stable complexity?

🐦 2020 is the insane, single-window beat machine from the future

🐦 Andi on Twitter via Justin Blank

🧵 conversation

Hopefully not too silly, but Copilot has an opinion on NoCode twitter.com/Nexuist/status/1682783966074486786

🐦 Andi 🇦🇱🇺🇦 on Twitter: copilot was spitting here

👓 Live Coding in VR 🎮 Future of functional logic languages 🖱️ AI: First New UI Paradigm in 60 Years

Our Work

💬 Grant Forrest

🧵 conversation

I've had this idea rattling in my head to make a frontend framework that's only signals, and after almost a year of maturation I finally put down some code today. Genuinely surprised this works.

I'm curious where it starts to break down. It's not like modern frameworks are unaware of signals, most feature them heavily, so there's probably some reason they haven't gone all-in on them too, right?

I'm using tldraw's lovely signia for signals implementation, hence the first param of atoms being a 'name' and not meaningful for execution. This also gave me an excuse to read signia 's source and discover their clever trick for tracking atom inheritance which is pretty neat.

🎥 Demo Video

🏗️ Coil-Lang Structural Editor (WIP) via Marcelle Rusu (they/them)

🧵 conversation

I've started to work on a structural editor for my language coil coil-editor.netlify.app

It's still early & buggy, but the idea is to directly turn the AST into html with contenteditable for leaf attribute nodes.

So an expression like:

document.body

which is the coil AST:

{type: :property_lookup, lhs: {type: :id_lookup, name: "document"}, property: "body"}

Turns into:

<div data-kind="property_lookup">

  <div data-attr="lhs">

    <div data-kind="id_lookup">

      <div data-attr="name" contenteditable>document</div>

    </div>

  </div>

  <div data-attr="property" contenteditable>body</div>

</div>

And now we can easily query this expression with css selectors. So all the syntax highlighting AND formatting is done in css. It also means that static analysis can be done using querySelector.

🔗 The Power of the Link via Duncan Cragg

🧵 conversation

My latest Object Network Lab Note is out!

Please feel free to comment either there or here!

Small stuff that points to bigger stuff

💬 greg kavanagh

🧵 conversation

Added some filters and shadows to QuickPoint. "We are mere shadows and filters Horatio"

🎥 Demo Video

👓🎥 Kairon - Open Source Live Coding In VR via Felipe Reigosa

🧵 conversation

Hey Guys I've been working on a way to code in VR in an effective way. The code is open source and is available here: github.com/felipereigosa/kairon, for the full video where I show how it works and build a few things with it, let me know if you like it.

🎥 Trailer Video

Thinking Together

💬 Walker Griggs

🧵 conversation

I've been thinking a lot about apprenticeships over the last year and specifically the lack of apprenticeships in tech.

My mental model of apprenticeships is primary formed around how they apply to the arts -- people learning a craft from a single practitioner who has worked their life to develop a personal style or system. But apprenticeships also exist in trade, maybe even more so. Fundamentally, apprenticeships facilitate knowledge transfer -- all industries can benefit from that, no? So, I wonder why apprenticeships are far less common in software?

• Is it because so many industry vets were themselves self taught and so that mindset has lingered?
• Is it that so much of our industry is focused on access, democratization, and open sharing of information?
• Could it be that we need to train more software engineers than we have hours in the day, and that need for more qualified minds has pushed us beyond the 1-on-1 learning paradigm and towards bootcamps etc?
• Maybe so much of software and the knowledge around it is already accessible, so apprenticeships are just overkill? That said, there are still pockets of software where subject matter expertise and knowledge silos outweigh what is either 1) commonly taught in schools or 2) generally available.
• Software doesn't have the same requirements around professional certifications -- could that be at play?

Generally, do you all think there's value in apprenticeships or should we (continue to) move in the other direction entirely -- teach the masses? In that sense, I could see the argument that apprenticeships border on nepotism and are actually a form of gatekeeping. Have any of you been part of a formal apprenticeship (on either end)? If so, what conditions made that possible?

📝 The Austral Language Specification: Statement Orientation via Daniel Buckmaster

🧵 conversation

What we talk about when we talk about expressivity

I enjoyed the little tangent on expressivity in the latest episode. I've had thoughts on this recently and it prompted me to skim Felleisen's paper. I really resonated with the hosts' reframing of expressivity as being the part of the language that's oriented towards the programmer, not towards the machine.

I currently think that most programmers, when talking about "expressivity", actually mean essentially two things:

• I can use my own words
• I am not restricted by grammar

These things are strongly tied to writing, as that's still how we do most of our coding.

"Using my own words" is literally that - in any given chunk of source text, how many of the words were chosen by the programmer (e.g. to be particular to their domain or their theory of the program) and how many were specified by the language or environment? Punctuation, I think, also counts as words the programmer didn't get to choose. Random examples:

• In Ruby, one can create little DSLs where almost all words in a specific part of the code are "my own words"
• In assembly languages, the programmer can choose almost none of the words (except labels?)
• Being able to rename imported symbols lets the programmer choose their own words in specific contexts (same goes for type aliases, etc.)
• Languages with few keywords should tend to have more words chosen by the programmer... or at least, by the authors of the standard library?

I equate being "unrestricted by grammar" roughly to whether a language is statement-oriented or expression-oriented. The Austral spec has a great section on why it chose to be statement-oriented, and concludes that "a statement-oriented syntax is less simple, but it forces code to be structurally simple": austral-lang.org/spec/spec.html#stmt-orientation

In Austral, it's an ideological choice to force programs into a certain shape. But in general, it seems to me that languages with less "grammatical restrictions" in their parser are described as more expressive. Maybe this is just correlation with other features of those languages.

I'd love to know how everyone else understands "expressivitiy" when we talk about programming.

💬 Duncan Cragg

🧵 conversation

I think this topic, based as it is on personal experience, deserves better visibility, so hopefully Rachel won't mind my reposting it here! 🤗

[July 13th, 2023 9:38 PM] rachel: hey both! thanks for replying here.. as per your question Joe, I would consider someone a software engineer if they know how to code - whether they have a CS degree, or did a bootcamp, or learned on their own. Someone who can code and build applications. I have no formal training in coding. However, I am excited about the potential of AI to help me make an app by generating code for me.

To answer your question Duncan - I've mostly been using a combination of asking chatGPT for the steps and code, and also using an app I am working on with a cofounder called Sublayer. We noticed that the chat interface is not really the best interface for building (and changing) complex apps, but we're still exploring the right workflow for it. Definitely eager to learn from this group how others are getting the best code generation out of the existing LLMs.

🤖 Marvin: A lightweight framework for building AI-powered software that's reliable, scalable, and easy to trust via Scott

🧵 conversation

I've been thinking a lot about the patterns and architectures we're going to see start to emerge that lend themselves well to being written by generative AI and came across this technique being used by a library called Marvin (github.com/PrefectHQ/marvin) where they limit the tokens the LLM can respond with to just a single token corresponding to a value in an enum. They then have it respond with the value as the response to a natural language query. This is extra interesting because responding with a single token is relatively fast and cheap.

The example they give is using it in routing:

    USER_PROFILE = "/user-profile"

    SEARCH = "/search"

    NOTIFICATIONS = "/notifications"

    SETTINGS = "/settings"

    HELP = "/help"

    CHAT = "/chat"

    DOCS = "/docs"

    PROJECTS = "/projects"

    WORKSPACES = "/workspaces"





AppRoute("update my name")

# AppRoute.USER_PROFILE

But I feel like there's a seed of an idea here that points to what a piece of an LLM-core architecture may look like. I experimented with the idea a bit in chatgpt earlier today (screenshots attached) and I'd love to know if anyone finds this interesting or has any thoughts/opinions.

Content

🎮🎥 Beyond functional programming: a taste of Verse. Simon Peyton Jones & Tim Sweeney | Lambda Days 2023 via Mariano Guerra

🧵 conversation

Beyond functional programming: a taste of Verse. Simon Peyton Jones & Tim Sweeney | Lambda Days 2023

Verse is a new programming language, being designed at Epic Games as the language of the metaverse. Verse is a functional logic language, with a bunch of innovative ideas. Like Haskell, Verse is declarative (a variable in Verse stands for just one, immutable value), and higher order (lambdas are first class). But Verse goes well beyond Haskell, with existential variables, unification, expressions that yield multiple values, and much more besides. In this talk we'll give you a sense of what functional logic programming is about, what it looks like to program in Verse, and how we can give meaning to Verse programs using rewrite rules.

🖱️ AI: First New UI Paradigm in 60 Years via Mariano Guerra

🧵 conversation

AI: First New UI Paradigm in 60 Years

Summary: AI is introducing the third user-interface paradigm in computing history, shifting to a new interaction mechanism where users tell the computer what they want, not how to do it — thus reversing the locus of control.

💡 Invisible Details of Interaction Design via Mattia Fregola

🧵 conversation

What makes great interactions feel right?

🦋 gt4atproto: a dedicated environment for AT Protocol via Kartik Agaram

🧵 conversation

Exploring BlueSky's AT protocol in Glamorous Toolkit

gt4atproto is an environment for AT Protocol built in Glamorous Toolkit (GT). It covers several things at different levels of abstraction such as:

• Creating posts and threads from inside the knowledge management system.
• Working with a server through AT Protocol.
• Streaming and pagination support out of the box.
• Inspecting and visualizing results.
• Code generation from lexicons to Smalltalk code.
• Dedicated styling and completion support for editing lexicon JSON files.

🔳 Interpolating Polygons via Mattia Fregola

🧵 conversation

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