🏗️ Gradual Structure Editing 💡 Notation as a tool of thought 🔗 Live 2D Compositional Programming

Two Minute Week

Our Work

🎥 Algebraic effects and handlers on an Arduino board via Peter Saxton

🧵 conversation

Compiling Algebraic Effects and handlers for Arduino using tinygo

🎥 Kopi Demo via Mike Austin

🧵 conversation

Hi all! I introduced myself and started poking around about a week ago, and have now finally created a video to share my work. It's a small, immutable, 100% async programming language, Kopi, and a React (UI framework) based desktop environment. Enjoy!

Devlog Together

🏏 crosstable.love: A little tool for sports cross-tables via Kartik Agaram

🧵 conversation

@Matt Wynne Do you cricket? This one's for people in a few selected locales around the world, but there's a cricket world cup going on with a lot of upsets right now, and it just got me to scratch a long-standing frustration: a tool for all-play-all cross-tables that lets me simulate potential future results, while sorting the rows and columns for me.

In the process I learned to draw janky 3D-looking buttons for the first time.

As with most of my stuff lately, you can edit this app's code live as it runs, and my platform choices allow me to accomplish that with very little code. See the Readme for details.

🎥 Crosstable Demo

Thinking Together

💬 Lukas Süss

🧵 conversation

Hey everyone, – I'm looking for some quite a few years old demo that I can vaguely remember that

was using pointfree code in a table layout (related to stack based programming).

Some cells merged and changing on evaluation IIRC.

I initially thought that it was from Jonathan Edwards, but not so sure anymore.

I was not particularly convinced about the idea but some discussion

about stack based programming came up where this would be a nice reference I guess.

Does anyone here still have a link to that maybe?

🏗️ Gradual Structure Editing with Obligations via Lukas Süss

🧵 conversation

Here's an interesting new paper on advanced structural editing with a strong "typing normally" focus:

Gradual Structure Editing with Obligations

building on tylr.fun

by @David Moon @andrew blinn @Cyrus Omar

– – –

And some work on seemingly lower level perhaps more near term practically applicable projectional editing:

Projectional Editors for JSON-Based DSLs

Projectional Editors for JSON-Based DSLs

prong-editor.netlify.app

by @Andrew McNutt @Ravi Chugh

🤖 14 Best AI Coding Assistant Tools in 2023 via Mike Austin

🧵 conversation

Thoughts on AI code assistants?

It doesn't seem that far off from easily prototyping things like games. An AI could understand what a screen is, a sprite/character, movement, etc. Heck, just tell it to generate a random game and fine tune it.

🔗 Live 2D Compositional Programming via Lukas Süss

🧵 conversation

Concatenative Programming Projection

2022 – Interleaved 2D Notation for Concatenative Programming – by @Michael Homer

Some quickly enlightening demo videos here:

Landing page

Tryable in the browser

Direct link to the paper

It's a concatenative language.

It's not a stack based language. Slight differences I guess.

Also questionably point free with with the values unnamed but live values still shown.

Comparison to stack based languages

★ Similarities to a stack based language:

– also no variable names

– also the typical operations: dup, swap, dig

– also only variables with an arity of one or more (aka functions) are shown (and literals)

★ Differences:

– There's no reverse polish notation.

– Unlike in in a stack based language there's no single stack.

Rather the representation make opportunities for parallel evaluation quite obvious.

– Variables have no names but are still displaying their live value like in a spreadsheet (not referring to the layout).

⚠ It seems this is actually not a language but a projections style.

This is nice, meaning to some degree other language can potentially be projected into this representation.

Well, plus-minus some issues. Syntactic sugar mostly not carrying over. Readability in other projections.

Switching to a different projection one may want to give out human readable variable names though rather than assigning auto-generated ones.

Maybe this would be a viable additional projection target for some other languages (unison)?

No clue though how this would interact with algebraic effects.

Comparison to ALDs

Relation of Michael Homers model to annotated lambda diagrams:

★ ALDs give same obviousness of parallelity opportunities

★ Unclear which representation is visually denser but likely not the ALDs

★ ALDs (as in the current mockups) are not pointfree. Variable names do appear both …

– at the head of the function definition (and tops of let- and in- blocks) and

– as annotations of the horizontal value lines (i.e. as the arguments to functions)

★ For Making the ALD code projection more aligned with Michael Homers model:

– replace value names with live values

– collapse let-in-blocks by substitution

(live values could still be added as "syngraphic" sugar in extended value lines, I digress …)

★ flip & dig (argument permutators)

– They both vanish in the ALD code projection no matter their location.

– They are just permuting the arguments by swapping application lines and all preceding dependents.

★ dup

– only vanishes at the top level as it turns into two forks.

– otherwise less trivial as it induces an unavoidable let-in block.

(Uncurrying into tuples is a bad alternative as it hides away ALD circuitry, the whole point of ALDs)

💬 Tom Lieber

🧵 conversation

I know it's ancient tech, but there are so few parts of my computer where I can freely mix styled text, code, and data, and Mathematica is the only one where doing so feels remotely natural.

I was inspired to post something by recent workflow breakthroughs in how I keep my lab notebook, where I slice-and-dice tabular data from experiment results in-between my paragraphs of stream-of-consciousness analysis. It's a lovely way to work. My journal entries build on one another in ways they never did before, because I can use code to put the best view(s) of the data right into the notebook.

Content

💡 Notation as a tool of thought via Jack Rusher

🧵 conversation

Mathematical notation has serious deficiencies. In particular, it lacks universality, and must be interpreted differently according to the topic, according to the author, and even according to the immediate context. Programming languages, because they were designed for the purpose of directing computers, offer important advantages as tools of thought. Not only are they universal (general-purpose), but they are also executable and unambiguous. Executability makes it possible to use computers to perform extensive experiments on ideas expressed in a programming language, and the lack of ambiguity makes possible precise thought experiments. In other respects, however, most programming languages are decidedly inferior to mathematical notation and are little used as tools of thought in ways that would be considered significant by, say, an applied mathematician.

The thesis of the present paper is that the advantages of executability and universality found in programming languages can be effectively combined, in a single coherent language, with the advantages offered by mathematical notation.

— from Iverson’s Turing lecture, still a banger 50+ years later

🎥 "Weathering Software Winter", Handmade Seattle 2022 via Mike Austin

🧵 conversation

Sometimes I think you need to take a few steps back before moving forward. It's also fun to explore old technology.

"Weathering Software Winter", Handmade Seattle 2022

📝 The New Developer Research Paper via Eli Mellen

🧵 conversation

I shared this as a response to a message earlier today, but I think it may be worth sharing here, too!

Pluralsight shared some interesting research they just completed. The research seeks to validate a framework that can be used to understand developers’ relationship to AI.

Quoting from the data highlights of the landing page:

• 43-45% of developers studied showed evidence of worry, anxiety and fear about whether they could succeed in this era of rapid generative-AI adoption with their current technical skill sets.
• Learning culture and belonging on software teams predicted a decrease in AI Skill Threat & an increase in both individual developer productivity and overall team effectiveness.
• 74% of software developers are planning to upskill in AI-assisted coding. However, there are important emerging equity gaps, with female developers and LGBTQ+ developers reporting significantly lower intent to upskill. On the other hand, Racially Minoritized developers reported significantly higher intentions to upskill.
• 56% of Racially Minoritized developers reported a negative perception of AI Quality, compared with 28% of all developers.

Emphasis mine 😄

💻 Magpie is a small dynamically-typed programming language built around patterns, classes, and multimethods via Mike Austin

🧵 conversation

A programming language that inspired me, but never really took off was magpie-lang.org. It was heavily based on pattern matching and supported multi-methods. It's creator, Bob Nystrom, as far as I know now works on Dart language. journal.stuffwithstuff.com

🎥 The Message Is The Medium - Douglas Crockford via Paul Tarvydas

🧵 conversation

📐 Geometry to Algebra and Back Again 🧮 Computational Physics 💡 Forth, Prolog, Petri Nets and LLMs

Our Work

🐘 Deconstructing the Mastodon client via Konrad Hinsen

🧵 conversation

A blog post about my recent adventure into improving my Mastodon experience, do-it-yourself style:

Not quite end-user programming, definitely not professional software development, but something in between.

Ever since I joined Twitter in 2011, and then moved to Mastodon in 2022, I have been unhappy with the timeline view proposed by both of these communication platforms as their main interface. Now I have finally done something about it: I wrote my own Masto...

📝 Feminism — Matt Wynne via Matt Wynne

🧵 conversation

I wrote a piece about feminism, and what patriarchy means for "agile transformations": mattwynne.net/feminism

In this post I want to talk about feminism: why I have personally embraced it, why I encourage you to, and — since you’re probably readin...

💻 github.com/geoffw8/hyperlayer via Geoff

🧵 conversation

Hello all,

Very proud to introduce ⚡️Hyperlayer - Debug Rails apps 10x faster:

☝ Code and demo video in the repo.

It works by creating a visualisation layer which combines application flow, state and the code itself. It utilises Tracepoint and AST under the hood to build the visualisation. This visualisation means you can cut out a significant portion of the steps we have to go through to "manually" debug an issue, leading to the timesave.

I would absolutely welcome any feedback. I think it could be a big deal!

I'm really excited about being able to share this with the world.

💬 Marcelle Rusu (they/them)

🧵 conversation

Started working on a prolog backend for coil.

Here's an example of compiling a coil program to prolog & exploring the codebase via prolog repl.

This is early but the hope is to have an easily explorable codebase, to really treat the codebase as a database.

Ambition for this is

• Allow users of coil to write their own rules in prolog to ensure things about the program
• Make writing a type checker easier for me
• Make writing tooling for coil easier

🎥 Screen Recording

🎥 Conversational User Interfaces Prototype via Mariano Guerra

🧵 conversation

Conversational User Interface Prototype

• Select & pre-configure interactive UI components by asking an LLM in natural language

• Group them in sessions

• Reuse workflows by storing sessions as templates

📝 m-ld via George Svarovsky

🧵 conversation

m-ld is a component for sharing live information peer-to-peer. (Lots of materials at the link, and click the big green button to find code playgrounds.)

It's intended to allow programs to be written "local-first", having a reactive local model that is concurrently editable from multiple remote locations, with a guarantee of eventual consistency. So, you more-or-less write your code as if the data is 100% local, embedding m-ld as a library, and magically find that other remote participants can read and write the data too (subject to security!).

There are two main use-cases we're targeting – client apps, like office tools, supporting collaborative editing (GDocs-style); and microservices sharing information like configuration or master data. In both cases, you don't need a (extra) server for the data (though you do need a way to pass messages, for example a pubsub).

I've been working on this for a while so there's a million things I could ramble on about, but I'm curious to know if the above pricks up anyone's ears. Do those use-cases sound, well, useful? Does my description make you want to know more, or, ho-hum? Any feedback is welcome; will return with recent focus later! Many thanks

📐 Geometry to Algebra and Back Again via Jack Rusher

🧵 conversation

My talk on geometric algebra from this year’s Strange Loop/Papers We Love Conference, embedded in a mini-site with the video, a transcript, and links to all the papers I mention.

4000 Years of Papers

🎥 "Computational Physics, Beyond the Glass" by Sam Ritchie (Strange Loop 2023) via Jack Rusher

🧵 conversation

A look at what Sam Ritchie has been working on with Emmy, a Clojure computer algebra system ported from Sussman’s scmutils, that also features quite a bit of Clerk

… some of you might see where all of this is going — an open source, Clojure-based Mathematica-like system.

💬 Arcade Wise

🧵 conversation

: fizzBuzz? ( n -- ) "" swap ( str n -- )

   ( str n n ) dup 3 % 0 = ( str n ) if swap ( n str ) "Fizz" concat ( n strFizz ) swap then

   ( str n n ) dup 5 % 0 = ( str n ) if swap ( n str ) "Buzz" concat ( n strFizz ) swap then

   concat .

;



1 100 do i fizzBuzz? loop

I have been working on a forth implementation, and this fully works now! I'm super excited to show the cooler stuff that goes along with it too :>

💬 Arcade Wise

🧵 conversation

🎥 Fully I CAN'T BELIEVE ITS NOT FORTH user interface!

Devlog Together

📝 Software Simplification Compendium – Kinopio via Paul Tarvydas

🧵 conversation

Compendium and demonstration of simplification techniques for composing software programs.

Began new digital garden, including 3 working examples of drawware/0D (Scheme to JavaScript transpiler , markdown as a programming language, partial language for game programming), a 4th example of simple use of OhmJS (simplistic ABC language), headings for major sections, ongoing fleshing out of points under each heading.

Reading Together

📕 Languages for Developing User Interfaces via Beni Cherniavsky-Paskin

🧵 conversation

1991 workshop proceedings looks interesting but not sure it's worth buying 🤔 But amazon free sample is generous, reading that first...

🧫 guarded petri nets via Don Abrams

🧵 conversation

I'm looking at defining a collaboration-centered language that has sound semantics (ie semantics under composition are intentional and generally useful)

My understanding is that you can only verify semantics for a specific model, so trying to define a "good enough" model

Do y'all know of any papers on the tradeoffs of various "computer" models for distributed machines? Bonus points if it has time costs and resource limits built in and supports heterogeneous machines.

My best guesses so far are guarded petri nets or Poly

Thinking Together

💬 Janne Aukia

🧵 conversation

Has anyone thought about or written about malleable software + LLM:s? I feel that it is an area that could be quite interesting, but I haven't got yet a clear understanding on what this will lead to.

I think that pretty soon most of end-user code will be generated with the help of LLM:s. Some thoughts/questions I've been thinking about:

• How to generate programming languages, libraries and abstractions that LLM:s can use well? Is that different from generating libraries etc for humans?

• LLM:s are faster than humans in processing data, so API:s can be really wide and probably more complex than what would be practical for devs.

• LLM:s can probably handle more condensed/optimized representation better, too.

• And be able to infer system affordances directly from code.

• How to support creating good and maintainable code from LLM:s? And will that matter? Or will actual code become irrelevant?

• How to modularize apps so that they can be easily composed by LLM:s?

• My hunch: making apps modular and composable would work really well with LLM:s already now and even better in the future. Doesn't matter if functional or OOP, as long as the LLM can understand the logic.

• What kinds of new apps and malleable software will LLM:s enable?

• Also: LLM:s could finally enable removing some boundaries between different programming tools, library ecosystems, etc, by enabling translations/bridges automatically.

Any thoughts?

📝 Ursula Franklin’s tech project checklist via Alex McLean

🧵 conversation

Kartik Agaram's draft programmer's pledge reminded me of Ursula Franklin's checklist for technology projects, which is a bit hidden in one of her really excellent 1986 lectures on the "real world of technology"

“… whether it:

(1) promotes justice;

(2) restores reciprocity;

(3) confers divisible or indivisible benefits;

(4) favours people over machines;

(5) whether its strategy maximizes gain or minimizes disaster;

(6) whether conservation is favoured over waste; and

(7), whether the reversible is favoured over the irreversible?”

I tried to summarise these points in a blog post here or you can listen to the lectures directly, or read it in book form.

I'll pull out a couple of quotes, first on 3) divisible/indivisible benefits:

“If you have a garden and your friends help you to grow a tremendous tomato crop, you can share it out among those who helped. What you have obtained is a divisible benefit and the right to distribute it. Whoever didn’t help you, may not get anything. On the other hand, if you work hard to fight pollution and you and your friends succeed in changing the practices of the battery-recycling plant down the street, those who helped you get the benefits, but those who didn’t get them too. What you and your friends have obtained are indivisible benefits.”

and on 7) reversible vs irreversible:

“The last item is obviously important. Considering that most projects do not work out as planned, it would be helpful if they proceeded in a way that allowed revision and learning, that is, in small reversible steps.”

5) on maximising gain vs minimising disaster is also a really interesting point, where she argues against planning, and for finding the right conditions for something to grow, at its own rate.

💬 Jason Morris

🧵 conversation

I just (finally) figured out how to represent my coding language as a directed multi-graph with labeled edges. Now I'm wondering if the interpretation steps could be represented as graph translations, so you could literally "watch" it execute. Anyone have any ideas for libraries that I could use to explore that idea, or examples I could look to? My current best guess is NetworkX and visdcc+dash.

💬 Eli Mellen

🧵 conversation

What does it mean to you when someone says something like “code as literature?”

Often the implication seems to be that code should be readable — which I take to mean “understandable,” which I further take to me “as a person looking at this code I can map what it’s output will be.”

Where my specific hangup enters is that a lot of literature isn’t directly “understandable” in this sense. There are many layers at which to understand literature. How about code? Code as more than it’s outcomes.

💬 Josh Cho

🧵 conversation

better DSLs for prompt engineering? i am being inspired by forth

💬 Paul Tarvydas

🧵 conversation

observation: similarities - Forth, de Bruijn Indexing, Lambda Calculus, Currying ...

📝 David mcclain on forth via Paul Tarvydas

🧵 conversation

FYI - David B. McClain wrote Forth for a living (Kitt Peak) and is now using Lisp. I posted some of his comments here, including a reference to his Forth in Lisp: David mcclain on forth

Content

🎥 "Supporting Data Journalism through Compilers for Visual Inputs" by Parker Ziegler via Christopher Shank

🧵 conversation

🤖

💬 Jason Morris

🧵 conversation

Did a technical assignment for an interview this week, and made extensive use of ChatGPT4 to great success. It's to the point now that if I get an error message I don't understand, or get to a step where I'm unclear what to do next, I'll try ChatGPT4 before I will try Google, because with ChatGPT4 it already has the context for the problem, and gives me an answer specific to my context. Very different programming experience.

Present Company

💬 David Alan Hjelle

🧵 conversation

I was curious this morning: my naïve view of compiler history is that they used to be very small (due to performance constraints) and have gotten very complicated over the years in order to support multiple platforms and in order to employ more and more optimizations. Is that generally a fair take? What are the big changes to compiler architectures from the early days? Does something like LLVM produce enough better code to justify its complexity? Are there any blog post- or paper-length history of compilers articles out there? (I'm not quite so curious as to be ready to read a whole book, but if you've got a good recommendation…)

💬 Konrad Hinsen

🧵 conversation

A question that came up in a discussion this morning:

Suppose you want to publish a command-line utility program, meant to be easy to use. Doing Web retrieval and some post-processing. Around 500 lines in a typical scripting language, but with dependencies (in that language plus C libraries).

It looks like packaging such a tool for all popular platforms (i.e. package managers) will be a lot more work than actually writing the code.

True? Any way to avoid this?

Ideas so far: don't use a scripting language, but something with a compiler that can produce portable executables for every major platform. Recommendations in that category so far: Go, Rust, Racket, Common Lisp. I have doubts that all of these can handle "plus C libraries", but it's a start.

Does anyone here have actual experience with this kind of project?

💼 Economics of Programming Languages 🏗️ Building a Better Web Browser 💻 All things live coding

Two Minute Week

🎥 Recognition of hand-drawn symbols in embedded structures via Alex McLean

🧵 conversation

Lately I've been experimenting with recognition of hand-drawn symbols in embedded structures, working with Luke Iannini in Realtalk

Thinking about how perceptually salient properties (such as spikiness/roundness, wonkiness) could be taken into account in a kind of analogue interpretation of the shapes alongside discrete symbol recognition as 'signposts' in feature space.

and what happens to those features when some symbols are marked out as higher order functions.

Thinking about syntax based on proximity and containment rather than adjacency.

also what happens when the parser itself is part of the scene.. e.g. how does its orientation change the parsing of the symbols?

Would love to hear about other projects that have explored this kind of area!

🎥 Generate: A One Click Research Dashboard via Pawel Ceranka

🧵 conversation

We’re trying to put together a bunch of research tools in one place —web search, images search, all sorts of AI thingies.

It’s now possible to try some of this straight from the homepage —no login, no nothing.

Please check it out if it sounds interesting at all and as always comments appreciated 🙏

Here’s a little video for your viewing pleasure 📽 — have a great Friday and wonderful weekend!

Our Work

💬 Jason Morris

🧵 conversation

Early rough prototype of the Prolog debugging interface I'm designing. Feedback welcome. Logic Debug Prototype

🔍 Visualization of hindley-milner's algorithm-j via Jared Forsyth

🧵 conversation

I've been doing a bunch of diving into type inference algorithms trying to understand them better so I can write a good one for the language I'm creating, and my latest project is visualizing how the algorithms work, to get a better intuition for them.

Here's a visualization of basic hindley-milner's algorithm-j. You can play with it here type-inference-j.surge.sh

🎥 Type Inference Visualization

Devlog Together

💬 Maikel van de Lisdonk

🧵 conversation

This week no short video, just a report of my progress on building a visual programming system :

• I've started experimenting with having multiple layers in a visual flow.. as inspiration I think of pcb's which are used in electronic devices where components and connections can live on different layers. Hopefully this can help in keeping the flows becoming a big pile of spaghetti and better scalable.

• Another new experiment is an import function that can import a textual program and convert it to a visual flow. In my engine I already use a small custom language which is parsed to an AST and transpile that to javascript within some node-types.. so, with this import function a script in this language can be converted to a visual flow.. it's still in its infancies , but I even want to try and convert a javascript/typescript file to a visual flow.

• Made some new node-types to support functions within a visual-flow. Since I don't use a port-based/pull mechanism for the flow-runner that runs the visual program, the function parameters are send as a payload (which is a dictionary of keys and values).. and in the function node you can define the expected parameters.. currently these are not typed.

Hopefully I can find some time to make a video later this week.

Greetings,

Maikel

Reading Together

💬 Paul Tarvydas

🧵 conversation

The Little Typer online reading group starts tonight around 7 PM Toronto time contact me for details

Thinking Together

💬 Alex McLean

🧵 conversation

Reflecting more on Amy Ko's recent work on Wordplay, I think part of what makes it successful is that it's an art project - playing with typography is just a really nice domain to make alternative programming languages in - playing with symbols, with symbols. It's a shame that the arts are often pushed out of 'future of coding' type circles. E.g. compare the first LIVE workshop on Live Programming which had loads of music-focussed contributions, with recent editions where the focus seems much more on abstract ideas for which 'real world' applications have not yet been found.

My understanding is that part of the reason for this is that for CS academics, associating their work with creative applications is generally seen very much as a career-limiting move

💬 Duncan Cragg

🧵 conversation

I went away from FoC for a few weeks and dropped by today and I have to say I'm blown away by the diversity of creative and innovative work being brought to light here. And, bizarrely, how little discussion is being initiated by the posts! Is everyone so focused on their own stuff that they're not available for engaging in a broader perspective? I'm worried that a lot of great stuff could be going the wrong way or could fizzle simply through lack of community coherence. Dunno. Whaddyall think?

💬 by Qqwy / Marten

🧵 conversation

Some thoughts re: ‘67 Considered Harmful’:

Superparentheses :

Love the discussion about this topic 😛. Haskell has $ which means ‘opening parenthesis that is closed by the end of the line’ which gets a bit close to the idea of a ‘super opening parenthesis’.

C and GOTO:

C came out after this paper, and its goto statement was neutered: It only allows local jumps (remaining in the same function) and only to hard-coded labels (though a common GCC compiler extension extends this to allow dynamic labels).

The closest C gets to unrestricted GOTO is setjmp / longjmp ; but here the callee decides where you jump to (just like with exceptions) so you can really only jump up on the stack, making them slightly less painful to reason about.

Neither gets used a lot: I mainly know the goto sosueme idiom from a few of the talks of Alexei Alexandrescu in which he uses it in a hot code path because the resulting machine code is better optimized. And setjmp / longjmp is used in some places to emulate exceptions or coroutines in plain C, but whenever the OS provides higher-level abstractions to use here they are preferred (just like how OS support for threading is better than rolling your own spin-locks).

🧵 conversation

And making a separate topic for the second half of the episode about the list of other ‘things considered harmful’ because it is mostly separate from the previous discussion ^_^’:

• Most of your takes are actually luke-warm, in my opinion. 🙂
• Agile (with capital A) considered harmful: 100% agree with your discussion here.
• Dependency Injection considered harmful: I disagree. You can definitely use it too much and it would be better if people would approach it from the dependency inversion principle side, but it definitely is better than tightly coupling your code on implementation details. And related to that, I’d like to add:
• Inheritance considered harmful: Why do we still teach new programmers how to do inheritance? Besides ‘prefer composition over inheritance’, have we not learned in the last 20-ish years that doing polymorphism based on interfaces/traits creates much more maintainable code?

💬 Kartik Agaram

🧵 conversation

The next paradigm beyond capitalism

These are some rough thoughts I wasn't expecting to share publicly for a long time, if at all, but it seems to be inevitable for me to hit a point of, wth, throw it out there. In this case the impetus was @Alex McLean's comments on 💬 #linking-together

The way I see it, capitalism currently performs many load-bearing functions in the world, but the world today suffers from capitalism being the predominant engine of meaning/motivation. Why do we get out of bed and do anything? The places we tend to pay attention to are governed by social proof, a sense that others are paying attention. Social proof is in turn governed by status seeking; we all want to be "successful", and in our efforts to be successful we chase the prospects of success around us. We're more likely to attend to something if it promises to be successful. And finally, closing the loop, the metrics for "success" are basically money at root. Everything else seems to get grounded at some level of indirection in money.

All this hit home particularly hard when listening to the first hour of episode 65 (totally awesome, and having nothing to do with the title), where Ivan Reese at one point says, to be taken seriously you have to signal effort. And at a second point: one way to signal effort is to spend a lot of money. All totally right and obvious for the world we live in. And yet.. I'm kinda feeling done with seeing large projects spending lots of money as more intrinsically meaningful? We've seen many many examples of the same depressing way large projects with lots of money fail. Money invariably has strings attached.

So, I'd like to live in a world where money exists, but more people consider it a satisficing rather than optimizing criterion. Something that inhabits the lower levels of Maslow's Hierarchy and gets banished from the upper level that it has somehow infected while we weren't looking.

What might replace money as a source of meaning and motivation for programmers? One answer I've been rolling around in my mouth and feeling increasingly ok with is: durability. Durability has a long track record (i.e. monuments) as something that can motivate people. Software is currently really bad at building durable artifacts, and not I think for any intrinsic reason. We just haven't prioritized it. I think a world where software artifacts can be easily run a decade later -- without any modification -- would be a significantly better world than the one we live in. In such a world, software would be part of the solution rather than the problem.

So, with that lengthy preamble, here's the draft I've been noodling on.

Draft: A programmer's pledge

Given that:

• We are on this planet for a brief time and will take nothing with us when we leave; and that
• The effects of our actions compound for good and for ill, long after we are gone, in ways we cannot always anticipate; and that
• I want to be helpful to others, and for the good in my actions to outweigh the bad; and that
• I want to persuade you that I truly believe the above, that I want to be helpful more than I care about my own gain and aggrandizement;

Therefore, I pledge to:

• Tell you, when I build anything, what I hope to gain from it. If it's money I'll tell you how much in inflation-adjusted currency, and I'll commit to giving away anything beyond that while unencumbering any secrets it took to create it. If I create organizations or foundations around what I build, I'll enshrine these limits on value capture into their bylaws.
• Tell you, up front, when it will be done. I'll provide a clear test for features I will add, and when I will stop adding features.
• Show my thought process in my efforts to make it durable. Even after it's done, it might need changes to be runnable on people's computers. What have I done to minimize the likelihood of such changes? What have I learned from past projects that makes this one more durable than them?

💬 Tom Lieber

🧵 conversation

Is there a schematic table editor? (Jonathan Edwards?) I’ve been writing complicated nested conditionals in non-Subtext languages and frequently transcribing them as schematic tables in spreadsheets to understand and refactor them—but man, is it tedious!

Content

💡 What to know before debating type systems via Nilesh Trivedi

🧵 conversation

From 2010 but still holds up quite well 🙂

📝 Language and the Rise of the Algorithm by Jeffey Binder via Alex McLean

🧵 conversation

I'm enjoying the introduction to the book Language and the Rise of the Algorithm by Jeffey Binder, especially in the context of watching Amy Ko's "Searching for Justice in Programming Language Design" linked above. Her approach seems to have a lot more in common with Leibniz et al than I was expecting, in terms of addressing the political and social contexts of symbols.

It isn't open access, but you can download it from a shadow library if you want.

🎥 Moveable Projected Displays using Projector Based Tracking via Arcade Wise

🧵 conversation

This is part of my ongoing obsession with cool projection stuff, here's a paper from before I was born on some fascinating tracking and interaction methods!

📝 Quantitative Program Reasoning with Graded Modal Types via Shubhadeep Roychowdhury

🧵 conversation

Quantitative Program Reasoning with Graded Modal Types: Most programming languages treat data as infinitely copiable, arbitrarily discardable, and universally unconstrained. However, this overly abstract view is naïve and can lead to software errors. For example, some data encapsulates resources subject to protocols (e.g., file and device handles, channels); some data has confidentiality requirements and thus should not be copied or communicated

arbitrarily. Dually, some programs have non-functional properties (e.g., execution time) dependenton data (e.g., on its size). Thus, the reality is that some data acts as a resource, subject to constraints. In this paper we present Granule, a typed functional language that embeds a notion of data as a resource into the type system in a way that can be specialised to different resource and dataflow properties. Granule’s type system combines linear types, indexed types (lightweight dependent types), and graded modal types to enable novel quantitative reasoning.

🏗️🎥 Building a Better Web Browser - James Mickens - Harvard CS Colloquium 2015 via Marcelle Rusu (they/them)

🧵 conversation

James Mickens is describing the Atlantis Browser which is a very minimal high security & performant browser which forces each application to ship its own runtime (including languages, renderer, etc) with ideas on backwards compatibility with existing (js,html,css) web applications.

Im reminded by alan kay talking about the early browsers (unknown reference) basically what if applications shipped their runtimes. I kind of thought of a more general & inspectable html at the time but i think this is very interesting too

🕹️ An Interactive Intro to CRDTs via Mattia Fregola

🧵 conversation

💻 all things live coding via Alex McLean

🧵 conversation

Long list of 'all things live coding'

💼🎥 "The Economics of Programming Languages" by Evan Czaplicki (Strange Loop 2023) via Ivan Reese

🧵 conversation

Thinking about designing a new programming language or related tool? Yes? You've come to the right Slack!

Would you like to get paid for that work? Well, Evan has 10 years of wisdom for you.

📝 Undone Computer Science - A conference to reflect on epistemological and ethical dimensions of computer science via Alex McLean

🔥 Dusk OS via Eli Mellen

🧵 conversation

Has anyone else been watching Dusk OS dev take place? I subscribe to the git commits in my RSS reader and watching the progress made on this project in real time is a pretty wild experience.

I think some folks around here may find the “almost C” compiler implemented in forth interesting.

📝 musicriyaaz account focusing on on a unique music representation for voice via Arvind Thyagarajan

🧵 conversation

@Alex McLean for a small side road into music representation -- here's a wonderful insta account to follow; linking one recent example here: musicriyaaz account focusing on on a unique music representation for voice

[October 8th, 2023 10:47 AM] alex952: <@UCUSW7WVD> it's been a while.. but working on payment processing was mostly writing c code to pre-written specs but there was some room for finding creative solutions to problems.. A big part of making music for me is making new representations for music, which is really hard and is definitely some of the most interesting and technically challenging work I've done in my career. Actually making live music by live coding does feel very different though in a number of ways.. Being fully absorbed in the sonic output of your code while changing it, with a room full of people are dancing to it, is just a lovely time. It does seem like a very different activity to systems programming, but someone has to program the live coding system in the first place, and building and using systems happens in the same community, with everyone coding in some way.. like with dynamicland, things can get interesting when you break down the barriers between systems programming and live interaction.

🤖

💬 Tom Lieber

🧵 conversation

I don’t know how I missed it in the announcement, but ~when you use an LLM chat cell in Mathematica, it sends~ ~all~ ~the cells above it as context.~

I realized that was happening when the LLM happened to refer to code I’d written in one of its answers. Now I just straight up ask it “Why?” when something surprising happens.

I haven’t made a single non-chat notebook since I figured this out. 🌈

of-music

🎥 A video about Blockhead (experimental digital audio workstation) via Alex McLean

🧵 conversation

🎙️ FoC 67: Go To Statement Considered Harmful 🎥 Demos & More Demos 🐇 Plan B: An Operating System for Smart Spaces

Two Minute Week

🎥 Arithmetic demo via Jean-Louis Villecroze

🧵 conversation

This week I rewrote an older demo to work more like the more recent work I have done. It runs in 69s but have no commentary … 🤔

🎥 Visual Evaluation in GRASP via Maciek Godek

🧵 conversation

Yesterday I finished implementing the core functionality for the visual stepper in GRASP (and so I made this rather cheesy demo video)

Our Work

🎥 💬 Graphical Command Interfaces via Mariano Guerra

🧵 conversation

💬 Graphical Command Interfaces

🐟 Stop asking dead questions

Prototype of a conversational UI that uses LLMs to reply to questions in human language with graphical and interactive UI components.

🐸 TODEPOND PONDCAST: Strange loop via Lu Wilson

🧵 conversation

Ivan Reese was a guest host of my weekly PONDCAST

🎙️ Future of Coding • Episode 67 • Edsger Wybe Dijkstra • Go To Statement Considered Harmful via Ivan Reese

🧵 conversation

Go To Statement Considered Harmful is a solid classic entry in the X Considered Harmful metafiction genre, authored by renowned computer scientist and idiosyncratic grump, Edsger Wybe Dijkstra. Surprisingly (given the impact it's had) this is a minuscule speck of a paper, lasting only 1-ish pages, and it even digresses several times from the main point. Fear not! Jimmy and I spend the entirety of these two podcast hours thoroughly analyzing the paper, wringing every last drop of insight from it, speaking directly to how programming ought to be reimagined from the molten venture capital core on up. Yes indeed, this is another episode in the fine tradition of Future of Coding where we stay faithfully close to the text, we leave the second-order implications alone, and there's nothing more than that. Nothing portended, nothing changed.

Devlog Together

💬 Kartik Agaram

🧵 conversation

I've been "building" an "instrument". Thanks to some samples from Ivan Reese.

🎥 MiniIDE instrument

🎥 bubble sort implemented in a visual flow via Maikel van de Lisdonk

🧵 conversation

Bubble sort is a simple algorithm and offcourse in a real-live scenario you won't implement this using a visual programming environment... however, it's a nice test-case to help building a visual programming environment because it needs to be able to modify an array amongst other things.. So I've introduced the concept of being able to send commands to an array-node. When items are swapped, this is visualized by the array-node with some borders flashing and changing colors around the items that are being swapped. 🎥 bubble sort implemented in a visual flow .. furthermore the array is iterated using a foreach-node which triggers a sub-flow for each array item.

Thinking Together

💭 by Tim Lavoie

🧵 conversation

Re: Future of Coding - Apple Vision & Dynamicland

Probably unpopular ideas, but here's my Black Mirror take:

• What's tasteful won't matter, as long as it's popular.
• Success of these "spatial computing" concepts will come from what gets the masses interested.
• Whatever will be successful, porn will do first, as they always have. Now the action is with you, or you're "there". Consent from other people actually with you is left as an exercise for the reader.
• Ditto for Snapchat-like filters that are applied to other people in the room with you. Everyone naked? Everyone's a furry? Maybe we present virtually as we choose for other goggle-heads? Back to consent again, for, "who wants to see the naked furry centaur in the coffee shop?"
• Extra points for integrating Dynamicland-like badges that people wear, interpreted by the goggles as, "don't VR-alter me." Another one for, "don't apply facial recognition to me." Naturally, law enforcement gets a version that the latter filter doesn't apply for, and the tech leaks to hacky patches for consumer hardware.

🎙️ Looming Demise bonus episode via Lu Wilson

🧵 conversation

Re: Looming Demise bonus episode

It reminds me of this

👓 twitch.tv/hamish_todd/videos via Hamish Todd

🧵 conversation

I'm making a basic color picker for my designed-for-children VR animation program (streaming development here twitch.tv/hamish_todd/videos). Simple question: is it a good idea for "eraser" to be a "color" in my color picker, rather than its own button? Veeeeery limited number of buttons on a VR controller and I want to minimize menus!

🎥 Plan B: An Operating System for Smart Spaces via Arcade Wise

🧵 conversation

A really cool environmentally aware system based on plan 9, an operating system I have a big soft spot for

🎥 Excel to web app tutorial via Scott Antipa

🧵 conversation

I was building out a prototype and thought there must be a way for a designer or someone to use excel to put together basic ui. Found this

🎥 Searching for Justice in Programming Language Design via Jason Morris

🧵 conversation

Via @Devine Lu Linvega on Mastodon: Come for the hybrid block/text editor and the time travel debugging, stay for the social Justice.

📝 Notational Programming for Notebook Environments: A Case Study with Quantum Circuits | Proceedings of the 35th Annual ACM Symposium on User Interface Software and Technology via Christopher Shank

🧵 conversation

“Notational Programming for Notebook Environments: A Case Study with Quantum Circuits” by Ian Arawjo, Anthony DeArmas, Michael Roberts, & Shrutarshi Basu (2022)

🕸️ Visual Node Graph with ImGui via Jean-Louis Villecroze

🧵 conversation

HackerNews link and conversation on visual programming

🎭 wordplay.dev via Christopher Shank

🧵 conversation

“Searching for Justice in Programming Language Design” by Amy Ko (2023)

wordplay.dev (releasing later in the fall)

🎥 Deconstructing CS Culture – Dr. Amy J. Ko – 2021 IEEE RESPECT Keynote via Alex McLean

🧵 conversation

I wasn't familiar with Ko's work, so checking some of her earlier stuff

☞ Computation as Philology 🎭 The Meaning of Live 📖 Programming Interactive Fiction 🧮 Logic is Algebra

Two Minute Week

🎥 Fibonacci implemented in a visual flow via Maikel van de Lisdonk

🧵 conversation

Hi, this week I finally managed to make a much smaller version of the fibonacci algorithm in a visual flow : youtu.be/hO_emZq0dEI

What helped, is to be able to define variables inside a flow and use them in an expression, even if the variables are defined in nodes that comes after the expression node in where they are used. In this case it's an array variable node that is needed.

Something that I currently am trying to accomplish is creating visual flows that are smaller and therefore hopefully clearer and more helpful in explaining algorithms.

In my previous visual implementations of the Fibonacci algorithm much more nodes and connections where needed not helping in explaning the algortihm (in the thread I have shared a previous implementation).

I think this new approach helps and I'll explore this further.

** update ** after uploading the video I got another idea that helps showing the invisible connections between the nodes: when the array/list-node elements are read or an item is added.. a small rectangle around the element now flashes 😎 .. so I've re-uploaded the video

Our Work

☞ Computation as Philology via Sam Arbesman

🧵 conversation

Folks here might get a kick out of this essay I wrote: arbesman.substack.com/p/computation-as-philology

Logismics and the wide-ranging impacts of computing

🎥 🐢 UI Combinators all the Way Down via Mariano Guerra

🧵 conversation

🐢 UI Combinators all the Way Down

🛠 UI Combinator builder to create & preview components

⏪ Undo history implementation

⚖️ An experiment using a Rules as Code encoding in Blawx to create a converational tool that can accurately and explainably answer questions about that law via Jason Morris

🧵 conversation

The REAMDE.md below tells the story of how I used the user-friendly declarative logic tool I built over the last couple of years to encode a small portion of Canada's Privacy Act, and then had that code used as a tool by a langchain agent. Very interested in anyone's thoughts on both content and form. It's not as easy as it ought to be to talk publicly about what you are doing inside GoC, but evidently documentation for an open source software repository is something of an exception to the usual rule.

🪣 Fractal bucket via Lu Wilson

🧵 conversation

My plan for a new visual programming language, currently named Fractal bucket

📝 Building machine learning products: lessons from Papercup's product team - Papercup via Kilian Butler

🧵 conversation

This isn’t as interesting as what most people here are doing but I wrote a blog post about building products with machine learning at their core.

I’ve been working on ML focused products for the last 4 years and have learned a lot. Hopefully it may be useful to someone out there 😇 Always happy to chat ML products if anyone’s interested

How to utillize machine learning capabilities to develop valuable products with real-world use cases.

📝 The Meaning of Live: From Art Without Audience to Programs Without Users via Alex McLean

🧵 conversation

The Meaning of Live: From Art Without Audience to Programs Without Users with Julian Rohrhuber and Renate Weiser

It includes critique of what we saw as the common approach to 'liveness' in future of coding community. We explain ways in which live debugging is the opposite of live coding.

The concept of an `art without audience' has informed live coding since its beginnings. Live Coding concentrates on collective work and questions the division between producers and consumers. This understanding of art has enabled a parallel strategy in the understanding of programming: just as an audience is not necessary for art, a user isn't necessary for programming. In the same sense as we question the separation between developer and user, we question the juxtaposition of artist and audience. This gives us occasion to recall some aspects of live coding which we have always found central to this practice: the displacement of the relation between programmers and programs, and the emancipatory potential of public thought.

Reading Together

🧮 Logic is Algebra via Nilesh Trivedi

🧵 conversation

"Logic is Algebra" paper suggests Abstraction Logic as foundation of mathematics

It's from the creator of Practal proof language: practal.com

Logic really is just algebra, given one uses the right kind of algebra, and the right kind of logic. The right kind of algebra is abstraction algebra, and the right kind of logic is abstraction logic.

Thinking Together

💬 Paul Tarvydas

🧵 conversation

Ivan Reese and @Alex McLean mentioned “...hand drawn programming environments...“. The first thing that I think of when I hear this is “whiteboards”. What are the dimensions involved in whiteboards? x/y/t. T goes forwards (e.g. adding new details by drawing them in over time) and backwards (erasing parts of drawings). Iteration. Scrubbing.

💬 Guyren Howe

🧵 conversation

Why on earth, in this era of many-gigabyte machines, don’t all programming languages have a time-travel mode for debugging?

📖 Inform via Qqwy / Marten

🧵 conversation

Hi all! New here, but latest episode of Future of Coding (‘ 66 - a Small Matter of Programming ’) made me think of something closely related.

Part of the discussion was about using formal vs informal language to communicate with a computer, and whether ‘end-user programming’ would be feasible using those methods or not.

One tool which came to mind is ‘Inform’. It is a tool (mainly a programming language, though it also ships with its own IDE-like thing) to write text adventure games.

But rather than being geared towards programmers , it is geared towards writers.

An example of a simple program:

The Cabin is a room.  "The front of the small cabin is entirely occupied with navigational instruments, a radar display, and radios for calling back to shore. Along each side runs a bench with faded blue vinyl cushions, which can be lifted to reveal the storage space underneath. A glass case against the wall contains several fishing rods.

Scratched windows offer a view of the surrounding bay, and there is a door south to the deck. A sign taped to one wall announces the menu of tours offered by the Yakutat Charter Boat Company."

The Cabin contains a glass case. In the glass case is a collection of fishing rods.

The case is closed, transparent, and openable.

The bench is in the cabin. On the bench are some blue vinyl cushions.

The bench is enterable.

The Beach is a room. "A beautiful beach where the sunset can be seen. Some seagulls are flying overhead."

The Beach is south of the Cabin.

Some points for consideration are:

• Where do you think a language like Inform fall on the ‘formal’ vs ‘informal’ spectrum?
• Inform is perhaps the most widely used tool to create text adventures with today. Could this be considered a success story where non-programmer end users were able to build something through ‘programming’?

📝 Attempto via Konrad Hinsen

🧵 conversation

Where do you think a language like Inform fall on the ‘formal’ vs ‘informal’ spectrum?

Preliminary question; what exactly changes from one end to the other of that spectrum? My current answer is: how much of the total information conveyed is formal. I'd love to hear from others who have thought about this question, or know about work on this topic in the literature.

To illustrate my definition, a few examples:

• Machine code is near 100% formal.
• Standard programming languages are mostly formal, the informal part being the variable names, which convey context-dependent information to humans but nothing to the compiler/interpreter.
• Markup languages (HTML, Markdown, ...) are mostly informal, because the formalized information is not the most relevant part. You could strip it away and the rest would still fulfill its purpose.

There are lots of subtleties I am glossing over. Example: A Python program saying print("...") with a 100 KB string is basically just decorated informal prose. My definition applies to typical or intended use, not possible extremes.

Back to Inform: I cannot judge from the example which information is extracted from the code by formal processing. Is this a controlled natural language, like Attempto ? Or plain English from which some engine extracts isolated keywords?

📖🎥 NarraScope 2020: Inform 7 Update via Alex McLean

🧵 conversation

On another inform tip, I really enjoyed this talk from Graham Nelson, with lots of take-home ideas for making a learnable language that's engaging and open to change

💬 Alex McLean

🧵 conversation

One thing I've noticed working with Realtalk is that the natural language style tends to have a trade-off in making things easy to read, but a bit harder to write.. You can read them like English sentences but if you try to write them that way you probably will get a connective wrong or some other subtle thing and it won't parse or won't communicate with something else.

More generally I think it's easy to conflate readability and writeability, they're obviously related but still quite different properties.

Actually for a lot of things writeability is far more important than readability. E.g. when live-coding music you don't necessarily have to read/understand exactly what code is doing because you can understand the code by experiencing the results while writing, rather than reading the code.

💬 Tim Lavoie

🧵 conversation

I had a couple thoughts bouncing around, listening to, 66 • A Small Matter of Programming by Bonnie Nardi.

• Jimmy mentioned writing browser extensions. Just recently, there was a thread (probably on HN), with discussion of people sharing filter snippets for uBlock Origin. It turns out that besides simply filtering links and so on, the snippets are also being used to modify styles and visibility for all sorts of things that people find needing change on various web sites. This, along with the whole "view source" era discussion, suggests that it hasn't gone away. Browser extensions such as uBlock Origin also include a colour-style picker for identifying the elements on the page that you're interested in. So in a way, it is very much enabling a simple sort of end-user programming, right in the browser. You won't see the back-end, but can manipulate the DOM that is very much on the client.
• Regarding the discussion in the episode on early education, teaching kids programming, I was thinking along the lines of teaching the means to observe. "View source" is one such part, along with browser dev-tools. Perhaps most people won't be interested in modifying the programs they use, but teaching the idea that introspection, via software-as-microscope, is possible. Too much of our computing is directed to being strictly consumption, that I suspect few people will even think of being able to look at the innards. Think Wireshark for networks, source-level debuggers where you have source, or binary analysis tools where you don't. (Probably related, I got a Snapshot cartridge for the C64 as a youth, and was amazed at being able to capture the entire state of a program, fiddle with it, and save it as an executable to resume.)

🎥 I'm Re-Imagining the Command Line Interpreter via Peter Saxton

🧵 conversation and 🧵 conversation

This was an interesting video. Not sure what the state of the project is, but it got me thinking along similar lines.

Content

🎙️ ‎Happy Path Programming: #82 The Future of Programming via Greg Bylenok

🧵 conversation

This podcast may be of interest to this group: "The Future of Programming" by Bruce Eckel and James Ward. What does the future of programming look like? In their opinion:

• static typing over dynamic typing
• IDE support is a must
• the happy path is the resource efficient path
• transparent concurrency
• transparently distributed systems
• embedded DSLs

📝 How the Mac didn’t bring programming to the people via Mariano Guerra

🧵 conversation

Macs have brought a great deal to us over the years: desktop publishing, design, image editing and processing, multimedia, and more. One of the few fields where they have failed is programming, despite many attempts. Here I look back at some of those opportunities we missed

HyperTalk, AppleScript, Prograph, Automator, Swift Playgrounds and Shortcuts – all wonderful tools in their day, but none has brought coding to the crowd.

📝 Notes on craft and interaction design via Alex McLean

🧵 conversation

Loving this annotated bibliography of craft and interaction design

📝 It's okay to Make Something Nobody Wants via Jean-Louis Villecroze

🧵 conversation

Saw this article on hackerNews … thought it was pertinent to me, albeit oddly phrased at time but the author is likely not a native English speaker (like myself) so that’s to be expected 🙂

Products seem to be made for users, but I think this might be an illusion; they are more like a medium for self-expression. Different expressions, conceived by various minds, undergo a form of natural selection, with the surviving expression being the one that resonates most with users. I mean, the process unfolds like this: you create something not because “I think they might need this,” but because “I find this so fucking interesting.

📝 Ashley Blewer via Jonas

🧵 conversation

Hey! So Ashley Blewer has created this wonderful syllabus to go along with the TV show "Halt and Catch Fire" (2014-2017), "a fictional narrative about people working in tech during the 1980s-1990s." The syllabus features readings on the history of technology, computers, programming etc. as well as recommended RFCs and emulators of old systems to take a look at to provide material for discussions about a set of episodes.

I wanted to watch the show for a long time now, and since I really enjoy the A Pattern Language book club that was linked to here a few months ago, I thought it might be a nice idea to create a watch club to go through the series together–the way Ashley intended!

I created a Discord for this purpose. Right now, no date has been set for the first session, as I want to give people some time to show up first. I'll announce the schedule soon. If all this sounds like something you might be interested in, please join me in this adventure!

Here's the link

💾 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?