✉️ Not subscribed yet? Subscribe to the Newsletter
Future of Coding Weekly 2023/10 Week 3
📐 Geometry to Algebra and Back Again 🧮 Computational Physics 💡 Forth, Prolog, Petri Nets and LLMs
A blog post about my recent adventure into improving my Mastodon experience, do-it-yourself style:
Not quite end-user programming, definitely not professional software development, but something in between.
Ever since I joined Twitter in 2011, and then moved to Mastodon in 2022, I have been unhappy with the timeline view proposed by both of these communication platforms as their main interface. Now I have finally done something about it: I wrote my own Masto...
📝 Feminism — Matt Wynne via Matt Wynne
I wrote a piece about feminism, and what patriarchy means for "agile transformations": mattwynne.net/feminism
In this post I want to talk about feminism: why I have personally embraced it, why I encourage you to, and — since you’re probably readin...
💻 github.com/geoffw8/hyperlayer via Geoff
Very proud to introduce ⚡️Hyperlayer - Debug Rails apps 10x faster:
☝ Code and demo video in the repo.
It works by creating a visualisation layer which combines application flow, state and the code itself. It utilises Tracepoint and AST under the hood to build the visualisation. This visualisation means you can cut out a significant portion of the steps we have to go through to "manually" debug an issue, leading to the timesave.
I would absolutely welcome any feedback. I think it could be a big deal!
I'm really excited about being able to share this with the world.
💬 Marcelle Rusu (they/them)
Started working on a prolog backend for coil.
Here's an example of compiling a coil program to prolog & exploring the codebase via prolog repl.
This is early but the hope is to have an easily explorable codebase, to really treat the codebase as a database.
Ambition for this is
- Allow users of coil to write their own rules in prolog to ensure things about the program
- Make writing a type checker easier for me
- Make writing tooling for coil easier
Conversational User Interface Prototype
Select & pre-configure interactive UI components by asking an LLM in natural language
Group them in sessions
Reuse workflows by storing sessions as templates
📝 m-ld via George Svarovsky
It's intended to allow programs to be written "local-first", having a reactive local model that is concurrently editable from multiple remote locations, with a guarantee of eventual consistency. So, you more-or-less write your code as if the data is 100% local, embedding m-ld as a library, and magically find that other remote participants can read and write the data too (subject to security!).
There are two main use-cases we're targeting – client apps, like office tools, supporting collaborative editing (GDocs-style); and microservices sharing information like configuration or master data. In both cases, you don't need a (extra) server for the data (though you do need a way to pass messages, for example a pubsub).
I've been working on this for a while so there's a million things I could ramble on about, but I'm curious to know if the above pricks up anyone's ears. Do those use-cases sound, well, useful? Does my description make you want to know more, or, ho-hum? Any feedback is welcome; will return with recent focus later! Many thanks
My talk on geometric algebra from this year’s Strange Loop/Papers We Love Conference, embedded in a mini-site with the video, a transcript, and links to all the papers I mention.
4000 Years of Papers
A look at what Sam Ritchie has been working on with Emmy, a Clojure computer algebra system ported from Sussman’s scmutils, that also features quite a bit of Clerk
… some of you might see where all of this is going — an open source, Clojure-based Mathematica-like system.
💬 Arcade Wise
: fizzBuzz? ( n -- ) "" swap ( str n -- ) ( str n n ) dup 3 % 0 = ( str n ) if swap ( n str ) "Fizz" concat ( n strFizz ) swap then ( str n n ) dup 5 % 0 = ( str n ) if swap ( n str ) "Buzz" concat ( n strFizz ) swap then concat . ; 1 100 do i fizzBuzz? loop
I have been working on a forth implementation, and this fully works now! I'm super excited to show the cooler stuff that goes along with it too :>
💬 Arcade Wise
Compendium and demonstration of simplification techniques for composing software programs.
📕 Languages for Developing User Interfaces via Beni Cherniavsky-Paskin
1991 workshop proceedings looks interesting but not sure it's worth buying 🤔 But amazon free sample is generous, reading that first...
🧫 guarded petri nets via Don Abrams
I'm looking at defining a collaboration-centered language that has sound semantics (ie semantics under composition are intentional and generally useful)
My understanding is that you can only verify semantics for a specific model, so trying to define a "good enough" model
Do y'all know of any papers on the tradeoffs of various "computer" models for distributed machines? Bonus points if it has time costs and resource limits built in and supports heterogeneous machines.
💬 Janne Aukia
Has anyone thought about or written about malleable software + LLM:s? I feel that it is an area that could be quite interesting, but I haven't got yet a clear understanding on what this will lead to.
I think that pretty soon most of end-user code will be generated with the help of LLM:s. Some thoughts/questions I've been thinking about:
How to generate programming languages, libraries and abstractions that LLM:s can use well? Is that different from generating libraries etc for humans?
LLM:s are faster than humans in processing data, so API:s can be really wide and probably more complex than what would be practical for devs.
- LLM:s can probably handle more condensed/optimized representation better, too.
And be able to infer system affordances directly from code.
How to support creating good and maintainable code from LLM:s? And will that matter? Or will actual code become irrelevant?
How to modularize apps so that they can be easily composed by LLM:s?
My hunch: making apps modular and composable would work really well with LLM:s already now and even better in the future. Doesn't matter if functional or OOP, as long as the LLM can understand the logic.
What kinds of new apps and malleable software will LLM:s enable?
- Also: LLM:s could finally enable removing some boundaries between different programming tools, library ecosystems, etc, by enabling translations/bridges automatically.
📝 Ursula Franklin’s tech project checklist via Alex McLean
Kartik Agaram's draft programmer's pledge reminded me of Ursula Franklin's checklist for technology projects, which is a bit hidden in one of her really excellent 1986 lectures on the "real world of technology"
“… whether it:
(1) promotes justice;
(2) restores reciprocity;
(3) confers divisible or indivisible benefits;
(4) favours people over machines;
(5) whether its strategy maximizes gain or minimizes disaster;
(6) whether conservation is favoured over waste; and
(7), whether the reversible is favoured over the irreversible?”
I'll pull out a couple of quotes, first on 3) divisible/indivisible benefits:
“If you have a garden and your friends help you to grow a tremendous tomato crop, you can share it out among those who helped. What you have obtained is a divisible benefit and the right to distribute it. Whoever didn’t help you, may not get anything. On the other hand, if you work hard to fight pollution and you and your friends succeed in changing the practices of the battery-recycling plant down the street, those who helped you get the benefits, but those who didn’t get them too. What you and your friends have obtained are indivisible benefits.”
and on 7) reversible vs irreversible:
“The last item is obviously important. Considering that most projects do not work out as planned, it would be helpful if they proceeded in a way that allowed revision and learning, that is, in small reversible steps.”
5) on maximising gain vs minimising disaster is also a really interesting point, where she argues against planning, and for finding the right conditions for something to grow, at its own rate.
I just (finally) figured out how to represent my coding language as a directed multi-graph with labeled edges. Now I'm wondering if the interpretation steps could be represented as graph translations, so you could literally "watch" it execute. Anyone have any ideas for libraries that I could use to explore that idea, or examples I could look to? My current best guess is NetworkX and visdcc+dash.
💬 Eli Mellen
What does it mean to you when someone says something like “code as literature?”
Often the implication seems to be that code should be readable — which I take to mean “understandable,” which I further take to me “as a person looking at this code I can map what it’s output will be.”
Where my specific hangup enters is that a lot of literature isn’t directly “understandable” in this sense. There are many layers at which to understand literature. How about code? Code as more than it’s outcomes.
💬 Josh Cho
better DSLs for prompt engineering? i am being inspired by forth
observation: similarities - Forth, de Bruijn Indexing, Lambda Calculus, Currying ...
FYI - David B. McClain wrote Forth for a living (Kitt Peak) and is now using Lisp. I posted some of his comments here, including a reference to his Forth in Lisp: David mcclain on forth
Did a technical assignment for an interview this week, and made extensive use of ChatGPT4 to great success. It's to the point now that if I get an error message I don't understand, or get to a step where I'm unclear what to do next, I'll try ChatGPT4 before I will try Google, because with ChatGPT4 it already has the context for the problem, and gives me an answer specific to my context. Very different programming experience.
💬 David Alan Hjelle
I was curious this morning: my naïve view of compiler history is that they used to be very small (due to performance constraints) and have gotten very complicated over the years in order to support multiple platforms and in order to employ more and more optimizations. Is that generally a fair take? What are the big changes to compiler architectures from the early days? Does something like LLVM produce enough better code to justify its complexity? Are there any blog post- or paper-length history of compilers articles out there? (I'm not quite so curious as to be ready to read a whole book, but if you've got a good recommendation…)
A question that came up in a discussion this morning:
Suppose you want to publish a command-line utility program, meant to be easy to use. Doing Web retrieval and some post-processing. Around 500 lines in a typical scripting language, but with dependencies (in that language plus C libraries).
It looks like packaging such a tool for all popular platforms (i.e. package managers) will be a lot more work than actually writing the code.
True? Any way to avoid this?
Ideas so far: don't use a scripting language, but something with a compiler that can produce portable executables for every major platform. Recommendations in that category so far: Go, Rust, Racket, Common Lisp. I have doubts that all of these can handle "plus C libraries", but it's a start.
Does anyone here have actual experience with this kind of project?