✉️ Not subscribed yet? Subscribe to the Newsletter

Future of Coding Weekly 2023/09 Week 4

2023-09-25 00:08

☞ 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

Youtube Thumbnail

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

Youtube Thumbnail

🐢 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

Youtube Thumbnail

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

Youtube Thumbnail

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

Future of Coding Weekly 2023/09 Week 3

2023-09-17 23:06

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

Two Minute Week

🎥 A Visual Summary — Entity Graph via Pawel Ceranka

🧵 conversation

Youtube Thumbnail

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

Youtube Thumbnail

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

Vimeo Thumbnail

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

Youtube Thumbnail

🧬 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

Youtube Thumbnail

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

Youtube Thumbnail

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

Youtube Thumbnail

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!

ss.jpg

Future of Coding Weekly 2023/09 Week 2

2023-09-10 23:40

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

Two Minute Week

🎥 Lisp shell for deployments via Peter Saxton

🧵 conversation

Vimeo Thumbnail

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

Youtube Thumbnail

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.

Näyttökuva 2023-9-6 kello 15.20.16.png

Näyttökuva 2023-9-6 kello 15.20.27.png

Näyttökuva 2023-9-6 kello 15.20.51.png

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

🧵 conversation

Youtube Thumbnail

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

Youtube Thumbnail

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

Future of Coding Weekly 2023/09 Week 1

2023-09-03 23:30

🐬 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

Youtube Thumbnail

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

Future of Coding Weekly 2023/08 Week 4

2023-08-28 15:42

🎙 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

repl1.png

repl2.png

repl3.png

🎙 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

Youtube Thumbnail

  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

Youtube Thumbnail

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

Future of Coding Weekly 2023/08 Week 3

2023-08-27 18:50

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

image.png

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

Youtube Thumbnail

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

Youtube Thumbnail

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?

Contents © 2023 Mariano Guerra - Powered by Nikola