💾 Riffle: Reactive Relational State 🪜 Prolog Meta-interpreters 💻 Deploy Functions as Services

Two Minute Week

🎥 A Visual Summary — Entity Graph via Pawel Ceranka

🧵 conversation

We’re experimenting with different ways of summarising information visually.

This a simple one where we get ‘named entities’, group and lay them out as a tree.

(other categories can be added of course based on anything that an LLM can produce)

To me at least there are couple of interesting things in this space:

• interactions

• pagination (done!), sorting, filtering, (re-) moving of the nodes

• bidirectional connection to the source (e.g. navigating to a particular mention in the parent block,) and canvas (drag and drop of the nodes to expand on canvas)—cf. the video

• multiple sources + analysis & comparison

• e.g. a graph that answers the question of what are some common themes, ideas, entities in two pieces of information (e.g. a video lecture and a webpage)

• tools for extending the graph

• by search

• by generative AI

• by custom/manual annotations

I would of course be very grateful for comments on any of the above 🙏

Wonderful weekend to you all 🍹

🎥 Save and Seal CodeParadise image via Erik Stel

🧵 conversation

CodeParadise is a (Pharo) Smalltalk project to create web applications using Smalltalk only (and HTML/CSS 😉).

A tiny Smalltalk image runs inside the browser and performs all the UI logic. Normally applications created with CodeParadise have a highly interactive character and communicate with a server environment.

A new feature allows a running tiny image to be saved and restarted later as a Single Page Application. A sealed snapshot is made, meaning the connection with the server environment is removed. All code running inside the browser (in the tiny image) is saved in the snapshot as well as the current DOM. After the snapshot is restarted the application will create the same DOM structure and rehydrate the WebComponents and you'll have a running application again!

For a short video see: youtu.be/9YUXYuo_HaM

Or go to the resulting SPA at: codeparadise.nl/blog-example (open the browser inspector to see all the WebComponents)

Happy coding!

Our Work

🎥 Build and deploy as continuations via Peter Saxton

🧵 conversation

Latest update from my project. This has finally got me to the point where I can consider deployment as just passing continuations from a build script to a server. The same is true for a client just being a continuation from the server. I think I need a better name for what I'm doing. In this is the video I try and explain it.

💻 Unison: A new approach to Distributed programming via Stew O'Connor

🧵 conversation

at unison-lang.org we're getting ready to open up the ability for users to easily deploy any function from HttpRequest -> HttpResponse as a web service. here's a simple example of what one might look like: stew.unison-services.cloud/s/dice-roll

🎥 UI Combinators / Regular UI Expressions via Mariano Guerra

🧵 conversation

🧬 UI Combinators: express complex UIs by composing a small set of combinators and terminals

🌳 Combinators: Option, Alternatives, List & Record

🍁 Terminals: Int, Float, Bool, ConstantSet (select), Text, Color, Date, Time etc

Devlog Together

🐦 Chris Rabl on X via Chris Rabl

🧵 conversation

Re-hashed a prototype from wayyyy back and iterated on it (two demo videos in the thread)

There's something to be said for letting ideas "marinade"... I was working on an outline today and that got me thinking about the Layered Text prototype I built almost 3 years ago (link in the :thread:). With a little encouragement from @niveor, I decided to give it a go:

🎥 visual flow: traffic light via Maikel van de Lisdonk

🧵 conversation

Hi,

I am working on a visual programming system to allow for combining multiple visual programming paradigms and not just flow-based-progamming. Finally I've made enough progress to my project to make a small video of it again: 🎥.

In the video you see a very simple statechart for a traffic light including the visualisation and other needed logic (it also has timers, gates, splitters, a html-node with support for expression-script and a bit more). The traffic light also shows a countdown when the light is red and will countdown to 0 and show a green light again.. all still very simple offcourse.

In the video you can see that the running of the flow is also being shown by those animated elements which move through the flow... since I want to prevent "spaghetti", I've created some node-types that allow for triggering other nodes without having a physical connection. Currently it's not clearly visible (except by text) which nodes are invisibly connected to what node, but I have some ideas on how to improve that. But that's for another video.

The upcoming months I want to focus on improving the UI, interaction and fix bugs to be able to put this online somewhere so it can be tried out and I hopefully can collect some feedback.

Greetings, Maikel

Thinking Together

💬 Patrick Connolly

🧵 conversation

hey all! i was at a future of coding meetup maybe 6 months ago (at Newspeak in London UK), and someone gave an amazing presentation showing what I think was a collab drawing tool that continuously scrolling , which I think used some sort of service to handle websockets between a lot of ppl. Anyone recall this and have any hints on what this tool, services or person was called ??? THANK YOU

Content

💾🎥 Geoffrey Litt: Riffle - Reactive Relational State (Local-First Meetup Berlin #1) via Marcelle Rusu (they/them)

🧵 conversation

Local-first has got me actually optimistic for future of mainstream app dev.

So much complexity arises from the many client - 1+ server architecture.

📕 CS 6120: Advanced Compilers: The Self-Guided Online Course via Eli Mellen

🧵 conversation

Has anyone checked this out? CS 6120: Advanced Compilers: The Self-Guided Online Course

It covers universal compilers topics like intermediate representations, data flow, and “classic” optimizations as well as more research-flavored topics such as parallelization, just-in-time compilation, and garbage collection. The work consists of reading papers and open-source hacking tasks, which use LLVM and an educational IR invented just for this class.

🛸 Why Fennel? Fennel is a programming language that runs on the Lua runtime. via Mattia Fregola

🧵 conversation

📝 Alienation, Marvelous Pursuits and the New Nomadic Sciences via Devine Lu Linvega

🧵 conversation

On Unity

🎙️ EP03: Alternatives to Modern Programming Languages with Ramsey Nasser and Jon Corbett – Fission via Christopher Shank

🧵 conversation

This month, we are joined by special guests Ramsey Nasser and Jon Corbett to discuss their work creating Arabic and Cree programming languages, respectively.

For episode 3 of the Causal Islands Podcast, we are joined by special guests Ramsey Nasser and Jon Corbett to discuss their work creating Arabic and Cree programming languages, and what they learned in the process.

🤖

🪜🎥 Prolog Meta-interpreters via Devine Lu Linvega

🧵 conversation

Excellent talk on meta-interpretation in Prolog

💬 Jason Morris

🧵 conversation

Apart from things like the langchain and hugging face blogs, does anyone have any good resources for the latest tools and techniques for LLM prompt engineering? I need to bone up, this week.

Present Company

🍰 Don't Do Math via Ivan Reese

🧵 conversation

Some personal news: I just released my first new song in 9 years. You can listen to it here.

Can I find a way to make this even vaguely relevant to you, members of the FoC community, other than merely the personal connection we share? Why yes! It's a song about meaning and interpretation, things that I love thinking about when programming and detest thinking about when creative writing. I had to pick some subject, thus: what's something wryly confrontational I can say to all my programmer friends? Don't do math! Stop it. Don't think about it. Don't look for meaning. Stop formalizing, stop proving. Stop saying "easy to reason about".

For those who enjoy this sort of thing, the song is also loaded with music-math "jokes" — collect them all! Microtones, time signature changes, polyrhythm, polymeter, isometer, hocketing, … I even count-in at the beginning (and yes, the first bar comes in waaay early).

Enjoy.

🌱 An approach to computing and sustainability inspired from permaculture - Strange Loop via Devine Lu Linvega

🧵 conversation

Working on my slides for the strange loop talk right now.

I'm not sure how relevant to FoC it is, as it's a tiny bit more like.. the past of coding, but I'm pretty excited for it, the slides are encoded in a little slideshow scripting language I made up, for a program(Adelie) written in my favourite language in the world, running on a system built from garbage held together with strings and duct tape! Should be fun : )

Strange Loop (Sep 21-Sep 22, 2023 - St. Louis) is a conference for software developers covering programming langs, databases, distributed systems, security, machine learning, creativity, and more!

💭 Conviviality: Community or Independence? 🛸 Prototypes: Object-Orientation, Functionally 🎥 Lisp DevOps

Two Minute Week

🎥 Lisp shell for deployments via Peter Saxton

🧵 conversation

I've implemented a Lisp REPL/Shell for accessing my deployment infrastructure and other parts of my personal compute resources. It uses the same AST/interpreter as the rest of EYG.

🎥 Folding & Unfolding UIs Prototype via Mariano Guerra

🧵 conversation

Folding & Unfolding UIs Prototype

💡 Get the simplest UI possible for the level of detail you need

🪗 Unfold UI components to get more fine grained control

🤏 Fold back to go back to a simpler representation preserving as much of the content as possible

Our Work

🐦 Adam Menges on X via Nick Arner

🧵 conversation

Hi all, a project I’ve been helping out with is looking going to be looking for Test Flight users soon - more details here 🙂

🐦 Adam Menges on X

Thought I’d share a little project a few of us have been tinkering away on.

Built entirely on an iPad, with the prototype itself created by @GK3 awhile back, all credit goes to him

📝 Distributed == Relational via Guyren Howe

🧵 conversation

This might be of interest to folks here:

📝 Distributed == Relational

Perhaps surprisingly, distributed systems are naturally relational

💬 Janne Aukia

🧵 conversation

I'm building an automatic brand (and theme) design tool. Any comments are welcome 🙂. Current plan is to add signup + payments + basic documentation / export functionality, and then launch it.

🎥 ktulu's babi demo (with voice over) via Jean-Louis Villecroze

🧵 conversation

I have been trying to create a video demoing some of the work I have been doing for the past 3 years (on the side) and it’s turning out to be a lot harder than I expected … I do have phone anxiety but this isn’t a phone 😳 Anyhow, feedback welcomed. I will be re-recording it. I know it’s way too long and that I am yapping too much …

Thinking Together

💻 playb.it via Jeremy Vuillermet

🧵 conversation

Hi! I recently noticed how I struggle regrouping things by topic/task/project on my different devices (laptop, phone). Quite frequently, one topic can be spread across 5+ apps/website. My less than ideal solution is to introduce another aggregator app (roam research in my case) and paste & tags different links when possible. Arc browser spaces also helps with that. The issue is that it's very manual and not worth for small ad hoc topic and researches.

Is this a problem you are facing? How do you solve/work-around it? Any interesting links on the topic?

I believe it could & should be solved at the OS level and found really interesting project: playb.it, MercuryOS, alexanderobenauer.com/labnotes/000 but I feel like there should be more

💭 by Kartik Agaram

🧵 conversation

Question for people who've read Tools for Conviviality

Do you think "convivial" in the Illich sense has connotations of communality? Like, having a strong sense of membership in a coherent, shared community?

I'd never really thought of it that way, but I was just chatting with a friend who's only skimmed the essay, and had that impression. Obviously I think I'm right, but I also wonder if I've been reading my own bias towards independence and self-sufficiency into the essay. I'd appreciate thoughts. "The future is a disagreement with the past about what is important." And at this point it doesn't matter what Illich intended, only what we in the audience tend to make of his words.

If we tend to agree that conviviality is independent of social arrangements, and that it is equally applicable to gregarious people who like to be cheek by jowl with others and introverts who are more off on their own, this might suggest that the word "conviviality" isn't an ideal term in the year 2023 for a value a lot of us tend to aim towards here. It was a frontrunner in our long thread about renaming FoC (linen.futureofcoding.org/t/42821/here-s-a-big-one-apologies-in-advance-to-everyone-for-the-un) but perhaps it has some distracting connotations.

🤝 peernet.go via Andreas S

🧵 conversation

Hello FoC Community 🙂

I have something in mind which I don't know exactly how difficult it i or even possible so I'm going to ask for your council here. I have some files 2-4 GB and I want to share those with a friend. What would be the best way to do so? Assuming that I don't want to use dropbox or google drive. I vaguely remember that there was a programm called wormwhole or somethign which did this using python. I would kike to have something in go which has nice cross OS binaries. This looks nice but I would want to have a simple exchange application wher eI can use it instead of a lib to be implemented. github.com/filecoin-project/go-data-transfer/blob/master/benchmarks/testnet/peernet.go Another question - fundamental in nature- if I join a P2P net what do I need to exchange with my peer - out of band such that we can exchange files through the P2P network. ie.e. how do we find each other? Thank you for your thoughts and ideas.

💬 Grant Forrest

🧵 conversation

Branching out from the discussions about the current state of AI agents vs. how they were imagined in the text from the recent podcast episode...

I was glad to hear our hosts were on a similar thought-track when discussing the "send this draft to the rest of the group and let me know when they've read it" example regarding how programmers tend to parse the last bit as "let me know when the metrics indicate they scrolled to the end" (etc) whereas a human agent would parse it as "and follow up with them after a reasonable time to ask if they've read it or not."

One thing that struck me was the number of times I've told a white lie in that kind of scenario. Yes, I read it! (No, I haven't, but I just pulled it up when you asked and I'm skimming it now before the meeting starts).

Dishonesty with the metrics-mindset takes a different form. In simple forms, it's like terms of service pages which gate the "agree" button behind a scroll value... You scroll to the end to lie. But if the designers of those metrics were somehow able to perfect them (eye tracking? a quiz at the end?) then an AI agent could force a more accurate/truthful answer from you.

All that to get to my point... Do we have a right to lie about this stuff? How important is it for us to be able to present less-than-truthful representations to other people even if the medium is via an AI agent? If we don't include this concern in our designs, are we facilitating a world of micro-surveillance of coworkers and friends?

Content

📝 WASM: Big deal or little deal? via Mattia Fregola

🧵 conversation

WebAssembly is getting a lot of hype, but is it the game-changer some think it is?

🛸 Prototypes: Object-Orientation, Functionally via Paul Tarvydas

🧵 conversation

Faré gave a talk “Prototypes: Object-Orientation, Functionally” to our Toronto Lisp Group Sept. 5, 2023.

My personal agenda is finding the “atoms” of programming (simplicity, clarity). I think that Faré nailed the questions of what is OO, what are Classes, what are Prototypes?

The slides from last night are github.com/metareflection/poof/blob/main/poof-slides-2023.rkt . With the caveat that the slides and talk are WIP.

30 LOC to implement Prototypes (and Classes) in any language that supports first class functions.

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

🧵 conversation

The C programming language was devised in the early 1970s as a system implementation language for the nascent Unix operating system. Derived from the typeless language BCPL, it evolved a type structure; created on a tiny machine as a tool to improve a meager programming environment, it has become one of the dominant languages of today. This paper studies its evolution.

🎥 Procreate Special Event via Leonardo Dino

🧵 conversation

For fans of Bret Victor’s “Inventing on Principle”, it only took a decade

Devlog Together

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

🧵 conversation

A silly little script built on this cross-platform IDE for LÖVE I've been contributing to.

🎥 MiniIDE demo

💬 Chris Rabl

🧵 conversation

Been a while since I've posted here, but I've been playing around with Domain Driven Design and drawing context maps: ended up building a little React app to help me draw them. It's not much, but I think the "auto-blobbing" is kind of a neat/cute interaction. There's actually a surprising amount of computational topology behind it!

🎥 Blobs demo

🐘 Kartik Agaram (@akkartik) via Kartik Agaram

🧵 conversation

Hopefully this isn't too ranty for this channel:

I like to say that software is often just bureaucracy by other means (though it could be oh so much more).

This might be the single-most powerful example of that on the internet: https://rclone.org/drive/#making-your-own-client-id

The reason I sought this page out: - I want to download a copy of my baby photos in case Google shuts me out in future.

• Google Takeout is basically unusable if you have more data than you can download in 30 minutes. (https://lethallava.land/notes/9if8o9ngl13900d9)

• So I saved my Takeout files to Google Drive (not yet taken out! https://merveilles.town/@akkartik/110892364898712223)

• Then I had to find a way to get files out of Google Drive. Which leads to the above page.

Google should be required to report reading burdens like the OMB does for US govt. forms.

💬 Nilesh Trivedi

🧵 conversation

Is there a visual programming environment that implements lambda calculus (either untyped or simply typed)?

🕹 Soul Arithmetic via Yair Chuchem

🧵 conversation

Before coming back to working on Lamdu after a few months break, I had to first start making this game:

Took the opportunity to use modern tools like Svelte, GitHub Copilot and Stable Diffusion for the first time which makes for a good reference for what FoC will need to improve on 🙂

Feedback most welcome..

💬 Eli Mellen

🧵 conversation

What thinkers or groups not related to mathematics or computer science most influence your thinking about programming and computers?

🐬 AI NPCs as dolphins 🎥 Introducing Mathematica (1989) 💡 Apps as Functions

Devlog Together

📝 Introduction to the Zettelkasten Method via Kartik Agaram

🧵 conversation

I just came up with a name for the versioning scheme I've been using recently:

Zettelkasten versioning

1, 2, 3, ... 14, 14a, 14b, ... 14z, 14aa, ... 14ak1, 14ak2, ...

My versions are to communicate identity. That's it. Not ordering, not value, not recency, not stability, not compatibility, not quantity of change, not support duration, just identity. Am I using the same version as you?

(The easiest way to come up with versions also ends up communicating heredity. But that's an unimportant side effect.)

Learn how the Zettelkasten works as a system, what a Zettel is made of, and how to grow an organic web of knowledge.

Our Work

🐬🐦 Matt Webb on X via Matt Webb

🧵 conversation

I’ve been digging into how we might interact with AI, beyond chatbots, and whether we could have NPCs as colleagues...

In particular I’ve been writing actual code (ulp) around actual multiplayer apps (ulp) to see what the interactions and issues might be

It is slightly ridiculous to imagine AI NPCs as dolphins... but why not, right? We’ve got a lot of language around “companion species” as a metaphor for AI, so let’s jump and see if that works.

So here’s a Twitter/X thread of my first sketches: multiplayer cursors that look like other users, but are actually NPCs

Big lessons: escaping the chatbot format might let us answer the AI affordance issue (ie how do we know what the AI can do). Here the NPC can proactively tell you. But also apps will need significant re-engineering to present a machine API and NPC runtime

Gonna dig in this direction for a couple weeks, so up for chatting with anyone about the intersection of AI/multiplayer/collaboration/etc

📝 Matt Webb :cherry_blossom::blossom::cherry_blossom: on X

How do we collaborate with AIs? What if they were just like our human colleagues, cursors and all? Well not exactly human

I’ve been sketching NPCs-as-dolphins — you build a little pool, summon them, and that’s where they hang out

(NPCs = non-player characters)

AND THEN...

Thinking Together

💬 Marcelle Rusu (they/them)

🧵 conversation

For some time I've thought that type systems are essentially ad-hoc logic languages. So.. why not use a full on logic language (prolog or something) to statically analyze your codebase instead of keep patching onto a type system, it appears to me that logic languages are simpler & more expressive than most type systems. I'm starting to work on this for my language, and creating a logic language in efforts to also understand logic programming better.

Another advantage I can think of is that if a the logic language is expressive enough to type even the most advanced languages as well as the weakest, it could be used as a shared interface between languages to understand at least parts of each others type systems, as well as be a tool for user extension for additional static analysis specific to their project.

I'm basically thinking something like this.

# here's a sample program in my (object oriented) language

fn add(a, b) = a + b

add(1, 2)

generated logic program in pseudo syntax ( #A is a pattern to check value is type of A , ?a is like prolog's A , {...} is map literal.)

-- preloaded facts

lookup(#Number, :+, {args: [#Number, #Number], ret: #Number}).



-- program

add(?a, ?b, ?ret) :- lookup(?a, :+, {args: [?a, ?b], ret: ?ret}).

?- add(1, 2, ?_).

The specifics of my logic language is likely flawed, but I'm curious about the general idea of using a fully-fledged logic language to generate a program in & run instead of generated a typed AST and running ad-hoc type systems.

My question is, what are people's thoughts on this? Any previous work in this area? Any obvious flaws?

📝 github.com/rust-lang/chalk via Martin Sandin

🧵 conversation

I might be missing context here but the fact that type systems are logic languages should be uncontroversial given that that's what the Curry Howard Correspondence is about. Though I'm not very well read I think that using "complete" generic logic languages/solver (as a component) in solving type equations ought to be well trodden ground, my first thought went to github.com/rust-lang/chalk as one example. I'd be looking at what one might give up doing so as the reason why it doesn't happen more: speed? guaranteed termination? good error messages?

💬 Jim Meyer

🧵 conversation

A one minute interaction with a digital product at 60FP on an HD RGB screen flows through a creative/generative space of 125,241,246,351,360,000 pixel variations.

We need spaceships to explore this space, but we got rectangles with drag handles instead.

💬 Eli Mellen

🧵 conversation

A question for ya’ll doing thinking on future of coding things:

When/if you think about the accessibility (read here as “a11y”) of the future of coding do you consider accessibility as an attribute of the folks using your thing (e.g. a need) or an attribute of your design (e.g. a feature)?

🐦 sophia on X via Steve Dekorte

🧵 conversation

Thoughts?

🐦 sophia :chart: (8723/30000 days alive) on X

I feel like it’s not obvious to consumers how monumental and expensive regular software is. iOS cost about as much as the Manhattan project (~$20b). Google search cost about as much as the ISS (~$100b).

Content

🎥 Introducing Mathematica, Stephen Wolfram via Chris

🧵 conversation

Fascinating video that popped up on my radar today of Stephen Wolfram demoing Mathematica in 1989

I was quite blown away by how powerful and ahead of its time it was, even back then, with features like interactive programming in a very high level, multi-paradigm language for symbolic computation with rich, introspectable outputs and various thoughtful design decisions around interoperability, extensibility and API (as validated by how none of the API functions demo'd have changed AFAIK in 30+ years!)

💡 github.com/Ruddle/Fomos: Experimental OS, built with rust via Andreas S

🧵 conversation

„So what if an app was a function ? „

🤖

🧑‍🏫 Teaching with AI via Lu Wilson

🧵 conversation

Hard to pin down what's most dystopian about this

We’re releasing a guide for teachers using ChatGPT in their classroom—including suggested prompts, an explanation of how ChatGPT works and its limitations, the efficacy of AI detectors, and bias.

💬 Denny Vrandečić

🧵 conversation

Doug Lenat, inventor of Cyc, has passed away

present-company

📝 Assaf Magen, PhD - Entrepreneur and Consultant Profile via Assaf

🧵 conversation

For those interested in gaining experience in bioinformatics/ML:

I've recently founded Mendel AI, a first of its kind AI-assisted data analysis and visualization tool designed to empower biotech & pharma R&D scientists to interact with genomics data using natural language. We're working on a prototype and would benefit from additional help. Reach out If getting exposure to this rapidly developing field sounds exciting to you.

👔 Chroma via Nick Arner

🧵 conversation

A company I put an angel check into, Chroma, is hiring a product engineer. Very keen to talk with folks from communities like this / tools for thought. If you’re interested; send a note to careers@trychroma.com

🎙 FoC #66 Bonnie Nardi • A Small Matter of Programming 🫰 LÖVE your apps 🤔 No one actually wants simplicity

Our Work

🫰 Adding malleability to any LÖVE app via Kartik Agaram

🧵 conversation

You can now make any app end-user-programmable -- as long as it's built in LÖVE

🎙 FoC #66 Bonnie Nardi • A Small Matter of Programming via Ivan Reese

🧵 conversation

This community is a big tent. We welcome folks from all backgrounds, and all levels of experience with computers. Heck, on our last episode, we celebrated an article written by someone who is, rounding down, a lawyer! A constant question I ponder is: what's the best way to introduce someone to the world of FoC? If someone is a workaday programmer, or a non-programmer, what can we share with them to help them understand our area of interest?

A personal favourite is the New Media Reader, but it's long and dense. An obvious crowd-pleaser is Inventing on Principle.

Bonnie Nardi's A Small Matter of Programming deserves a place on the list, especially if the reader is already an avid programmer who doesn't yet understand the point of end-user programming . They might ask, "Why should typical computer users bother learning to program?" Well, that's the wrong question! Instead, we should start broader. Why do we use computers? What do we use them to do? What happens when they don't do what we want? Who controls what they do? Will this ever change? What change do we want? Nardi challenges us to explore these questions, and gives the reader a gentle but definitive push in a positive direction.

Also of note — we've launched a Patreon! If you enjoy the show, please consider supporting it with a small (or not-so-small) monthly contribution. You'll get bonus episodes and a warm feeling in your heart (disclaimer: warm feeling is a metaphor; if you actually feel an increase of body heat please do not discontinue support but do talk to a doctor)

🎥 It's now easier to build and run little LÖVE apps for yourself on Android via Kartik Agaram

🧵 conversation

1. Install LÖVE from the app store (see love2d.org)

2. Download MiniIDE.love from love2d.org/forums/viewtopic.php?t=94852. I've been contributing to this app and vouch for it.

cc Konrad Hinsen who's been waiting for this 🙂

(MiniIDE has also been tested on iOS without limitations. But I gather LÖVE is quite tortuous to install on iOS, so you're on your own there..)

Devlog Together

🐸 TODEPOND PONDCAST via Lu Wilson

🧵 conversation

I've been trying a new format for my weekly devlog updates. I started by recording myself 'reading them out loud' a few months ago. And it's stuck, and I have no plans of stopping, and they're including more-and-more ad-libbing, so I've decided to make it official. So... now I'm doing the weekly 'TODEPOND PONDCAST'. Mostly as a bonus for supporters, but the occasional public one, like this one.

I'd highly recommend recording yourself speaking your blog/posts/devlogs! It's been a nice way of connecting on a more personal level with readers.

💬 Jason Morris

🧵 conversation

I think I figured out how I want to visualize a logic program executing in a debugger. A tree of trees. Chess-style variation tree navigator, where each node represents a search step and shows the search tree and bindings at that time, plus where the new unification clause was found in the source code. Anyone ever seen a logic debugger like that?

🧵 conversation

(or know of any open source web-based chess variation builders I could crib from)?

Thinking Together

💭 The reality of abstractions by Daniel Buckmaster

🧵 conversation

In Episode 66 there was a long discussion about an idea I've come to know as the reality of abstractions . I got that phrasing from David Deutsch in The Beginning Of Infinity.

I've long wanted to write about this in connection to programming, where we talk a lot about "abstractions", but in a very different sense* to the way Deutsch does. In lieu of doing that (which sounds like a lot of work) I will just post some of my favourite Deutsch quotes about it.

Reductionism and holism are both mistakes. In reality, explanations do not form a hierarchy with the lowest level being the most fundamental. Rather, explanations at any level of emergence can be fundamental. Abstract entities are real, and can play a role in causing physical phenomena. Causation is itself such an abstraction.

When we use theories about emergent physical quantities to explain the behaviour of water in a kettle, we are using an abstraction - an ‘idealized’ model of the kettle that ignores most of its details - as an approximation to a real physical system. But when we use a computer to investigate prime numbers, we are doing the reverse: we are using the physical computer as an approximation to an abstract one which perfectly models prime numbers. Unlike any real computer, the latter never goes wrong, requires no maintenance, and has unlimited memory and unlimited time to run its program.

Abstractions are essential to a fuller explanation. You know that if your computer beats you at chess, it is really the program that has beaten you, not the silicon atoms or the computer as such. [Nor, I would add, the arrangements of pixels on the screen which symbolize knights, pawns, etc.] The abstract program is instantiated physically as a high-level behaviour of vast numbers of atoms, but the explanation of why it has beaten you cannot be expressed without also referring to the program in its own right. That program has also been instantiated, unchanged, in a long chain of different physical substrates, including neurons in the brains of the programmers and radio waves when you downloaded the program via wireless networking, and finally as states of long- and short-term memory banks in your computer. The specifics of that chain of instantiations may be relevant to explaining how the program reached you, but it is irrelevant to why it beat you: there, the content of the knowledge (in it, and in you) is the whole story. That story is an explanation that refers ineluctably to abstractions; and therefore those abstractions exist, and really do affect physical objects in the way required by the explanation.

To connect this to the content of the episode - I think all the different representations of a cube on a screen are "real". The parts that you might dismiss as not having an "effect on the world", like the data structures in RAM, or the textual representation stored on disk, are as unavoidably real at their own levels of abstraction.

*Colloquially, I think working programmers use "abstraction" to mean things ranging from "I can ignore the details 'below' this point" to "I can compress this implementation into fewer syntax tokens". A contrary view from Dijkstra, which I think is closer to Deutsch's view, is abstraction as "a new semantic layer in which one can be absolutely precise".

Content

🤔 No one actually wants simplicity via Eli Mellen

🧵 conversation

No one actually wants simplicity

The reason that modern web development is swamped with complexity is that no one really wants things to be simple. We just think we do, while our choices prove otherwise.

later, continuing…

The same is often true of complexity. The real test is the question “what are you willing to sacrifice to achieve simplicity?” If the answer is “nothing”, then you don’t actually love simplicity at all, it’s your lowest priority.

When I say “sacrifice”, I don’t mean that choosing simplicity will mean you are worse off overall – simplicity brings massive benefits. But it does mean that there will be some things that tempt you to believe you are missing out.

Looking beyond the inflammatory fun title, how do ya’ll think this relates to the future of coding? Is a reason that visual programming is often just around the corner because folks aren’t willing to shed some of the complexity (read also as “power” or “flexibility”) of existing programming systems?

📝 Leaving Haskell behind — Infinite Negative Utility via Konrad Hinsen

🧵 conversation

A nice essay on programming languages, but with a message that is much more general: journal.infinitenegativeutility.com/leaving-haskell-behind

It's about the tension between "make better technology", "use start-of-the-art technology", and "use boring (but stable and well understood) technology". Different goals, different tools.

Another example I have experienced a lot: mathematics and physics. Mathematicians work on new mathematics, mathematical physicists introduce state-of-the-art mathematics into physics, and all other physicists use 100-year-old mathematics from textbooks. And each group complains about the attitude of the two others.

🛸 kamilalisp via Eli Mellen

🧵 conversation

Has anyone spent time with kamilalisp?

I've spent the last week or so exploring it, and it keeps blowing my mind.

📝 Andy Gocke on X via Gregor

🧵 conversation

:((

📝 Andy Gocke on X

Developer tools seemed like a good industry to be in, "sell shovels in the gold rush" and all, but it turns out developers prefer to dig for gold with their teeth.

🎥 Modern C development with Visual studio in 2023. via Nils Berg

🧵 conversation

wee, new stuff from Eskil Steenberg:

(not that new, he’s been working on things like this, and advocating for live debugger use for many years at this point. and yet, his stuff always seems fresh, and just…different)

🤖

📝 What can stop the AI apocalypse? — Grammar. Yes, only grammar. - Metamoderna via Konrad Hinsen

🧵 conversation

An interesting take on AI risk: metamoderna.org/what-can-stop-the-ai-apocalypse-grammar-yes-only-grammar

The vision exposed in this article is that humans with their institutional superstructures (bureaucracies, markets, corporations, ...) and AIs (plural) will/should form an ecosystem in which all players coevolve, competing and collaborating at the same time. I don't think that any of the players are ready for this, but in the long run, this is where we could be heading.

The sociological/psychological fallout of AI is not decades away: right here, right now, we are watching in slow-motion the major meltdown of our shared sense of reality. The only thing that can save civilization from utter destruction? Basic English grammar. Hear me out, guys. Part One: Introducing the idea: “If the disease stems from a […]

💬 Jason Morris

🧵 conversation

So it looks like my current term contract doing Rules as Code for the gov't of Canada will expire in a couple of months. If you have generic advice about how to do a job search when your expertise is so niche as to be almost singleton, let me know. 🙂

🤔 Backends at any scale in 100x less code 🎥 Unit by Samuel Timbó

Devlog Together

💬 Jason Morris

🧵 conversation

A little bit of Rules as Code in Unit: "a person can write a will if they are 18 or at least 14 and in the military". The checkbox indicates if they are military, the number field is their age, and the text field is the answer to whether they can write a will. What's interesting is that the diagram illustrates the reasons. If they qualify both ways, both paths are yellow.

Reading Together

📝 “Myths and Mythconceptions: What does it mean to be a programming language, anyhow?” by Mary Shaw (2021) via Christopher Shank

🧵 conversation

Content

🤔 How we reduced the cost of building Twitter at Twitter-scale by 100x via Mariano Guerra

🧵 conversation

How we reduced the cost of building Twitter at Twitter-scale by 100x

Rama unifies computation and storage into a coherent model capable of building end-to-end backends at any scale in 100x less code than otherwise. Rama integrates and generalizes data ingestion, processing, indexing, and querying.

A summary from @Dustin Getz

I’m going to cover a lot of ground in this post, so here’s the TLDR: We built a Twitter-scale Mastodon instance from scratch in only 10k lines of code. This is 100x less code than the ~1M lines Twi…

🎥 Flowistry - Helping Rust Developers See Data Dependencies in the IDE (Will Crichton, August 2023) via Cole Lawrence

🧵 conversation

I just finished editing and published the talk from Rust East Coast. Perhaps some programming theory folks could find it interesting! cc Garth Goldwater

In a large Rust codebase, it can be difficult to find just the code you need to implement a feature or fix a bug. This talk will introduce Flowistry, a tool for visualizing data dependencies in Rust programs that can help programmers quickly sort out irrelevant code. I will explain what makes static analysis of dependencies a difficult problem, and I will describe the key insight in Flowistry that makes the problem tractable.

Presented by Will Crichton

📝 Introduction: Situating Critical Code Studies in the Digital Humanities via Eli Mellen

🧵 conversation

Introduction: Situating Critical Code Studies in the Digital Humanities

Critical code studies is the application of the hermeneutics of the humanities to the interpretation of the extra-functional significance of computer source code. “Extra” here does not mean “outside of” or “apart from” but instead it refers to a significance that is “growing out of” an understanding of the functioning of the code.

This piece also links to a few other interesting resources on the subject, including, the initial manifesto for critical code studies.

I also liked this quote,

Still, reading code, even without interpreting its cultural significance, can be no easy task. Ask a professional programmer who inherits legacy code to maintain or, worse yet, to improve, and they will tell you about the dread of sorting out just-in-time code, minimally documented, written with hasty patches, full of compromises and workarounds. Even those who write their code in artistic projects can be shy about sharing their code out of embarrassment and self-consciousness. This shame is a product of the “encoded chauvinism” of programming culture, one that can be fostered on the internet as much as it is in classrooms Marino 2020

📝 The Critical Carbon Computing Collective’s issue of Branch is out! via Eli Mellen

🧵 conversation

🎥 Unit by Samuel Timbó via Ivan Reese

🧵 conversation

Today's workshop on Unit with @Samuel Timbó is now up on YouTube

Thanks to everyone who attended, and to Sam for building and demoing such an impressive piece of tech!

📝 some writers use an old word processor called WordStar via David Alan Hjelle

🧵 conversation

I thought this article on why some writers use an old word processor called WordStar was interesting. I wonder if there are any implications here for editing programs? Some of the ideas — like comments — we usually take for granted in programming. But maybe there are some other worth-while take-aways?

Let me speak generally for a moment. I've concluded that there are two basic metaphors for pre-computer writing. One is the long-hand manuscript page. The other is the typewritten page. Most word processors have decided to emulate the second — and, at first glance, that would seem to be the logical one to adopt. But, as a creative writer, I am convinced that the long-hand page is the better metaphor.

Consider: On a long-hand page, you can jump back and forth in your document with ease. You can put in bookmarks, either actual paper ones, or just fingers slipped into the middle of the manuscript stack. You can annotate the manuscript for yourself with comments like "Fix this!" or "Don't forget to check these facts" without there being any possibility of you missing them when you next work on the document. And you can mark a block, either by circling it with your pen, or by physically cutting it out, without necessarily having to do anything with it right away. The entire document is your workspace.

On a typewritten page, on the other hand, you are forced to deal with the next sequential character. Your thoughts are focussed serially on the typing of the document. If you're in the middle of a line halfway down page 7, your only easy option is to continue on that line. To go backwards to check something is difficult, to put in a comment that won't show when your document is read by somebody else is impossible, and so on. Typing is a top-down, linear process, not at all conducive to the intuitive, leaping-here-and-there kind of thought human beings are good at.

💬 Jason Morris

🧵 conversation

Anyone ever played with Symboleo? I'm only now learning it is under development in Canada (University of Ottawa) for use in legal contracts. Logic based, uses event calculus, implemented in Prolog-inside-Java, looks like. Shares a lot of design objectives with what I'm doing with Blawx.

📝 Scratch via Shalabh Chaturvedi

🧵 conversation

I’ve been doing Scratch with kids recently and while it’s fun, I’m looking for something next level. Specifically things like no shared custom blocks across sprites is becoming problematic (copy paste issues). Any recommendations?

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