How to sanely scope synchronization is always a deep and interesting problem especially once you get around the often accidental complexity of alignment.

Yes, pretty cool!

This weekend was spawnfest, a 48 hour BEAM Jam (Erlang, Elixir & other BEAM languages). I created dtu aka Data The Ultimate, a data format that, unlike YAML, allows to define pretty decent programming languages, below some links: • • Full Stack Todo MVC with 4 dialects in a file • Format Description The short version is that it's a data format that makes it easy to define DSLs and translators, I implemented translators for subsets of CSS, HTML, JS and Erlang, enough of each to create a Todo MVC app in a single file, since all "dialects" have the same syntax and share code each one can "enter" another dialect and embed the result in the outer one in the way it makes sense. For example, the `style` node will render the CSS in the body like here. The CSS in the `style` attribute will render it inline as a string like here. Erlang embeds HTML, CSS and JS inside Erlang as seen here, in this case the content is rendered as a string to be served as a response to a

GET /

request, you can see the result here.

I have a new idea for doing links in Scroll (our extensible successor to markdown): https://github.com/breck7/scroll/issues/74

* If you want THESE THREE WORDS^^^ to be the link. A oneWord^ link.
 ^^^ someLink.html
 ^ <https://oneWordlink.com>

// Has anyone seen this done before?

Been improving my visual editor for compound graphs: https://grapherx.netlify.app/ . Recent additions: Undo/Redo, Multi-select, snap-to-grid, read-only mode etc. This tool is now being used by the Foresight institute for their civilizational tech trees for domains like nanotech, neurotech, spacetech, longevity research, intelligent cooperation: https://foresight.org/tech-tree/

Future of Coding • Episode 59 Richard P. Gabriel • Worse is Better 🔗 https://futureofcoding.org/episodes/059 Following our previous episode on Richard P. Gabriel's Incommensurability paper, we're back for round two with an analysis of what we've dubbed the Worse is Better family of thought products: 1. The Rise of Worse Is Better by Richard P. Gabriel 2. Worse is Better is Worse by Nickieben Bourbaki 3. Is Worse Really Better? by Richard P. Gabriel Next episode, we've got a recent work by a real up-and-comer in the field. While you may not have heard of him yet, he's a promising young lad who's sure to become a household name. • Magic Ink by Bret Victor I am usually really thorough in my editing of the show, but this one I sort of had to rush out the door because the month is rapidly drawing to a close. If anyone spots any weird edits, or anything that sounds out of place, let me know. In particular, the sponsors (which now come at the end of the episode) might be a little rough. Oh well — pays the bills, amirite?

Hello everyone, I've made a little video demonstrating my visual/spatial programming tool! It's called ⚡

Hello! After a 5 month break, we have resumed our activities. We haven't officially released the product yet, but I have written a draft of introductory articles. I would be happy to hear your feedback. The official release of Desk is scheduled for the end of this month. https://github.com/Hihaheho/Desk/blob/main/docs/blog/0001-introduce.md

We made a bot to create Slack thread summaries with GPT3 ✨ Hi, we built a Slack app to summarise long threads in channels: https://www.buildwithforest.com/summarise-with-forest We built this using our product Forest (http://buildwithforest.com/) which allows developers to build workflows and connect APIs extremely fast. We are still early in our development and would love to chat with developers who think Forest could be useful for them and get feedback!

I've converted my long thread of curated classic HCI demo videos into a mini-site with authentic period styling. :) https://jackrusher.com/classic-ux/

It's been forever since I wrote a blog post! This one is a long-time coming on a topic near and dear to many of us (EUP). I propose "end-programmer programming" as a pit stop to the dream of end-user programming, and flesh it out in the context of my current project (Val Town) and experiment (HN Follow). Feedback is much appreciated! ❤️ https://www.notion.so/val-town/End-programmer-Programming-a749beb4a9b143f2990f575fb7e59b33 Thanks @Kartik Agaram @André Terron @Sam Arbesman @Geoffrey Litt for feedback!

an older article i wrote but one i'm revisiting right now on a project about thinking of business processes as types rather than code paths - https://deathbykeystroke.com/articles/20220517-business-processes-as-types-lets-explore.html

As promised in my intro, here’s a little bit of current thinking I wrote up about what feels like I’m going to end up building a DSL to let ecologists work on large datasets. https://digitalflapjack.com/blog/yirgacheffe/ Currently it’s a Python library that lets ecologists just work with large geospatial files as if they’re variables, like numpy does, but manages the memory side of things, as these files quickly can cause you to run out of memory even on a 1TB RAM machine like we have in the group. The next thing I have in the wings is trying to hide Python multiprocessing support behind my library, for two reasons: • I’m already chunking up the computation, so throwing it out to many cores to get concurrency seems like a natural fit. Early on in my time here I tried to encourage the ecologists to think in terms of small programs that would then be run concurrently, but that didn’t really work for how they think of programming, so I think letting them think single threaded whilst I hide concurrency is probably easiest. • GDAL, the library used for a bunch of the actual geospatial transforms is leaky as anything (or rather, it’s Python bindings are), and so pushing that into child processes is a win, as it’s the only real way to clean up properly. But at this point I think what I’m not doing is a good fit for Python anymore, so I kind of envisage a Go backend, where I handle the concurrency side of things, and a small front end language where I let the ecologists reason about geospatial files as opaque blobs, and possibly have CSV as a natural thing. But I also think this is a good fit for a visual programming language, where you connect the CSVs and geospatial files by the kind of operators you’d do normally, and then having that be the ecologist view on the world. I guess my main aim is to try and not do everything though - if you imagine this was wildly successful, then all I’m doing is making yet another data-processing system that is specialised in one thing that someone will then want to do what I’ve done for some other metric down the line. So I think I want to deliberately keep this focussed/niche rather than accidentally drift into building something generic that will inevitably not be good for other purposes.

I would like to share with you my open source project - Semantic Code Search ( https://github.com/sturdy-dev/semantic-code-search ) The tool lets you search code with natural language (you don’t need to know the exact keywords), for example: • ‘Where are API requests authenticated?’ • ‘Saving user objects to the database’ • ‘Handling of webhook events’ • ‘Where are jobs read from the queue?’ It’s a command line app and is fully local, and it was so much fun to build (and train)

hello everyone I did a little spatial-programming demo at the London meetup yesterday and fortunately, the second half of it got filmed! You can watch it here: youtu.be/bqtVv9ts29c and it was great to meet so many more people at the meetup!

Not related to coding, but I have long been annoyed by how hard it was to discover and curate the best learning resources of the Web. Google/YouTube/Wikipedia do a terrible job of it and so do universities/coursera/edX by never linking out to the Web (eg: 3Blue1Brown or SmarterEveryDay). I wanted to collect links to amazing videos, interactive explorables, books, research papers and organize them by topics, formats, difficulty level etc. This is what I made: https://learnawesome.org/ Some highlights: • There is a custom topic taxonomy and a zoomable treemap. • For books and papers, I make it easy to find them on SciHub/LibGen etc. When possible, resources like videos/wikis are embedded directly. • I am planning aggregate reviews to help you select a resource among many available. So, under "Sapiens", you will see that Bill Gates recommends it highly. • There is no server and no user accounts. Your bookmarks are kept in browser's localStorage only. • Above all, this is a work-in-progress. Expect breakage. Would love to hear thoughts and feedback. 🙏

Hi, I've finally found time to make a small video.. I am showing a flow that represents a very small crud-application where I reconnect multiple connections at once as well as connections being animated when they are retriggering (like when using a timer). Hope you like it!

I saw the ‘AI found a bug in my code’ on HN and I wanted to try this out on my code. Since the tool was not open sourced, I decided to build it from scratch myself 👨‍💻😅. So I present to you Suspicious (https://github.com/sturdy-dev/suspicious) It’s a fully local CLI app which analyses your source code file. It then shows you specific parts of the code where it would have done something else. Demos & screenshots in the GitHub readme. Let me know if it catches anything good for you 🙂

Hi everyone, I’m going to start live-streaming myself using Lamdu to solve this year’s Advent of Code problems every day during the month of December on my YouTube channel starting tomorrow at 18:00 UTC at https://www.youtube.com/@yairchu/streams, and I wish to invite you to come watch and join the conversation! It’s my first time doing something like this, and I really hope that it will be interesting 🙂 For those who haven’t heard about Lamdu (http://www.lamdu.org) : It is a structural editor and language quite similar in its vision to Unison, Dark & Hazel, It’s an open-source passion-project of @eyal and myself (more contributors always welcome of course!), and its goal is to make programming delightful :) It started in 2011, and was the first to create a structural editor that almost feels like text editing (which we call WYTIWYS - What-You-Type-Is-What-You-See), and was also the first environment where all IDE services are available at all times without syntax errors or type errors getting in your way. Our solution for type mismatches is pretty much what some of you know from Hazel, but slightly generalised, more info here - Cheers! Yair

Who’s doing Advent of Code this year? I’m putting TypeCell to the test, and will be live-coding my assignments! Let’s see how far I get… 😬 Would be cool to see people in this community trying different Future of Programming systems! https://twitter.com/YousefED/status/1598288368164835328

For people doing it in Clojure, we have a Clerk template here: https://github.com/nextjournal/advent-of-clerk

Today’s Advent stream was nice and quick 🙂 It was honestly such a pleasant experience for me to solve it in Lamdu that I can’t imagine it having been easier in any other programming language / env that I’ve ever used! Though we still have some kinks to fix and missing features to implement, for the Advent of Code it feels already great!

I hooked up ChatGPT to my live programming system: https://twitter.com/YousefED/status/1599512716086910976

An essay about the history of compiler-appeasement languages, meant for discussion. [meta: I would be glad to move this to another channel or to remove it completely. One aspect of my “work” is to observe. FWIW, I share this...] Type checkers are helpers for development. Similar to parsing and syntax checkers. Type checkers are - currently - more difficult to write than syntax checkers. There was a time when syntax checking was not well understood and was difficult and was written in an ad-hoc manner. Early FORTRAN had syntax that we would consider weird today. Early FORTRAN did not treat spaces specially and went for the shortest match (I think). For example

IF

and

IFX

were both parsed as the beginning of an

IF

statement. Later, it was discovered that making spaces “special” would help in making parsers and would help in cleaning up silliness like

IF

and

IFX

. At the time, the character set consisted of ASCII (well, there was EBCDIC, championed by IBM, but, IBM was hated even more than Microsoft and Apple are hated today, so EBCDIC was mostly avoided by non-IBMers). The fact that ASCII only has 128 characters to choose from (some 32 “unprintables” must be subtracted from this count) made for silly decisions like denoting strings with the same beginning and ending quote (which makes parsing more difficult) and not-allowing spaces to be embedded in names. With Unicode, we have many more choices, but, we remain stuck with decisions made to appease 1950s hardware. Aside: in 2022, we have hardware that can handle vector graphics and overlapping graphical elements, e.g. windows and very-small windows (“buttons”, “widgets”), but, we are stuck with decisions made to appease 1950s hardware. I argue that we should be building languages based on vector graphics instead of non-overlapping characters. SVG is a simple example of something that might work on this front (rectangles, ellipses, lines, text, groups). Aside: “declaration before use” is a result of 1950s thinking (save CPU time by making compilers 1-pass), even though, in 2022, we could easily burn CPU cycles to figure out “declaration after use”. Aside: declaration-checking (before or after use) is only a helper for developers. The machine doesn’t care if you make a typo. “Declaration-checking” is an app to help developers stamp out simple errors (like typos). Demanding that programmers rearrange their code so that the declarations ALL come before the code is compiler-appeasement (based on 1950s hardware). The best way to write a type checker is to use a Relational Language (like PROLOG, miniKanren, Datalog, etc., etc.). Relational languages are shining examples of languages that don’t appease compilers. In a relational language, you write relations (“truth”) and let the underlying system figure out how to implement the machinery for matching up the relations. Other technologies that bark up this same tree: declarative languages and ML. (Aside: oh my, HTML is a declarative language. But, HTML needs to lean on JavaScript to allow imperative break-outs). There is no “ideal language”. The notation you use depends on the problem you are trying to solve. A simple example would be the idea of Spreadsheets vs. Lambda Calculus. Accountants and financial analysts like Spreadsheets. Programming rigor analysts like Lambda Calculus. Accountants would not want to use Lambda Calculus and rigor-ists would not want to use Spreadsheets. Another example, closer to my heart, is the difference between using Language Theory to generate parsers and using PEG to generate parsers. Language Theory-based parsers cannot do what PEG-based parsers can do (for example, parse balanced parentheses). Trying to force-fit language theory onto parsing has stagnated the field. Most languages look the same, with minor differences. (Aside: PEG is Parser Theory, not Language Theory, despite the superficial similarities in syntax). The fact that parsing is “difficult” has restricted programmers to using only a small number of programming languages, instead of using a zillion nano-languages and defining their own nano-languages (I call these SCNs (Solution Centric Notations)). “Dynamic” languages are “good” for fast turnaround on ideas, but are “bad” for producing end-user apps which are cost-optimized. “Static languages” are “good” for Production Engineering apps, but, are “bad” for inventing new products. Trying to force-fit all use-cases into one language results in a watered-down notation which isn’t particularly good for either use-case. (Aside: at the moment, efforts to force-fit all use-cases into one language favour the Production Engineering side over the Design side of things, and, this is what I call “compiler appeasement”. When programmers have to stop and rearrange their inventions to help the compiler figure out how to optimize, they are appeasing the compiler). (Aside: if Physicists ALL engaged in worshipping functional notation, we wouldn’t have Feynman Diagrams, nor Polyani’s “Order Out of Chaos”, etc.). Barnacles might be invented for helping developers, e.g. type checkers and linters. Twisting a language design to appease only pre-compilation is not OK in my book. At the moment, most of our programming languages are compiler-appeasement languages and insist that developers waste time (and imagination) on dealing with compiler-appeasement and pre-compilation issues, long before the program works. Barnacle-like pre-compilation was researched in the mid-1900s with work like Fraser/Davidson peephole technologies. This was called RTL and formed the basis of gcc. Cordy’s Orthogonal Code Generator is a generalization of this technique replete with declarative syntax for portability choice-trees (MISTs) and Data Descriptors and Condition Descriptors that improve on the virtual registers used by RTL. [This essay can be found in https://github.com/guitarvydas/py0d/issues/2]

Hey all, this blog post has been kicking around in my drafts for a while. I finally decided to complete it. It’s about thinking about compilation, basically the strategies and techniques that I’ve learned in my short time writing compilers. It’s what I wish I had as a resource when I started. https://github.com/NicholasLYang/uptointerpretation/blob/master/content/posts/how-to-think-about-compiling.md

Future of Coding • Episode 60 Bret Victor • Magic Ink 🔗 https://futureofcoding.org/episodes/060 Hey, ya'll ever hear of this guy? He posts some wild stuff. Feels like it might be relevant to the folks here. Maybe a little fringe. For instance, he thinks that software could be — get this — better! You might be surprised to learn that I also think software could be better. Radical idea, yes, but it feels like it's finally time for us to take the idea seriously. Next month, we're reading Peter Naur's Programming as Theory Building, with a little bit of Gilbert Ryle's The Concept of Mind as background.

I made a video to keep track of all the choices I have been considering while designing an effect system for my language https://vimeo.com/780465787

write-up of the end-user-programmable UI-builder I researched & prototyped for Glide: https://www.glideapps.com/research/code-components

If you have any Zoom/Google Meet calls today, here’s new something you can try: it’s a call bot prototype called Action Cat https://interconnected.org/more/2022/action-cat/ I’ve been writing recently about how apps could use spreadsheets to expose functionality, as a way to be useful but also open to end-user customisation. And I’m also super curious about how live feedback in a meeting can change the way that meeting works So this is an experiment about that! I ran into the folks at Reduct.Video and they were up for working together. It shows a live transcript of your call, and the twist is that is drops it into Google Sheets which is pre-configured to track phrases like “remind me”… but you can then search for anything, or do calculations like “who has spoken most” I’d love to hear about what it’s like to use, and whether this spreadsheet approach might be a more generalisable pattern

Sharing our latest write-up of building abstractions on spreadsheets 😄 https://subset.so/blog/building-abstractions-on-spreadsheets