You know that thing when playing Pokemon games where after you throw a Pokeball you frantically tap the action button to ... do something? It is never made clear if this helps or even does anything at all. What are other ghost-mechanics like this in games or software that you know of, where folks often take actions that aren’t clearly signposted to actually do anything? The most immediate other example that comes to mind is swiping apps away in the iOS app switcher, but that isn’t exactly the same thing, since, even if it doesn’t free up memory, it is a direct interaction that alters state (removes options from the app switcher).

Retrofitting of Medium I tend to think every time a new medium is introduced, all the contents of the previous medium are ported over, without regard for fully understanding the new medium. For instance, films matured when it stopped porting over books, games matured when it stopped porting over movies, etc. An excellent example of this is Outer Wilds, a space-exploration time-traveling game which is simply impossible to recreate in any other medium. It fulfills the medium. Given that, I think two new forms of medium are being introduced in the next 5 years: LLMs and VR. If we accept the supposition that there will be a lot of retrofitting of the medium, i.e. chat into LLMs, games into VR, what are the content that will truly fulfill the mediums of LLMs and VR?

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

What do you think about this?

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

https://twitter.com/ID_AA_Carmack/status/1689297553408315392

Welcome!

kam

joined #thinking-together. Also,

linen dev

joined.

Last night I spent some time documenting an almost-trivial state machine that I keep getting wrong: https://docs.google.com/document/d/1EbK4AxDCDWonMa8KyGJFX4jllXXLew0qBsGxsmqoYqk State machines are hard! • We usually have one in our head when we program. • The abstract state in my head is usually made up of multiple concrete variables in the program. • Mutations happen to variables, but it's not obvious at each how the abstract state is changing. • The state machine in my head often evolves, which makes documentation challenging to keep up to date. Which is why I think nobody builds documents like these. Tell me how immutability or State Charts will solve all my problems 🙂

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".

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?

…

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 https://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?

Quick reminder — please post replies as threaded replies. Thanks!

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.

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

Thoughts? https://twitter.com/cis_female/status/1697763571751674297?s=20

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: https://playb.it/, MercuryOS, https://alexanderobenauer.com/labnotes/000/ but I feel like there should be more

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 (https://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.

Welcome!

Samuel Timbó

joined #thinking-together.

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. https://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.

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?

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

@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.

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

@Shobhit Srivastava @Prabhanshu Gupta @Ravi Chandra Padmala and others: Let's have a FoC meetup in Bengaluru? Happy to host in Domlur.

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

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?

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

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.

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.)

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

Re: Future off 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.