Future of Coding Weekly

Working on performance improvements now. Getting some nice visual effects thanks to uninitialized memory.

Our Work

🧑‍🔬 Account of the research project we’re doing at JetBrains by Pavel Mikhailovskii

Hi everyone!

I’d like to give an account of the research project we’re doing at JetBrains.

It is called Ludwig after Ludwig Wittgenstein and has an ambitious goal of re-engineering the foundations of the software development stack.

At the moment, we are still at a very early design and prototyping stage, but we believe that this project will let us create the next generation of development tools.

Here are the most important ideas we’re trying to materialize:

Liberation of code from the shackles of textual representation

Human-readable textual notations were a great innovation back in the 1950s. However, we have made great progress in the ways we store complex data structures since then, and the typical codebase sizes have also grown by a few orders of magnitude.

Code is essentially a graph with one tree-like perspective more important than others. An adequate way of storing such complex and evolving data as code would be to put it in a versioned graph / linked document database, supporting Git-like branching and merging. That would get rid of the need for continuous parsing, indexing, symbol resolution and typechecking that constitute the code editing workflow in modern IDEs. We would resolve symbols once, at the moment of typing and store their unique identifiers (not just names!) in an indexed by construction and preserving referential integrity database.

That would also make such intentions as Rename, Move, Find Usages or Go To Definition trivial to implement. Of course, structural representation of code will come hand-in-hand with structural (semantic) diff and merge.

This graph-like representation should allow for a fine-grained tracking of changes and dependencies and dramatically reduce feedback times in such scenarios as incremental compilation.

A minimalist approach towards programming language design

To prevent our language from becoming “fat and weak” as John Backus has put it in his famous lecture, we want to pass our language through a series of aggressive optimization rounds or distillation passes.

This should result in something comparable with Smalltalk’s “syntax on a postcard”. Actually, we believe that we could make it even more symmetric by eliminating the distinctions between methods, named and anonymous functions, operators and statements. (As you know, Smalltalk has different syntaxes and different behavior of return statements for methods and blocks and “surprising” execution order rules for different kinds of messages).

The goal is to come up with a language that would be easy to learn and read and straightforward to reason about for all kinds of agents-be it humans, static analysis tools or AI.

In terms of notation, it will look like an indentation-based syntax for a tiny subset of Lisp, but without its macros or the zoo of “special forms”. Being freed from the limitations of plain text, we’re going to use semantic coloring to make the notation even more expressive and compact.

Obviously, our programming language, as any other, should be able to express computation logic and code structure; what is less common is that we also want it to be able to express data, configurations and knowledge, thus eliminating the need for additional DSLs. A YAML-like data notation emerges from our tiny language as naturally as JSON emerged from JavaScript. The only difference is that JSON was discovered by chance, and our language is consciously designed to be able to declaratively describe complex data structures.

Unification of Object-Oriented and Functional programming

As a part of our minimalist program, we are aiming to heal the great schism that divided programming into the object-oriented and the functional worlds.

We believe that the class-free approach in the form proposed by Douglas Crockford will let us make OOP an integral part of functional programming, thus converging the two into what could be called unified programming. This form of OOP will keep the best parts—encapsulation and polymorphism and get rid of the "considered harmful" implementation inheritance. There will be no need for classes, constructors, prototypes, visibility modifiers, this and new - just immutable structures and anonymous functions.

An IDE designed for focus and context awareness

We want to build an immersive Smalltalk-like environment with structural navigation, a smaller editing scope and richer and more dynamic context compared to the traditional file- and text-based IDEs. This seems well-aligned with both the minimalist design of the language and the non-textual storage format. The latter should allow us to store some additional information alongside the code. That will include all kinds of metadata, normally invisible to the users, but also some unusual forms of embedded content. Think of a documentation comment containing a video explaining the algorithm or a discussion between multiple developers linked to a certain place in the code.

Smart typing

We also have some ideas on how we could implement some smart typing techniques, combining the convenience of automatic type inference with the solidness and discipline of explicit type annotations.

The key idea is that the flexibility of the non-textual representation will eliminate the need for the user to choose between the two worlds. Manual annotations can be hidden to reduce visual distraction, automatically inferred types can be displayed and persisted in the code database, etc.

Designed to be AI-fitting

Finally, we want the whole thing to be future-proof and provide better support for AI-aided development compared to the traditional languages. The simplicity of the language as well as its fine granularity and its property of always having all the symbols resolved should allow for high-quality “understanding” and retrieval-augmented generation of code compared to such languages as Python or Java.

As I said, at the moment we’re still at a very early stage. Many of our challenges are not technical, but about finding the way of how we could shape this set of ideas into a product vision. We are, of course, open to collaboration with like-minded people.

I will be happy to answer your questions and hear your feedback.

🎥 code::dive 2017 – Douglas Crockford – The better parts

💬 Jarno Montonen

Added tabular data and document template import to my notebook demo so now it can be used to fill/generate documents from csv/spreadsheet rows. Would any of you find something like this useful? I know there are a bunch of document generators, but the ones I've seen seem kinda crappy. Happy to hear about experiences using any of the existing solutions and why they suck though 😆.

🎥 Document Generation

📝 About - The Parallel Reality Computer via Duncan Cragg

Hiya folks, now that many of you have been digging in to Dynamicland's website for a bit and are in the right frame of mind, I was hoping that you may have had your neurons tickled in just the right ways to be open to reading about a project with some similarities: mine! 🤗

So I updated my About page, and I was hoping that it's now short and accessible enough to be just the info needed for you to "get" what my project is all about:

📝 About - The Parallel Reality Computer

Still lots missing, but check this out.

Lol, look at how it renders hyperlinks. This isn't going to be useful without some sort of delimiter or fence around math.

$fractions-bug.png$

Thinking Together

🪼 Physics of JellyCar: Soft Body Physics Explained via Christopher Shank

Youtube Thumbnail

What are ways we can make computation more squishy with soft-body physics? Most visual notations are overwhelmingly rigid and structured!

Content

💻 Decode via Ivan Reese

Decode — a new tldraw-based augmented coding canvas tool from @Francois Laberge

📝 Situated Computations: Bridging Craft and Computation in the Trinidad and Tobago Carnival via Jasmine Otto

a paper from an architectural journal that combines an ethnography with a sculptural grammar ('situated computations').

🧦 dynamicland.org via Alex McLean

I hear dynamicland.org will update sometime today..

💡 Donate to dynamicland via Ivan Reese

Somewhat buried in the new DL webpage — you can now directly donate to support their work. This is absolutely the sort of thing I'd back on Patreon, so I'm glad to see they offer those sorts of $n/month options.

📝 The Canary via Kartik Agaram

No coding here, but this is fantastic.

The Canary

And yet even now his father hovered in the background both as a rhyme and a presence. The careers of both men had been redirected by a simple question posed in a college class. Both spent their lives measuring the stress in stone. Both used scientific methods to answer questions that had seemed to everyone else beyond the reach of science. Both sought to understand what prevented roofs from collapsing. The father’s work had received a lot of public attention and the son’s had not. But that was just an accident of what people cared about. A lot of people cared about Gothic cathedrals; fewer were concerned with whatever was happening to workers deep underground.

📢 PAINT: Programming Abstractions and Interactive Notations, Tools, and Environments via Beni Cherniavsky-Paskin

Looking at SPLASH '24 program, I knew LIVE workshop is always very relevant (this year majority of lectures involve folks here); but also found PAINT which sounds great too 👀

In the workshop on Programming Abstractions and Interactive Notations, Tools, and Environments (PAINT), we want to discuss programming environments that support users in working with and creating notations and abstractions that matter to them. We are interested in the relationship between people centric notations and general-purpose programming languages and environments. How do we reflect the various experiences, needs, and priorities of the many people involved in programming — whether they call it that or not?

Areas of interest to PAINT include but are not limited to:

Design and implementation of program representations and their means of interaction for end-users of all ages
Design and implementation of visual programming environments
Block-based environments and their application
Projectional editors and their application
Languages and their environments with mixed notations
Meta tools or tool creation frameworks
Methods to support working with abstractions, such as example-based programming
Input and output devices for interacting with programming environments
Theories of the above

PAINT format is flipped, kinda critical review, and not recorded IIUC. But the past papers look interesting.

📝 A note on the PERQ computer via Ivan Reese

A fun little rollercoaster of computing history shared in this short blog post by Graydon Hoare, looking at the lesser known Xerox Alto descendant, the PERQ.

📢 Causal Islands Berlin via Orion Reed

The Causal Islands Berlin conference (organised by me, Boris Mann, and Jack Rusher) is happening next month (Oct 4 & 5). Would love to see some of you there. It'll be quite small (100-ish capacity) but loaded with great talks and conversations. We'll also be doing a more full-size conference in May next year. The vibes are "future of computing" and "spiritual successor to Strange Loop" with a more socio-political bent.

Also, there is a CfP up if you want to submit a presentation!

🧑‍💻 To Write Code: The Cultural Fabrication of Programming Notation and Practice via Joel Chan

greetings! am thoroughly enjoying the latest podcast episode on agentsheets, and the discussion of “is programming a Language(TM)” and the history of how it came to be that programming was considered language in the sense of “has a formal grammar” reminded me of this paper by Ian Arawjo on the history of programming notation and its cultural referents (e.g., typewriters, and how it moved away from more “visual” forms and converged around “programming as typing on a typewriter”: To Write Code: The Cultural Fabrication of Programming Notation and Practice

i found the resulting frame of programming as translation work of “mapping one culture to another” provocative too!

CleanShot 2024-09-07 at 14.41.31@2x.png

CleanShot 2024-09-07 at 14.43.59@2x.png

🤖

💬 Nilesh Trivedi

TIL:

🎥 Roboco-op explainer via Tom Larkworthy

Youtube Thumbnail

I thought I had shared roboco-op here but it seems I had not. The idea is to mix code/runtime/chat context into a single materialised human editable representation to enable "mimetic engineering". Copy and pasting "skills" between notebooks and therefore engineering the AIs context to suit the task at hand, all while having a machine checked code based conversation (I demoed this at Berlin's GenAI meetup) withou context switches.

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/09 Week 1

2024-09-02 10:19

🎙️ FoC 73 • Moving Beyond Syntax 📢 Onward! and LIVE Papers Announced 🧦 Hypercard in the World

Two Minute Week

💬 Karl Svartholm

🎙️ Future of Coding 73 • Moving Beyond Syntax: Lessons from 20 Years of Blocks Programming in AgentSheets by Alexander Repenning via Ivan Reese

Trying to make Duplo more interesting... So far it is working (probably), seem to have encouraged my daughter to learn to stack two pieces together! 😃

Actually the next step after a fanfare is probably (not the stars but) to have pieces make different sounds and/or beats depending on sensors (ex sensing colors, stacking, proximity or sound) — a music machine. Perhaps more important: a programmer base plate; where you stack pieces & program them (from ex Arduino studio, for now). Inter-piece communication could also be interesting? Ideas?

🎥 Video 1

🎥 Video 2

Our Work

Finally, a title with appropriate length given the duration and depth of its episode. May it swiftly be surpassed.

Alexander Repenning created AgentSheets, an environment to help kids develop computational thinking skills. It wrapped an unusual computational model with an even more unusual user interface. The result was divisive. It inspired so many other projects, whilst being rejected at every turn and failing to catch on the way Scratch later did. So in 2017, Repenning published this obit of a paper, Moving Beyond Syntax: Lessons from 20 Years of Blocks Programming in AgentSheets, which covers his findings over the years as AgentSheets evolved and transformed, and gives perspective on block-based programming, programming-by-example, agents / rule / rewrite systems, automata, and more.

This is probably the most “normal” episode we’ve done in a while — we stay close to the text and un-clam many a thought-tickling pearl. I’m saying that sincerely now to throw you off our scent the next time we get totally lost in the weeds. I hear a clock ticking.

🤔 Bloquecitos: the ultimate visual programming language via Mariano Guerra

Inspired by the podcast episode above I created bloquecitos: the ultimate visual programming language

Try it here: marianoguerra.github.io/experiments/bloquecitos

🎥 Bloquecitos Demo

Devlog Together

Leveling up goals: a shower thought

Life: "cells maintain the environment in which RNA molecules originated." (tim-taylor.com/assets/docs/barricelli-suggestions-for-starting-theoretic-papers-6-6-1987.pdf; page 2)
Bureaucracy: you create a system that can outlive you. The system outlives its own usefulness.
Permaculture: design systems to try to make themselves less and less necessary to the functioning of the ecosystem. (merveilles.town/@neauoire/113040776489493243)

Reading Together

📝 BDI Agents: From Theory to Practice via Nilesh Trivedi

LLMs are forcing me to think about non-deterministic yet rational "computation".

Agents are beyond what traditionally computation has been. When an agent starts performing a task, and the environment changes, they need to find the balance between too much rethinking (classical decision theory) and not enough rethinking (computation).

Thinking Together

💬 Guyren Howe

I just had a thought.

Is anyone aware of any work on a non-programmer-friendly UI for editing pattern matching? Semantically, I’m looking for Datalog. So I guess a Datalog query UI, although I could imagine a pattern matching UI being developed outside of a use with Datalog.

I’m trying to figure out why you (Ivan Reese) think that using OhmJS to produce the wiki would create a dependency, while I (Paul Tarvydas) don’t think so. Here’s a diagram of how I understand the situation...

💬 Nilesh Trivedi

📝 0048: zest progress, zest ordering, wasm alignment, umbra papers, future of fast code, new internet, books, other stuff via Jamie Brandon

I've been thinking about how neurosymbolic AI might be achieved. The first problem is that of memory/knowledge. Triple stores are often recommended. But I am failing to see how triples are THE definitive choice for knowledge representation.

The classic example would be: How to store the fact "Bob's age is 23yrs". This maps to the Entity-Attribute-Value or Subject-Predicate-Object pattern and the triple (Bob, age, 23yrs) works.

But on one hand, even a 2-store can be used:

(Bob, Bob's age)

(Bob's age, 23yrs)

This has more layers of indirections, yes. But the primitives become simpler.

On the other hand, if the fact was "Bob bought this camera in Singapore for 100$", the same layers of indirections show up in triple stores as well.

Arbitrary knowledge seems multidimensional (time, place, context etc etc). Is there a reason to believe that triple stores achieve the best tradeoff between simplicity and expressivity?

Does anyone have thoughts about equality vs ordering in maps/sets?

I have some pondering here - scattered-thoughts.net/log/0048/#zest-ordering but the decision tree at the end is the main thing:

Order isn't observable at all.
Iteration order is either non-deterministic or expensive.
Determism can be manually recovered by storing both a map and a list of keys, but at the cost of storing two copies of each key.
Order is observable.
Order doesn't affect equality.
Equality is not extensional ie a == b does not imply that f(a) == f(b) .
If [a: 0, b: 1] == [b: 1, a: 0] then we must have struct[a: i64, b: i64] == struct[b: i64, a: i64] , but we still have to remember that the field order is different, which implies that type equality can't rely on interning and pointer comparison.
Order affects equality.
Sets become surprising / less useful.
If I want to add query planning, I can't promise that f(db) == optimize-query(f)(db) .

Content

💡 SPLASH 2024 - Onward! Essays - SPLASH 2024 via Konrad Hinsen

🎥 Capt. Grace Hopper on Future Possibilities: Data, Hardware, Software, and People (Part One, 1982) via Paul Tarvydas

The accepted contributions to Onward! Essays and Onward! papers have been announced. Many of the titles/abstracts sound very relevant for our community. And three essays have authors from FoC.

my thoughts on the above issues

Youtube Thumbnail

Capt. Grace Hopper on Future Possibilities: Data, Hardware, Software, and People, 1982

Part One * youtube.com/watch?v=si9iqF5uTFk&t=1s
20:58 - We’ve Always Done It This Way *
47:10 - Systems Of Computers, Not Bigger Computers *
48:00 - Get Out Of The Plane Of Paper *
Part Two * youtube.com/watch?v=AW7ZHpKuqZg
0:00 - Security *
8:42 - Bloatware *
9:57 - 2FA *
12:12 - Specialized Machines Are Faster Than General Purpose Machines *
12:59 -We Have To Overcome The Concept Of Only One Computer *
14:58 - Dependency Analysis *
18:53 - Use independent modules *
22:15 - Advocate the use of standard high level languages *
27:19 - Buying Computer Time *
34:49 - Management vs. Leadership *

🧦🎥 Hypercard in the World, May 2016 via Lu Wilson

Youtube Thumbnail

Just in case you missed it

🎥 Subtext 1 via Kartik Agaram

Vimeo Thumbnail

I had no idea Jonathan Edwards's landmark Subtext is almost 20 years old.

Subtext 1 (2005) is still hugely compelling. I hadn't watched this until today. If you're like me, you're in for a treat.

This work predates Bret Victor's "Inventing on Principle" by 7 years!

📑 Workshop on Live Programming (LIVE) via Maikel van de Lisdonk

The accepted list of papers for liveprog can be seen here liveprog.org and I notice that FoC is very well represented by quite some folks from this community, very nice! 😎

🤖

💬 Nilesh Trivedi

The holy grail of AI. Any thoughts on how this kind of integration can be achieved?

Present Company

🔠 Departure Mono via Christopher Shank

DEPARTURE MONO IS A MONOSPACED PIXEL FONT WITH A LO-FI TECHNICAL VIBE

🎥 Virtual Meetup 4 • August 28, 2024 via Ivan Reese

Youtube Thumbnail

Here's the recording of the Future of Coding Virtual Meetup 4. We saw a textual projectional editor from @Jarno Montonen, an Observable-based exploration of visualizations from Tom Larkworthy, and I shared an update on the FoC Wiki.

Next month, rather than demos, we're going to host a little event where we all get together on a call and write wiki articles. Should be fun, likely chaotic. See you there!

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 4

2024-08-25 23:01

🧮 Scrapsheets demo 🎥 Why Star Trek's Graphic Design Makes Sense 🔌 Visual Neural Networks

Two Minute Week

🔌🎥 Neural network training using mnist dataset in code-flow-canvas via Maikel van de Lisdonk

Youtube Thumbnail

After lots of reading (books and other people's code), watching video's, thinking, asking chatgpt for help (it needed help itself), experimenting and frustration, I finally managed to get a neural network working including the training using backward propagation, in my visual programming system!! You can see a small video where I demo it here

The results are far from perfect and neither is the visual flow itself. Currently I only used a subset of mnist to train (9000 images) and on every training iteration the weights are updated per training image. Also the network can for sure be improvement by using a different layer setup and configuration parameters (different learning rate and activation / cost functions). From a visual programming perspective there are also lots of things to improve: currently a lot of the needed functionality is inside the nodes instead of being visible in the flow. So the neural and training nodes are black boxes as well as the node that loads the mnist dataset and handles some of the logic in the training proces. I want to change this in the near future though. You currently can't even see the resulting weights and biases.

Hopefully it is clear from the neural node types how the neural network is structured: it shows the number of nodes in the layer and an icon illustrating whether a node represents an input, hidden or output layer.

In the video I show a slow and fast run of the training proces: by putting the speed slider to the right you can run the flow without animations otherwise it takes too long.

There's also a custom node type that can be used to draw a digit manually and provide the digit which the drawing represents for purpose of calculating the error cost/loss.

Anyway, for now I am happy with the result. More to follow in the future :-)

💬 Marek Rogalski

They may be totally invisible in the video but objects in Automat now drop shadows! They're drawn using fairly sophisticated procedures that were developed a copule of years ago for Google's Material Design system. Each object actually drops two different shadows - one coming from environmental light (a.k.a. ambient occlusion) and one from directional light (which is modelled as a disk with the same width as window and is positioned in 3d space roughly in front of the title bar). The cool thing about those shadows is that they're not using either shadow maps nor gaussian blurs (except concave shapes). The library takes some shape (vector contour of the object dropping shadow) + parameters of the light and computes a physically based analytical shadow mesh that is then drawn in the background. This manages to render fairly realistic shadows even while elevation of objects is being dynamically changed.

🎥 Demo

Our Work

📝 Call Return Spaghetti by Paul Tarvydas

In the essay referenced below, I examine why a diagram of a Call/Return system makes less sense than a diagram of a concurrent system.

Call/Return operates in a LIFO - last-in first-out, stack-like - manner.

Adopting an alternate perspective - FIFO, first-in first-out, queue-like manner - allows us to represent diagrams more easily.

CPU chips implement CALL and RETURN instructions as single opcodes, but, they do not implement queue behaviour as single opcodes.

Most popular languages are generally function-based, e.g. C, Haskell, Python, Javascript, Smalltalk, etc. Such function-based languages tend to adopt a LIFO (callstack) perspective and tend to use CALL and RETURN opcodes to fake out the function-based paradigm.

Such languages allow programmers to implement FIFO queues, but, such languages encourage the use of LIFO stacks. This seemingly small difference subtly affects designs with function-based - stack-based - thinking. This difference ultimately encourages single-threaded design while making multi-threaded design more difficult to imagine and to implement, as witnessed by the fact that most languages relegate multi-threading to hefty code libraries, while treating functions as basic building blocks.

This subtle encouragement towards function-based thinking has led to the general impression that Visual Programming Languages (VPLs), node-and-wire Diagrammatic Programming Languages (DPLs), Actors, etc., are ineffective programming tools.

I argue that VPLs, DPLs, Actors, etc. are effective programming tools, but that their use is are ultimately discouraged by the over-use of the function-based paradigm.

Further

💻 Tensort via Kyle Beechly

I just published Tensort, a family of sorting algorithms (slash research paper?) inspired by Ivan's remark near the end of Beyond Efficiency by Dave Ackley about Robustsort not existing yet. I'd love to hear what y'all think! 💙

📼 Bootstrapping OOP Part 3: Who Parses the Parser? via Mariano Guerra

How do we feed the prelude if there's no parser (yet)?

💡 If code is data then a data serialization format is a binary representation of a program

Devlog Together

Getting ready for Slack apocalypse.

🔌🎥 Improved neural network layer node visualization in code flow canvas. via Maikel van de Lisdonk

Youtube Thumbnail

I've made some visualization improvements for the neural network layer nodes in my visual programming system "code flow canvas". Nodes can now have meta information to show internal data which is stored on the node level that is not shown on the node itself. For the neural network nodes this are the weights and biases.

Also the structure of the neural network itself can be viewed in a scalable way instead of just the nodes on the canvas itself. And with scalable I mean not showing all the nodes, but only a max of 10 per layer and add smaller dots in between to illustrate that there are more nodes then just the max 10 that are shown per layer. The number of dots are different depending on the total node count to make it clear that layers differ in total node count.

You can see it here or try it yourself at demo.codeflowcanvas.io and select the neural network mnist training & testing example.

Thinking Together

💬 Yuriy Zymlex

I have a few questions/topics about which I would like to get your opinion. Since I'm interested in the underlying logic of this things, this may look banal.

If the essence of every programming language is the construction of logic , have there ever been any attempts to bring that process __ into minimal separate entity for purpose of wider use than just programming?

By purposes, I mean the creation of:

Text instructions - as you can see them in Jira, Org-Mode, Markdown (or detailed program's log)
Graphical - MindMap or here it is good to remember "data flow diagrams" from informatics, but it can be expanded to any other kind
Actually programming itself, but as building any "pseudo" code (including graphical) for convenient use with a theoretical possibility of converting "pseudo" code back to logic
... (other variants)

Content

🧮🎥 scrapsheets splash demo via Kartik Agaram

Youtube Thumbnail

Demo of a spreadsheet-like tool. To be presented at SPLASH? By @Taylor Troesh.

🎥 Why Star Trek's Graphic Design Makes Sense via Stefan Lesser

Youtube Thumbnail

YouTube served this older video to me, but I couldn’t help noticing a few things in relation to (the future of) coding:

All the models and (fake screens) etc. are now considered art, but they weren’t created as art. They were functional props on a movie/TV show set put together under tight timelines. How often do we put together functional code under tight deadlines? And how often is what we do regarded as art later? Almost never, I reckon.
His expertise: When he talks about smoked acrylic and how almost everybody doesn’t listen to him because “You’re losing light", even though he clearly knows exactly what he’s talking about, that reminds me of about a million conversations about how some clearly less experienced engineer tells an experienced veteran why their code isn’t good.
Oh, the pragmatism! The ship models? Hacked together from repurposing strange parts they had lying around. The details? Just enough to make it look great. The blinking buttons interface? Just a few lightbulbs behind the buttons that were supposed to blink. If that doesn’t remind you of software development, you’re not doing it right. Or you are, and that’s part of the problem. 😉
I know, there’s some physicality to all the examples in the video, but the LCARS interface points to the possibility of designing something in software only that can transcend its functional framing and become more than just a prop. We have a few examples of that in software (“You had me at scrolling”), but not nearly as much as we should have, I think.

Where are the videos like this that celebrate achievements in software design?

📝 The Competing Predictions of Edsger Dijkstra and Douglas Engelbart via Kartik Agaram

He who would do good to another must do it in minute particulars General Good is the plea of the scoundrel, hypocrite and flatterer For Art and Science cannot exist but in minutely organised particulars -- William Blake

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 3

2024-08-18 23:38

🎥 A structured, type safe and web native shell 🐸 Arroost: Unblocking creation with friends 🔌 Nodes & wires experiments

Two Minute Week

🎥 Draw a Triangle to a Window via Dany

Youtube Thumbnail

Hello Triangle!

Our Work

🎥 A structured, type safe and web native shell. via Peter Saxton

Vimeo Thumbnail

This video is a break from my normal log. This time I assume no previous knowledge and try to show what I thing a structured, type-safe and web-native shell should look like.

🪜 Bootstrap post-collapse OOP technology with Wasm GC (Part 2) via Mariano Guerra

🪜 Bootstrap post-collapse OOP technology with Wasm GC (Part 2)

A raw WebAssembly (Text Format) implementation that bootstraps a compact object-oriented language in itself

~1500 lines of WAST, 5.8KB compiled to Wasm

🐸 Arroost: Unblocking creation with friends via Lu Wilson

My submission to LIVE just got accepted. Here it is!

Please read and share and let me know what you think

Devlog Together

💬 Ivan Reese

Not an exhaustive test, but the gemtext superset / markdown subset is coming along. The parser is really simple. I need to style blockquotes and code blocks (like… at all), and improve the styling on other elements. Also need to document this subset. But hey, getting closer.

Screenshot 2024-08-17 at 9.05.00 PM.png

Screenshot 2024-08-17 at 9.07.45 PM.png

🗺️ the FoC starmap via Kartik Agaram

Quick aside on "the making of" 💬 #thinking-together@2024-08-18. I've been reading Christopher Alexander's "The Nature of Order". I'm 250 pages (so 1/8th of the way) in, but I tried to make each node (problem statement) a "center" as CA defines it.

Initially I wanted distances to be meaningful but I couldn't see a way to make it work, so they're mostly meaningless (except for a couple of nodes with very few edges). Instead I ended up focusing on angles. I tried to make every edge unambiguously go to a specific node, and this had the effect of improving use of all 360 degrees around every node.

I started out putting myself in the center, but eventually realized it was better to start with people who had the most 1s and 2s (for the most part the only edges shown in these graphs).

🧵 read more...

Thinking Together

🔌 Writing software without a programming language via Paul Tarvydas

Youtube Thumbnail

I’ve been pointed at the Kronark YouTube channel which is only a few days old and purports to show how to build software using nodes.

Several things jump out at me: (1) nodes do NOT need to return a value (unlike functions, which must always return something ; does the need to return something lead to bloat???) (2) undefined behaviour is allowed (does over-defining of ALL behaviour lead to bloat???) (3) encapsulation and abstraction - 0D defines Container components which encapsulate and elide layers, 0D does this encapsulation at runtime ; Kronark compiles out encapsulation at compile time (AOT). I feel uneasy about this, when taken to the extreme. Maybe 0D should be described as“structured concurrency” (???) Whereas Kronark is just more-of-the-same linear composition (???) that works in a feed-forward, single-threaded manner. It will be interesting to see examples of concurrency and feedback in Kronark. (FTR, “feedback” is not the same as “recursion”).

🗫 Final-ish state of problem statements and reactions by Kartik Agaram

Also, a final-ish personal visualization of the "star map of FoC". All the caveats and disclaimers 💬 #thinking-together@2024-08-04 continue to apply.

I'll post some even more personal comments and critiques of people's responses and the whole process in comments. I hope it provokes comments and reflection from others.

I'm looking forward to putting this up on the FoC wiki in some form.

🗒️ problems.html

Content

🤖 The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery via Mattia Fregola

Curious to see how this Fully Automated Open-Ended Scientific Discovery thing unfolds

🔌🧮 They turned MATH into a factory game... via Jason Morris

Youtube Thumbnail

Saw *Beltmatic" and thought of Hest. 😅

🔌🐦 @KennedyRichard@fosstodon.org (@KennedyRichard) via Mattia Fregola

Spaghetti-code polemics aside – how cute!

🐦 🦣 @KennedyRichard@fosstodon.org (@KennedyRichard) on X: @KenneyNL No guys, hear me out, we might be onto something here! What about tracking eyes that become happy when the connection is reached out? (also in Nodezator's dev branch)

🤖

📝 The Turing Test and our shifting conceptions of intelligence via Mattia Fregola

Good short article by Melanie Mitchell

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 2

2024-08-11 23:43

📔 Userspace notebook editor ⛏️ Bootstrap post-collapse OOP technology 🔌 cables.gl is now open source

Two Minute Week

💬 Marek Rogalski

This week I've implemented serialization format for machines built in Automat. Simple JSON file (pretty-printed) stored next to the executable. Turns out its quite handy during interactive development. And also opens the way for regression testing. Restoring the window state was (surprisingly) the hardest challenge (due to DPI and monitors) and I didn't manage to correctly persist it. Both on Linux and Windows, the window managers just don't want to share some of the window properties... (especially around window tiling)

🎥 Demo

📔 observablehq.com/@tomlarkworthy/userspace-editor via Tom Larkworthy

What would it take to make an open source front end to the Observable Runtime? One where you have control over the runtime and layout and are free from iframe sandbox restrictions?

🎥 open-notebook

Our Work

⛏️ Bootstrap post-collapse OOP technology (Part 1) via Mariano Guerra

How do we preserve the ability to program OOP through civilizational collapse?

Devlog Together

💬 Ivan Reese

Got the visual design of the wiki mostly fleshed out. Fluid layout, one breakpoint that moves elements around for smaller screens, light and dark modes, nice keyboard nav, etc etc. Thoroughly documented too, since I figure some folks might want to peek at the css but aren't up on all the new weird stuff you can do.

Also, I'll be eating my hat now: everyone who scolded me for attempting to parse a markdown-like syntax with Regex, well, yeah, it kinda stinks. Not sure what to do about this, given the values I'd like to impart in this project. Since it's not a blocker on writing pages, I think I'll ship it half-finished and we can talk about it. This feels like a great area to draw on the wisdom of the crowd.

Markdown or not, we'll still need a build script, I reckon, unless we want to ~require~ that anyone adding a new page also add their page to any relevant indexes — since, I reckon, we'll need some indexes just to get through the early phase where the wiki will be sparsely interconnected. To start, I'm thinking one index of broad categories (or maybe tags, dunno), and then another that's just a list of all pages. But if anyone has strong feelings about the right way to do this, I'm at least 75% ears.

Thinking Together

📝 How I program in 2024 via Andreas S

Kartik Agaram is that your blog?

Content

🔌 cables.gl via Ivan Reese

The cables.gl visual programming language for making cool WebGL shaders was just open-sourced.

💬 Beni Cherniavsky-Paskin

Just found Mr. 4th Programming Conversations podcast which mentions multiple FoC topics 🍰. Visual programming, Bush & Englebart...
Developer Voices podcast is maybe less 1:1 match but interviews many developers building new/experimental/visionary languages.

🤖

💬 Mark Dewing

We now have two examples of systems that can turn text descriptions into code - humans and LLMs. And we don't understand how either of them works.

📝 No apps no masters via Kartik Agaram

Present Company

💬 Dany

So I have this c/c++ codebase, around 116,000 lines of code. A full release compilation takes 6:25 minutes. Not too bad to work on.

If I break this down, a single line of c/c++ code takes 0.0033s (3.3 miliseconds). For comparison, a game that runs at 60 fps, draws a new frame in under 16 miliseconds. So while a game simulates and renders a frame, a c/c++ compiler compiles 5 lines of code. That is usually not even a single function.

My cpu avarages at around 10 instructions per clock cycle. At 3.6Ghz it can do 3.6 * 10 * 1,000,000,000 instructions on each core, per second. That's 36,000,000 per milisecond, on 8 cores.. but let's add some cache misses, any instructions can either go full speed 1x or go to main memory around 200x slower.

We are looking at around 5 million instructions per milisecond.

If we print out (9pt font) all instructions executed to compile a single line of c/c++ code, we'd end up with over 6 kilometer long paper.

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/08 Week 1

2024-08-05 10:21

🎥 The future of programming is data-parallel? 💡 A modern and executable specification language 🎥 Spatial Canvases: Towards an Integration Domain for HCI

Two Minute Week

💬 Marek Rogalski

Another major feature implemented - the toolbar . I really love the toolbar system used by Vlojure. I never used it personally but I like the idea of many customizable bars. Eventually I'd like to make this one more flexible as well... The animations behave slightly differently than most docks I know (Cairo, Mac OS) - instead of zooming all nearby elements (in a gaussian-distribution like pattern), only the one under the cursor is enlarged. I think this contrast makes it clearer to which action will be selected by clicking. The radar animation also got some love - it now shows the paths to nearby objects, connection name and animates slightly more smoothly.

🎥 Video

Our Work

📝 Improving LLM Accuracy with Levlo Languages via Jarno Montonen

Did an experiment on improving LLM accuracy with Structured Generation using my stuff: Improving LLM Accuracy with Levlo Languages

🧮 Cashflow Profiles and Reserves: Actuarial Terminology I via Declan

I'm getting ready to release some actuarial models and outputs that use calculang.

So I made an interactive post to introduce some terms actuaries use

💬 John Christensen

Here's my work in progress node-and-wire system. It's specifically targeting signal processing related work.

Here, data is all passed between nodes as 1D arrays, so the plots just have the x-axis hardcoded for now. I'm not sure if a pair of x/y array's should be passed together on a single wire, or if they should be passed separately for the most flexibility.

💬 Nilesh Trivedi

I will try to reproduce these two papers that suggest program synthesis (eg: inducing new tactics) for AI to solve math problems or the ARC-AGI puzzles:

There's a quite a bit of new math/ML/programming for me to learn here.

Devlog Together

📝 Diagram Compiler Status via Paul Tarvydas

I’m in the process of writing a transpiler that spits out Drawware 0D kernel code in various languages (like Python, Lisp, JS, WASM, etc.) from a higher-than-HLL. I’m using a very simple “circuit” to regression test (Larson Scanner, as seen on T.V. Knight Rider). Current status and “working paper”: 2024-07-30-Diagram Compiler Status

💬 Ivan Reese

My basement flooded this week. So that's going to set me back a bit. But, hey, here's a quick update on the two FoC-relevant things I'm floating.

DANK WIKI • At the last FoC virtual meetup, we talked about setting up a super lo-fi, friendly-to-nontechnical-folks, hackable community wiki. I've got a repo all set up for that locally, and just have a tiny bit more experimentation to do before it's ready to share. All the pages are just simple HTML or MD. There is a build step — wait, stop, don't run away — it's a build step, but it's cool and different!! There's a really simple spec and a short reference implementation. Zero dependencies, less than 100 loc. Everyone is encouraged to port the script into their language of choice and commit that. That way, other people can check out the repo, add some pages, and build it locally without having to conform to whatever ecosystem the build script requires. I'd ideally like to have impls in each of the most common ecosystems right away (JS, Python, Ruby, maybe bash, etc). Finally, the wiki is (for now) going to be hosted on Github, with an action that runs the reference build script on commit, so if people want to edit it via the Github web interface they can. (I'll be liberal with handing out the commit bit). This is going to be a social experiment as much as a technical one. Excited to see how it goes. Hoping to have the initial version of this go live this weekend.
LIFE RAFT • I'm itching to get cracking on a Slack successor. I'm thinking I'll spin up a dedicated channel, and solicit people to drop in whatever random wishes / ideas / requests / suggestions / advice they feel like offering, so that these can filter in to the design process. I'm also hoping to put together goals for an MVP. This will need to include several things, including but not limited to: visual mockups for the GUI on desktop and mobile, technical architecture, priority features, estimated timeline. I intend to be quite restrained here — I want to make the smallest possible good enough thing.

🎥 work in progress: building a neural network using code-flow-canvas via Maikel van de Lisdonk

Youtube Thumbnail

Hi, Because I want to understand better how neural networks work and can be trained, the best way to do is, is by building a small one from scratch myself and training it.

In this video I show creating and connecting a few neural-nodes together and a show a very small prebuilt neural network.

To be able to do this, I've created 4 new node-types in my visual programming system: neural-input-node, neural-bias-node, neural-node and neural-output-node.. the first 3 output weighted connections. This means that a weight property is attached to the connection and can be changed.. the neural-node and neural-output-node use these weights in there respective calculations.

The neural-node currently uses sigmoid as its activation function.

The neural-bias-node only outputs a value of 1 and the output value of a neural-input-node can be changed. When any of these values are changed, they propagate forward through the network.

In the current example flow, an error is also calculated using an expression node-type depending on the output and expected value.

The white object-node is also a new node-type and can be used to obtain multiple values and output them in a single object.

In the near future I hope to implement a neural network that can be trained with the mnist digit dataset, but I have to do a lot more work before I am at that stage I think.

Reading Together

🎥 [PLDI24] The Future of Fast Code: Giving Hardware What It Wants via Jamie Brandon

Youtube Thumbnail

The future of programming is data-parallel?

Thinking Together

🎥 Spatial Canvases: Towards an Integration Domain for HCI, with Orion Reed via Paul Tarvydas

Youtube Thumbnail

Konrad Hinsen, I just watched Orion Reed’s talk youtube.com/watch?v=csGNVaB83Rk, pointed out by Christopher Shank. The talk continuously fired the same neurons in my head as does the phrase “malleable computing”. I’m not in that head-space, but, I continue to wonder if there’s a connection … (YMMV)

Prompt for everyone here: to the extent that you think about the Future of Coding or have projects to try to improve things, what problem are you trying to attack? Can you state it in a couple of sentences? Without reference to a solution? Try to be precise about the audience. For example, some problems affect everyone, while others affect only professional programmers, or only researchers who use computers in their work.

My hypothesis is that focusing on problems will help us all find our most promising collaborators in this group. (The next step will be to combat our tendency to be defined by our tools, to let our tools erect barriers that divide and balkanize us. But that's further down the road. For now, let's just "find our homies," the people we share specific dissatisfactions with.)

There are ideas for problem statements in a couple of earlier threads:

But this thread is not for critiquing or analyzing any of those statements. Just add your own, and nothing else.

(It's totally fine to copy statements from these threads. Many of them were arrived at after tons of consideration so it would be surprising if others didn't care about them. Also feel free to synthesize from multiple statements. Just try to get to something crisp and opinionated.)

Falsifiable theory…

Theory: Function-based thinking greatly restricts thinking about FoC.

Test: if this theory is true, then examination of the source code for The Mother Of All Demos will reveal that not all parts of the demo system were tightly inter-connected into a single synchronous, functional blob of design.

How?: Where can we find the source code for TMOAD? If we obtain the source, how can we reverse-engineer the design out from the implementation details? If we can get at the design, we should look for how the sub-units of software are interconnected. We need to examine if the code is designed as many islands of synchrony vs. being designed as just one big blob of synchrony.

Corollary: if TMOAD was designed as many islands of software and hardware, then it is unlikely that anything as interesting as TMOAD can come of building software on computers using only synchronous languages, like Python, Haskell, using concepts such as thread libraries, theorem-provers, etc. [Thread libraries are but assembler-level work-arounds that enable the use of the function-based programming paradigm with languages like Python, Haskell, etc. Theorem provers need single islands of synchronous code, to work]

📝 yesterday's prompt on problem statements via Kartik Agaram

Follow-up to 💬 #thinking-together@2024-08-01: post a single comment with a number from 1 to 6 for every comment but yours in yesterday's thread, indicating how close you perceive everyone else's problem statement to be relative to yours. (And don't read other people's comments before you post yours; that's part of the fun here.)

Here's what the numeric scale means:

1: This is a rewording of my problem statement.
2: This overlaps almost entirely with my problem statement.
3: I care about this problem.
4: This doesn't seem like a big problem.
5: This is fine, I don't think it is a problem.
6: This statement is alien to me, I don't understand it as a problem statement.

Hopefully that makes sense and I haven't missed some major option..

In a day or two I'll collate the results in the attached table. (You're welcome to do so as well; just download the html file and open it in a browser tab, fill in and hit the 'save' button to save a local copy with your edits. Upload it here if you like, that can be an alternative way to give your votes.)

🗒️ problems.html

💬 Jari

Hello, I am currently building a lowcode platform for easy and fast backend development. Basically, you write logic using functions which look like excel functions or UDFs. Do you have any opinions on programming using Excel? I have written prototypes many times using it, but main problems have been 1) not being able to use it as a backend 2) more complex sheets are hard to understand and test

📝 the problem statement thread via Kartik Agaram

Here's the current state of people's reactions to each other's problem statements. If you haven't added your reactions yet, please consider doing so! If you haven't written a problem statement yet, please do so before reacting to those of others. I know it's a non-trivial bit of work. I tend to open Slack on two windows somehow to jump between 💬 #thinking-together@2024-08-01 and the problem reaction thread 🤦 But it does seem like something promising to think about.

I've also included a very rough, very preliminary, very incomplete stab at visualizing clusters of people's problem statements. There's no reason to think this "space" is Euclidean or 2D, so take it with a huge bucket of salt.

The visualization is in no way mapping status relationships. The intent is not to exclude anyone, but a very narrow instrumental purpose of finding opportunities to collaborate. If you need an analogy, a better one might be a star chart. It seems safe to assume we're all light years apart given our track record of collaborating 😄 This picture is an initial attempt at making a map based on imprecise measurements from a single point. If you spend any time thinking about the map, try to build your own from the raw data to avoid my inevitable biases.

I started out with Kartik at the origin (no objectivity here!) and positioned first my 1s, then my 2s, then 3s and so on all the way to 6s. Then I tried to go through others similarly and resolve tensions in a very rough, very manual way. I might do this a few times to try to get better at it.

Even though this "data set" is almost certainly high-dimensional, a few 1-D relationships popped out at me:

Kartik -> Tom + Tom -> Paul = Kartik -> Paul
Kartik -> Tom + Tom -> Nilesh = Kartik -> Nilesh

I responded by putting the 4 of us on a straight line. There may be a spectrum here that bridges the incomprehension between the ends.

This sort of bridging of incomprehension is a common pattern. I initially had Ivan as far away from Kartik as Paul . But several connections drew the Ivan / Eli cluster closer. Dany too might be as far from me as Paul , but is just 1 away from Jimmy . Guyren too, but is close to Tom and Dany . So some of these edges have more "tension" than others, and I haven't come up with a way yet to show that.

(I'm currently showing edges labeled 1-3. If we get more data I might need to prune that further. The edges are directional but unfortunately my tool doesn't have arrows.)

Anyways. Add your problem statements and reactions!

🗒️ problems.html

🗒️ problem-clusters

Content

📝 Calculating Empires: A Genealogy of Technology and Power since 1500 via Ivan Reese

Calculating Empires: A Genealogy of Technology and Power since 1500

Via Jack Rusher on Mastodon…

It's an enormous map of illustrations of various advancements toward, within, and around computers. Note that it's wildly horizontal. I tried exploring it a bit on my phone but found that unsatisfying. I recommend using the largest monitor you've got.

💡 Quint: A modern and executable specification language via Jason Morris

Just saw Hillel Wayne link to Quint on LinkedIn, and I finally want to try writing TLA+ as a result...

🎥 Midinous - Non-linear MIDI Sequencer - Official Trailer via Mariano Guerra

Midinous - Non-linear MIDI Sequencer

Youtube Thumbnail

🐇 Hundred Rabbits is a small collective exploring the failability of modern tech via Andreas S

news.ycombinator.com/item?id=41131181

Hello 👋 Future of coding,

I hope you are doing well :)

So I found one of those interesting HN posts:

I hadn’t heard of 100 rabbits before :

100r.co/site/about_us.html

The comments in the HN are also very interesting. For me they feel very ~much~ related to the future of coding.

Like this one:

news.ycombinator.com/item?id=41136056

In this respect, their page for hacking baguettes by sun&sea is my personal favourite

100r.co/site/solar_cooking_experiment.html

100Rabbits is like the coming true of Grothendieck's 1972 permatech lecture given at CERN*

github.com/Lapin0t/grothendieck-cern

"I think that agriculture, stockbreeding, decentralized energy production, medicine of a certain kind, very different from the medicine that prevails today, will come to the fore. It's impossible to say which part purely creative joy will play in these new developments. My hope is, it will be a creative development in which there will be no essential difference between conceptual activities and manual physical activities. When people become masters of their own needs to the point where an appreciable part of their creativity remains free---and this will take a time we can't predict, it may be a generation, it may be ten, no one knows---at that point, anyone, not just a certain scientific elite, will be able to devote a significant part of their time to purely creative, purely speculative, purely playful research"

📝 this slimy interview via Arvind Thyagarajan

apropos of verbalising favourite problem statements, I found a wonderful one in this slimy interview

How can we align our interests with what living organisms and systems naturally do? How can we yoke ourselves to what they’re doing so that our relationship is no longer exploitative, but rather one where we’re putting existing capabilities to productive ends?

🤖

📝 Argentina to use AI to stop crime before it happens - UPI.com via Paul Tarvydas

Argentina to use AI to stop crime before it happens

Argentina has announced plans to use artificial intelligence to predict crimes before they're committed, the country recently announced.

Present Company

📡 webrtcforthecurious.com via Guyren Howe

Currently trying to use WebRTC from Flutter. I just want a way to find my external IP address and port, and to share data through it. Seems like a simple requirement.

I am utterly astounded at the complexity of WebRTC. I’ve just never see anything quite like it. The Flutter plugin just flat doesn’t work for me, and there is no debugging information available to let me know why. The plugin uses an opaque C library, and I’m no C hacker.

I’m down to using a headless browser, which I’m pretty sure I will get working. But holy moley. This: webrtcforthecurious.com is about the friendliest introduction I can find.

Tragic, because ad hoc peer-to-peer connections should be a large part of the Future of Computing.

File under: hopefully not the future of computing.

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/07 Week 5

2024-07-28 22:37

🎥 Structured editor in a shell 📢 Snap 10 Released 🎥 Toward a Live, Rich, Composable, and Collaborative Planetary Compute Engine

Two Minute Week

💬 Marek Rogalski

It's now possible to delete objects. Ten months into Automat development may be late but it's better than never. Now I'm working on auto-connections when objects are nearby.

🎥 Demo

💬 Tom Larkworthy

I am trying to get my lazer cut box joint generator thing less like a notebook and more like an app. So I have pushed all my observable UI cells into a single cell with a custom layout overlaying a three.js visualisation.

I wrote a new UI tool that allows the UI to be decomposed at runtime, so I can move the (live) ui visualisations to their appropriate place when needed.

🎥 decomposable ui

Our Work

📝 Why Do We Need Operating Systems? via Paul Tarvydas

Operating systems are generally thought, by software developers, to be necessary. What do operating systems accomplish? Engine for running code written in the function-based paradigm. Library of pre-fabricated subroutines that could be used in any app.

🎥 Structured editor in a shell via Peter Saxton

Vimeo Thumbnail

I have put my structural editor in a "cloud native" shell. I think quickly writing scripts has more value than quickly writing applications, because applications are normally meant to be around longer.

🕹️ DendryScope: a static analysis tool for interactive fiction, quests, and dialogue in videogames via Jasmine Otto

I wrote DendryScope, a static analysis tool for interactive fiction, quests, and dialogue in videogames. Given a story written in Dendry, the skein will generate all of the playtraces which match queries such as 'reached the good ending, did not find the thief's treasure, and offended the barkeep'. jazztap.github.io/DendryScope

More detail is available in our conference paper, which describes the technical system and documents further use cases. If you're wondering why the tool currently works on one Dendry game and not all of them, please let me know so I have an excuse to finish the transpiler. ojs.aaai.org/index.php/AIIDE/article/view/27527

🐘 a little neovim terminal fiddle via Ezhik

do little things count? because i made a little thing. i'm not a big fan of using repls for messing around because i want to go back and redo things all the damn time. recently i caught myself opening a text editor and doing ~_*watch -n1 some-script*_~ in a separate window.

so i went ahead and made a little (vim)script that does just that - it automatically reruns your code as you type.

it's been pretty convenient for doing little bits of napkin math.

🎥 Screen Recording

💡 The Entire History of… Computing? via Ivan Reese

On this month's FoC bonus episode for Patreon backers, Jimmy Miller, Lu Wilson, and I recount the entire history of computing.

…from memory. 🤦

Devlog Together

🌝 move.lua via Kartik Agaram

For the past month I've been doing something very unnatural for myself: "throwing the first one away." Going back and rewriting an aspect of a working program just to improve one property of the code rather than the behavior: eliminating all derived data structures and re-deriving everything all the time in a performant way.

The result is a simpler API that seems applicable to pixel-based editors that use proportional fonts. Basically the problem is: as you do line-wrapping on a screen, how do you deal with interactive operations like clicking at a pixel coordinate or pressing the down arrow (which might result in a scroll). These primitives seem to make the implementation fairly self-evident: git.sr.ht/~akkartik/lines2.love/tree/main/item/move.lua#L11-28

💻 www.holograph.so via Dennis Hansen

Hello- little update on www.holograph.so - formerly known as the 💬 #share-your-work@2024-05-22- I am working on performance had had the nerdiest proud moment ever and figured of all people, ya'll would appreciate it.

I built a propagation speed profiler in holograph to test how fast propagation was occurring for a little recursively incrementing loop (in the grey box). Im using a buffer to collect and average the values over time and another buffer to collect and display averages as a chart. You can see the propagation speed and compare it with the total Propagations Per Second (PPS in the top left). Before this work i was at a hard cap of 60 pps and now total pps often gets over 300. Still a long road ahead but it feels like a big win right now 🎉

In any case, this example demonstrates major stuff added since my first post here:

Get and set shape properties
Trigger click events
Dashed arrows that don't fire propagators
Async functions/fetch/await syntax
Lots of cool examples to explore- including some made my folk here :)

Hope ya'll enjoyed the update! If ya'll find anything wonky or have ideas let me know !

Thinking Together

📝 theory of bunches via Nilesh Trivedi

Youtube Thumbnail

Prof Eric Hehner's theory of bunches (think of the comma in x,y,z as a binary operator on bunches) seems very foundational and delightfully elegant. Once you see it, you can't see but think that the way we have handled collections of various kinds (sets, strings, tuples) is ad-hoc and not systematic.

What if we had notation that supported all these structures? 🤔

💬 Dominik Jančík

Thought the format may better fit here

[July 20th, 2024 10:22 PM] hi565: Thank you so much for your feedback <@U0296ACR13M>. It's really interesting to think about the strengths and weaknesses of these different paradigms.

I would say that with any sufficiently complex application, it comes down to what tooling is available and whether the codebase has consistent standards. I spend much of my day job in more standard code, in complex distributed codebases.

It's invaluable to be able to use an IDE, navigate through definitions, search across the full codebase, seamless debugging and lately even having the ability to analyze and explain larger parts of the codebase with AI in tools such as Cursor. This all can help understand new code. Using common or at least consistent patterns, good naming and all that stuff will make it easier. It can still involve learning new paradigms, libraries and so on.

I would say that a lot of the same applies to working in node based environments. With the added complexity of usually having to lay out things yourself, which can absolutely make or break readability - whereas formatters are absolutely standard for text code nowadays. Also, given the lack of standardization in node based tools (yes, it's often nodes, but with so many flavors), each language requires its own IDE, putting a lot of strain on developers to match the mature tooling for text code.

Still, I find that some types of flows, especially data piping, and some types of use-cases, such as realtime multimedia applications, generally work better for me in visual environments. vvvv gamma (https://visualprogramming.net/), which all of Schema is created with, seems to be the closest to a full featured IDE I've come across in visual programming. I've also found that Reactive programming is incredibly intuitive in this environment, compared to C# for instance. Though it still has some way to go, such as improved tooling for git or multiwindow.

During development I've certainly had moments where the realtime code update and amazing protocol abstractions made it a joy, while there were others where the tooling and constant tidying needed made me wish for more standard lands.

Going back to the original point with complexity, In Schema, while theoretically possible, I do not encourage there to be a huge amount of complexity at the same time. First of all, there is a big focus on fairly high level nodes aimed mainly at animation and a good amount of things happening implicitly, such as referencing extents of objects in space. Of course, all this interconnected machinery is its own complexity, even when there may be less "code" to see at a time.

Secondly, there are a number of ways of switching up parts of the stacks using assigning via Director, layers, groupings, referencing other objects and modifying slightly. With the general idea that you can get a lot of variety by combining and switching around small-ish stacks of blocks.

Additionally, when you look at a Block based code, which may seem visual, it's actually no more than nested functions, not far from Lisp or any code AST in general.

Blockly, for instance, is often used to build out regular text code. Though I agree drag and dropping everything is a pretty obnoxious way if you know your way around code.

As a matter of fact, all of Schema Block stacks can actually be represented as a very succinct YAML (https://docs.scenic.tools/future-concepts/scenicscript), which allows for a human readable transfer format, text editing (helpful on terminal devices also), LLM completions and more.

What the UI in Schema helps with is interfacing with the parameters and providing immediate in-place feedback of the individual data processing steps (similar to TouchDesigner which does this very well). It also providing domain specific overlays such as MIDI mapping or DMX channel output visualization.

Overall I am trying to strike a balance between the two worlds while finding new ways to interact with code.

This new Cursor work aims to make the block programming feel as efficient, if not more than, writing textual code, while also making it more accessible and fun with the goal of enabling full game controller support.

I really appreciate that you find some of these approaches novel :heart:

Content

📢 Snap 10.0.0 Released via Mariano Guerra

Snap 10.0.0 Released, some highlights:

Blocks all the way
Metaprogramming
New "Code to Blocks to Code" library, translates text code to blocks and vice-versa
New live coding "performer mode" setting
Matrix-kernel convolutions
New LISP-like text syntax for blocks and scripts

Play with it here: snap.berkeley.edu/snap/snap.html

🧑‍💻 Ilograph Interactive Architecture Diagrams via Ionuț G. Stan

🎥 [PROPL'24] Toward a Live, Rich, Composable, and Collaborative Planetary Compute Engine via Mariano Guerra

Zoomable architecture diagrams: ilograph.com

Create interactive system architecture diagrams to document, share, and explain your systems with amazing clarity and detail

Toward a Live, Rich, Composable, and Collaborative Planetary Compute Engine

Youtube Thumbnail

Addressing the climate crisis poses many computing challenges for a variety of stakeholders, many of whom are not CS experts but rather scientists, policymakers, journalists, and members of the public. In order to solve these challenges there needs to be a large-scale collaborative compute engine that is live, rich, composable, and collaborative. Specifically, we present Planet Hazel, a vision of the Hazel programming environment geared toward planetary computing.

Present Company

🎥 Virtual Meetup 3 • July 24, 2024 via Ivan Reese

Youtube Thumbnail

Recording of today's Future of Coding virtual meetup #3

This one featured a demo of LabView + AI from @Jim Kring, a smalltalk-esq browser for Lisp from Konrad Hinsen, plus a nice discussion about collaboration within the community led by Kartik Agaram.

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/07 Week 4

2024-07-21 23:40

💡 Where Should Visual Programming Go? 📝 We Can Do Better Than SQL 🎥 Home-cooked Software and Barefoot Programmers

Two Minute Week

🎥 Structured editor in a code notebook via Peter Saxton

Vimeo Thumbnail

Presenting a structured editor in a code notebook. I think I'm going to enjoy this environment

💬 Tom Larkworthy

I spent 2.5 months building a spatial compiler for lazer cutter plans to build a (massive) shelf. The shelf is built! But all the parts were mirrored, which was not an actual problem, but it was unexpected (a polarity problem somewhere).

For a few other test projects, when the edges are nearly the same length on the parts, the assembly is ambiguous, and it kinda assembles but the shape gets warped from misfitting. So recently I added labels to the edges, so I know which side should match which without ambiguous matching based on eyeballed length. After adding the labels the part visualisation had the numbers backwards, AH HA! my revelation was that this explained why my parts were mirrored.

My whole schtick at the moment is data viz driven development. Dataviz of runtime application state is the extension of text based coding/debugging that delivers value beyond our existing programming paradigms.

🎥 labelled cube

Our Work

🎙️ 91. What scares you about AI? Vol.2 via Ben Byford

not code per say, but AI philosophy

💻 github.com/thegreatercurve/okapi via John Flockton

Hey folks! I thought I’d share a JavaScript parser I’ve been working on: github.com/thegreatercurve/okapi

Very much a work-in-progress, but it's nearly fully compliant with the ECMAScript 2024 spec, 100% passes the Test262 parser test suite, and outputs ESTree.

My next step is to look into refactoring it to output bytecode by default, with the hopes of turning that into an actual JS engine one day.

Devlog Together

💬 Jason Morris

End-to-end demonstration of code generation and chatbot creation in the Blawx prototype I've been working on. The LLM generates a block-based, visual, domain-specific constraint logic program based on the text of the law and the ontology defined by the user, then you encode a question and an interview and you have a chatbot that doesn't have the black box problem of LLMs, but has the same easy interface. Very interested in anyone's comments.

🎥 blawx llm

Thinking Together

📝 Protective Randomness: Why We Fear the AI Unknown and What to Do about It via Jason Morris

After reading a linkedin post by a friend of mine, today, in which he describes "protective randomness" as a virtue of human systems, the absence of which makes certain AI applications frightening, (Protective Randomness: Why We Fear the AI Unknown and What to Do about It) I have come to the conclusion that this may be the best argument I have heard to object to the determinism in Rules as Code: that the systems we have for dealing with the output of the interpretation of statute not only anticipate but depend on variability of interpretation for their effective operation, and that they operate to do more than merely resolve disputes over legal interpretation, so the absence of those disputes is not an unmitigated benefit. Take for instance the conversation that happens between law makers and judges. A law is drafted, there are disputes over how to interpret it, in part fueled by examples of differing interpretations from administrative decision makers. Those differences in interpretation can help people know on what grounds they might object to a particular decision. Those objections go to judges, and judges might differ again, which has the same effect. And the differing interpretations of the judges in the context of things worth arguing about brings to legislators' attention places where the rule itself is both problematic from a fairness and/or interpretation standpoint, and where that problem causes significant issues in the real world, equipping them with information about where to focus when considering amendments. All of those benefits accrue even if no decision is ever made to resolve the dispute. If you replace variable administrative decision makers with a deterministic system based on a best shared interpretation, that review system, which not only accounts for but depends on variable outputs to function, stops working as effectively. That is not to say that what you lose is not worth what you gain. But it is a coherent argument about what is lost, and how, from consistent automated application of laws, and it is prescriptive about where and how rules as code should best be applied to avoid those losses. Which now makes me wonder whether armed with this idea, I would have a more generous read of the Laurence Driver paper.

For context, the linked post is aimed more at attempting to understand some forms of anxiety around AI applications, and particularly in the context of copyright violation, which Colarusso considers complaining about the wrong thing. But the idea metastasized in my head, and now I might have to give Driver the benefit of the doubt.

📝 Coding is State Farming via Guyren Howe

I have a blog about matters related to the topics here. Just dropped this, which discusses why more of typical business logic should be implemented in the database: Coding is State Farming

📝 Thinking About The Game Of Pong In Hardware And Software via Paul Tarvydas

Thinking about Schematics vs. Code. [This began as a short reply to Stefan Lesser regarding my take on electronics schematics in another thread.]

💬 Adam Davidson

Just a random thought that has been rattling around in my head while listening through podcast episodes and Ivan’s visual programing points. I am new here so apologies If all this has been said before, or covered in podcasts I haven’t gotten to yet.

I want to propose a slightly different framing for what it means to say that a representation of a program is visual / spatial or not

Content

🐘 This masto thread via Ivan Reese

This masto thread should resonate with folks here. Teaser:

fediverse is the kind of place where I can ask a question of “let’s say we’re designing an operating system from scratch. Clean slate. Let’s throw away all our old habits and legacy decisions. what’s the minimal set of applications we need to make a new operating system useful”

and the top replies are vt100 emulator, virtual machine to run other operating systems, and c compiler to port vim

like y’all are missing the point of the question!

🤔 We need visual programming. No, not like that. via Kartik Agaram

Let's observe what developers do , not what they say. Developers do spend the time to visualize aspects of their code but rarely the logic itself. They visualize other aspects of their software that are important, implicit, and hard to understand. Here are some visualizations that I encounter often in serious contexts of use: * Various ways to visualize the codebase overall. * Diagrams that show how computers are connected in a network * Diagrams that show how data is laid out in memory * Transition diagrams for state machines. * Swimlane diagrams for request / response protocols. This is the visual programming developers are asking for.

💡 Where Should Visual Programming Go? via Ivan Reese

As a follow-up to the above, there's this nice blog post from @Nikita Prokopov on diagrams as code: Where Should Visual Programming Go?

Level 3: Diagrams are code

This is what the endgame should be IMO. Some things are better represented as text. Some are best understood visually. We should mix and match what works best on a case-by-case basis. Don’t try to visualize simple code. Don’t try to write code where a diagram is better.

Hear, hear!

🐘 Luci for dyeing (@zens@merveilles.town) via Christopher Galtenberg

a huge formative experience happened when I was 16. I was brought into my mother’s office and hired to compell a guy to use his computer who was refusing to use his computer, and exclusively used his IBM selectric. First up, the guy was an unlikable jerk. However, first thing he does when I get there is refuse to even talk to me about the situation until AFTER I read The Invisible Computer by Donald Norman. It’s a good book I cannot summarise in the 50 characters I have left in this post

📝 We Can Do Better Than SQL | EdgeDB Blog via Nilesh Trivedi

The questions we often hear are “Why create a new query language?” and “What’s wrong with SQL?”. This blog post contains answers to both.

Music

🎛️ noodlesynth.com via Ronald C

I'm working on a web based modular synthesizer: noodlesynth.com

End User Programming

🎥 Home-cooked Software and Barefoot Programmers: Maggie Appleton (Local-First Conf) via Beni Cherniavsky-Paskin

Youtube Thumbnail

coins some neat terms, from "barefoot developers" to "the long tail of user needs".

🤖

💬 Mariano Guerra

hi! I'm co-organizing a builders-first AI & UX meetup in Berlin in September, if you are interested send me a DM

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/07 Week 3

2024-07-15 06:46

🚰 Visual Stream Processing System 🖌️ Figma meets VS Code 🛸 esoteric.codes

Two Minute Week

🎥 Stock Multi Time Series, Atom/RSS and HN Stories using Steampipe via Mariano Guerra

Youtube Thumbnail

📈 Stock Multi Time Series

🛜 Atom/RSS

🍊 HN Stories

Data integrations using steampipe.io

💬 Marek Rogalski

I've implemented the flip-flop object which concludes the "object library" that is necessary for basic macro playback. Automat can now play Super Mario Bros with only occasional desync issues 🙂

🎥 video

Our Work

📝 Baby's second wasm compiler via Jamie Brandon

Very present-of-coding, but the future is coming.

🎲 github.com/ivanreese/2222 via Ivan Reese

🎲 I created a new programming game. It's called 2222. (Pronounced "two twenty-two two")

Well, I actually created a meta -game — because you have to program the game yourself , in any programming system you want. Then you get to play it.

The code is incredibly simple. You can do it in 3 blocks of Scratch. It's what TodoMVC would be if it had a soul.

It takes about 22 minutes to play. You will very likely burst out laughing while playing. When you finish the game, you will feel utterly bizarre. You can play the game by yourself, or in a group. Good luck, have fun.

I would love to see your implementation, and/or (but especially and ) a video of you playing.

How do you ~play~ program the game?

Instructions here: github.com/ivanreese/2222

🚰 Visual Stream Processing System via Safta Catalin Mihai

Hello! I've been working on something in my spare time, very early stage... but I think it shows promise.

Given that Lu Wilson encourages us to share scrappy fiddles, here it is.

It's a visual stream processing system - based on tldraw for the UI and Pekko Streams (in Scala) for the backend.

Link to the blog post above, and leaving just a gif here as a tl;dr:

1280x720px image

🖌️ Spectral: Figma meets Visual Studio Code via nith

Hi everyone! Currently working on Spectral, a new way to approach code navigation by using an infinite canvas for traversal. We are aiming to simplify the onboarding, navigation and debugging processes.

🎥 Spectral Demo

📝 A short parable about technology via Stefan Lesser

In the last few days, there have been 💬 #thinking-together@2024-06-15 few 💬 #thinking-together@2024-07-04 here that have inspired me to write this short parable about programming and technology. Let me know how you feel about it. 🙂

🎥 Schema Studio Cursor Dev Update via Dominik Jančík

Youtube Thumbnail

I have been working on adding Keyboard / Gamepad only navigation for Schema Studio, the open-source integrated creative environment for light control, generative visuals and more based on vvvv gamma.

The environment focuses on instant feedback, quick editing, using a fun (subjective :)) game like interface. It uses a Block based programming approach that tries to combine the best of text and visual editing interfaces.

I am calling the feature "Cursor", and here is a short demo.

If you're interested in learning more about the tool, head over to schema.scenic.tools

Any feedback and questions welcome :)

Devlog Together

I've been slowly reading "The Nature of Order" by Christopher Alexander and slowly thinking about how to make my editor for text and line drawings more timeless. (And mostly sleeping a lot, if I'm honest.) Today the combination of the two led me to draw this shape for the line-wrapping algorithm.

Until now I've been developing the editor the "usual" way, which for me consists of needing some computation, figuring out the most convenient place to perform the computation, then squirreling away the result somewhere it's available when needed. In an effort to get myself out of the rut of the inevitable problems of indirection and cache invalidation that result, I've been trying to replace all my ad hoc data structures with on-demand computation based on the base state of the program. And what I've been ending up with is umpteen variations of this pictured algorithm, just with different code stuck on to the protrusions.

There may be an abstraction that comes out of all this, but I don't see it yet. And as CA says, a flower isn't made up of identical petals. Each one evolves uniquely as a part of the whole.

Quick and dirty prototype of the above algo/shape/code using Vim syntax highlighting.

The code in the screenshot is a function to convert a mouse click (mx, my) into the location (line_index, pos) of the character at that point on the screen.

The problem is much of this function is boilerplate shared with several other places, such as the code to draw text on screen, compute the height of a wrapped line, etc. The boilerplate makes it difficult to see the business logic unique to this particular function, and so creates pressure to prematurely create an abstraction to "DRY things out". Highlighting the shape of the boilerplate in pink helps the eye to focus to the unique business logic in the protrusions, and so counters the pressure to hide the boilerplate before I've figured out the best way to do so.

🎥 exporting from codeflowcanvas to open-canvas draft spec via Maikel van de Lisdonk

Youtube Thumbnail

Some updates on my visual programming project codeflowcanvas this week: In this video I show some work I did for the open-canvas working group (ocwg for short): if you go to demo.codeflowcanvas.io/ocwg you can see a window floating in the bottom right, this shows the current flow in the current ocwg draft spec.

I've build the export mechanism using a strategy pattern so that I can also easily support other formats if needed (a basic export to tldraw is already one of them). I hope this helps in developing the new open canvas spec that the ocwg is working on via bi-weekly meetings and a github repo (see various links on canvasprotocol.org).

Lately I am focussing more on embedding and/or integrating codeflowcanvas with other tools and technologies so that it is not running in a silo of its own, and this feature helps with that I think.

This week I also send in a submission to liveprog.org.

Content

🐦 Will Crichton via Mariano Guerra

Will Crichton: I'm starting a new group at Brown w/@ShriramKMurthi and @KathiFisler called the Cognitive Engineering Lab. We build tools to make you smarter, grounded in cognitive science and programming language theory. And we're hiring PhD students!

If you know browser-based UI programming inside and out (eg, you could reimplement React or Svelte), let's build the PL of your dreams to make reactive UIs fast & correct. Or let's build the next LaTeX / Markdown!

🛸 esoteric.codes via Ivan Reese

Just discovered the mostly-defunct blog esoteric.codes. Some beautiful projects on display here.

🎥 Seeing Like a Programmer - Resiliency, Limits, And Moral Hazards In SE by Chris Krycho via Chris Krycho

💡 screamer: the playground for screamer, a live-coding language for ray marching via Charlie Roberts

Youtube Thumbnail

Mostly lurking and reading everyone else’s links, but I at last have somethign to share myself! Here’s my LambdaConf 2024 talk, which I think folks in here will appreciate! In this talk: Peter Naur’s “Programming as Theory-Building”, Donella Meadows’ Thinking in Systems , and James C. Scott’s Seeing Like a State .

Graphics

a small frp-ish dsl I made for live coding ray marchers: charlieroberts.github.io/screamer/playground

🤖

📝 Neural Operator: Learning Maps Between Function Spaces via Nilesh Trivedi

Neural operators generalize neural networks from learning mappings between finite dimensional Euclidean spaces or finite sets to mappings between functional spaces: Neural Operator: Learning Maps Between Function Spaces

Here's a TED talk about how it's being applied in science and engineering: AI that connects the digital and physical worlds

👨🏽‍💻 By 🐘 @marianoguerra@hachyderm.io 🐦 @warianoguerra

💬 Not a member yet? Check the Future of Coding Community

✉️ Not subscribed yet? Subscribe to the Newsletter / Archive / RSS

🎙️ Prefer podcasts? check the Future of Coding Podcast

Future of Coding Weekly 2024/07 Week 2

2024-07-07 23:22

📑 Programming languages resources 🔨 Breaking Silos 💡 The Interfaces With Which We Think

Two Minute Week

💬 Marek Rogalski

🧵 more images in the conversation

This week in Automat was mostly refactoring and bug squashing so not much to show. Except today I've sat down and designed the object that will act as a flip-flop switch. The first three images are the candidates for the final object. I'm actually still not decided which one to go for... The others images are just interesting results obtained from prompting stable diffusion

design-generated-20240705-164409-0-detailed realistic masterpiece best q.png

Our Work

📝 The proof is in the meta-tracing JIT interpreter via Mariano Guerra

The one where I implement a native JIT interpreter for my minimal oop language using pypy's meta-tracing compiler toolchain

In the previous posts: Make Your Self and Macros and optimizations: it's just a phase I described the design and implementation of a minimal object oriented language with the implementation done in...

🥞 toy postfix stack-based language to inflict upon my kids via Beni Cherniavsky-Paskin

Been a while since I touched it but I've been building a toy postfix stack-based language to inflict upon my kids. My theory is:

postfix may have benefits for early teaching (linear evaluation order, lack of "syntax", trivial notional machine)
the obvious drawbacks can be somewhat mitigated if instead of destructively changing the stack, you can navigate all previous stack states. (I'm not the first to try the latter; in particular Kartik did it in Mu, including descending into function calls. I don't even have user-defined functions yet.)
I wanted to explore "replacing" some uses of control structures with composition of a bigger data type, like a whole picture or animation.

I'm resigned to the thing not being turing-complete.

Initial implementation's data type was 1D "animation" of color change (I wanted them to program an RGB lamp)

=> My kids liked typing and mixing colors, but the idea of a single value representing change over time went entirely over their heads 😞

Anyway terminal REPL was a dead end, because you can't go back and edit past code. => I got a prototype web editor — you can move cursor, edit freely, and see stack state before each word: animation-stack-language.netlify.app

TODO: rendering still uses styled block characters 🧑‍💻, I need to learn canvas...

TODO: Next big step will be to replace the data type from 1D "time" to 2D "picture", taking inspiration from forthsalon.appspot.com and code.world .

I'm thinking to make do with some 2D rather than RGB colorspace, so that every pixel can also be interpreted as a vector. That way any picture doubles as a limited representation of function-as-data (not turing-complete! but very visual 🤔).

🎥 hash references to functions, effects and transpilation in EYG via Peter Saxton

Vimeo Thumbnail

Hash reference to every function and limiting effects at the top level to allow code to execute even after a failure. This is a bit longer as I try to explain in more detail what these features are in EYG

🧮 Visualizing Risk – Calc with Dec 🧮 🤓 via Declan

I made a blog post about visualizing risk

It's a scrollable explanation that develops up a visualization - a bit going on in it, a problem I have with a lot of things, so was really glad to spend time learning a few things about making this kind of scrollable interaction to more carefully introduce things.

Behind the scenes, the numbers are from a calculang model doing monte carlo simulations on a pension calculator calculang model. This composability (or what I call flexibility) is something I decided not to make this post about, but it's an important part of why calculang exists.

I plan to do a few similar separate exercises, and then spin back to this on it's own. (e.g. next: benchmarking actual results to their older estimates)

So, this blog post isn't really technical, but I hope it's interesting or at least easy to follow, and it fits into a longer piece about calculang. Happy if you have any feedback about the post or questions about this longer piece!

Visualizing Risk: feat. a pension savings calculation, Monte Carlo simulation, and ‘scrollytelling’

🤖 A Voice Controlled G AI Assistant for LabVIEW via Jim Kring

Making more progress on AI assisted visual programming (with voice control).

🎥 GAIA Voice Demo

📲 DIPLOMATIC: Data sync framework via Mason

I've been building a sync framework that app developers can integrate, to securely sync state changes between clients. I call it DIPLOMATIC, after the concept of a diplomatic bag which travels through foreign territories, but protected against inspection. So far I've got a couple host implementations targeting Deno and Cloudflare (Workers + Durable Objects + D1), as well as client libraries to build web clients in React and CLI tools in Deno.

The attached video shows off a demo app that displays and updates a consistent status message across clients. It generates and stores a cryptographic seed (synced via the browser's password manager), queues status changes when offline or not connected to a host, then pushes queued changes when connected, and receives real-time updates using WebSockets.

I've got some rough docs up at diplomatic-docs.replit.app, and a walkthrough of the demo app from the video at diplomatic-docs.replit.app/docs/demos/status.html.

The backstory is that, for a while I've wanted to build a grand life-planning app, like a TODO list that can operate at the decade-level rather than the daily-level. But I kept running into these blocks:

a) I'll want to access it from phone and desktop, so it needs a sync solution,

b) maintaining servers is a pain, and

c) a life-planning tool will necessarily have personal info, so it shouldn't hang out in plaintext on someone else's computers.

These sorts of issues aren't unique to this tool. In fact, I think they're common enough to merit a general solution. The Web 2.0 client/server model gave us easy software updates and access from multiple devices with consistent data. But we backslid by making all app data visible to the software provider and relying on them to maintain their servers. Mobile apps gave us the additional expectation that we could access our data while offline.

I think there's a simple solution to get the best of all worlds, by encoding app state changes as objects (the Event Sourcing pattern), then encrypting those deltas and shipping them off to a server which relays to other clients, which then decrypt and apply the changes locally. With this architecture, the relay servers all have a standard interface (not application-specific), and they're blind to delta contents, so hosting becomes a commodity. This means companies could specialize in just running these hosts, giving application developers a secure backend without the maintenance burden. It also creates a standardized import/export format for app state—the delta log, so you get a backup format for free.

I'm only designing around single-user apps at the moment. Having a "last-wins" policy for conflicts makes things nice and simple..

If anyone knows of related work I should check out, has suggestions, wants to collaborate, ... let me know. The code is still a bit messy, but I'm planning to tidy that up and open the repo soon.

🎥 diplomatic-status-demo

🐸 Todepond dot com: I went to an algorave via Lu Wilson

i wrote up my experience of slowly discovering the live coding world, and how my Arroost tool fits into it, and the motivations for my work

🖥️ A set of tools to play around with a Hack compute via Ignacio Brasca

Hello everyone! I have just finished a set of tools I built while learning about the Hack computer architecture. Today I felt confident that I could share all the code I wrote for this

To me, this architecture was a great starting point if you want to get a hang of how computers, compilers, and virtual machines actually work

Devlog Together

Shower thought on yesterday's thread above: the painter's algorithm is a way to make an interface less stateful. It lets you specify shapes to draw in any order. However:

It does this by adding more state to the implementation. You can't just draw each shape as you encounter it in the code. You have to shove them all into an array, sort by z value, and then draw them all.
It does this by adding more state to the communication channel. The human has to provide a z value now for each shape. Sometimes this is naturally obtained, sometimes it is not and the human now has to think in their heads about what z value to give their shapes to make the drawing come out as they want.

Thinking about this, it feels like state is to some extent inevitable. There's some conservation of state going on. You can't really eliminate it. You squeeze it down in one area and like a balloon it pops up somewhere else.

🧑‍💻 a visual notation for something we typically use keyword args for. via Kartik Agaram

This morning I'm thinking about turning 💬 #devlog-together@2024-06-30 into a visual notation for something we typically use keyword args for. For example, the following glyph might represent a function for initializing a text editor widget with the following signature:

edit.initialize(top, left, right, bottom, font_size)

And the numbers indicate a specific call to this function:

edit.initialize(15, 15, 115, 215, 20)

🤔 moving away from slack via Ivan Reese

This week, I'm learning more WebGPU, since I'm hoping to use it for a handful of visual programming projects down the road. I'm also still looking at options for 💬 #administrivia@2024-06-24. Would love to find something that feels more like a forum than a chat, but not toooo much like a phpbb, and doesn't have a per-user cost, and doesn't impose a maintenance burden, and is accessible to search engines (and accessible to all people, natch), and isn't likely to "incredible journey" or "we AI'd every text field for you" etc. So we're currently whatever the opposite of "spoiled for choice" is :)

Reading Together

📝 Weird Machines, Exploitability, and Provable Unexploitability via Polly

🎥 RuhrSec 2018: "Keynote: Weird machines, exploitability and unexploitability", Thomas Dullien

I've been kinda obsessed with this paper, "Weird Machines, Exploitability, and Provable Unexploitability" since October last year.

(I think starting with the talk is a good idea)

After hearing about robust first computing I've been pondering the connection for a bit. I'm not really sure what to make of it, but there has to be some connection. In this talk by Dave Ackley he specifically mentions that "flipping one bit" (paraphrasing) can be enough to destroy a lot of software, which is the exact attack model that Dullien uses. It would be nice if software could maintain security invariants despite memory corruption (which Dullien proves for a small piece of software that he writes) so in that sense the two concepts allign. But I find that "continuing despite an error" or "return a best-effort answer" is the source of many security vulnerabilities, (mid example: database lookup fails, code is written in a way that forgot to handle that case, code continues anyway and returns admin data that shouldn't be shown). I wonder if any of y'all have read this or have thoughts about it. :))

Thinking Together

💬 Declan

I recall coming across some opinions Against interactivity. I think in support of showing the thing, rather than making the user interact to see the thing.

Is there a soundbite for this? Are there any good links? I don't know where I encountered this opinion I think a few times, but I found something in one passage searching Bret Victors Explorable Explanations.

I wonder is this the most concrete link or reference I'll get, or does it ring a bell for someone else?

💬 Shen Li

I find a lot of statements these days describes a fact about something and then call it the “best”.

It’s like someone saying “look number 2 is so great, it’s the only even prime number, it’s so cool that it’s used as the base of digital systems, so we should use 2"

And someone else says: “well, number 3 is cool because it’s the first Mersenne prime, and it has a super cool divisibility rule, so we should use 3”.

At the end of the day, if the question is 1+1, then 2 is infinitly better than 3, and the other way around if the question is 4-1. And if you just need some positive integer as a placehold or something, then well, they are the same.

People seems to like and re-post these information a lot. I think these facts do provide some values, like the whole entertainment industry, it fulfills the curiosity of our minds and keeps us, well, entertained.

But drawing the conclusion that something is better, or something should be used instead of another thing based on these facts just feels off to me. It’s especially bad IMO, when people use these statements in PR reviews.

💬 Eric Normand

I have a question I hope someone here can answer. I am at something of a crossroads in my career and privileged enough to be able to pursue almost anything. When I tell people the big problems I'd like to make an impact on, it's education, specifically science education. I want more people to understand how the scientific method works and how we use it to gain more understanding.

I have passively read about education (Montessori, Bruner, Piaget, Pappert), followed Alan Kay and the smalltalk story, and I was a math teacher for a couple of years. I also teach currently online.

I can't help but think that there is more to using computers than reproducing old media, and that the code-debug cycle is a good way to refine our understanding. And so maybe there is something there, using programming and interactivity as a medium for exploration of ideas.

However, I don't have much more of a vision than that. I was talking to my wife about it yesterday and came up with an interesting phrasing: I want to do what Montessori did with her learning materials but with computers as a medium.

I would appreciate any and all links to people, conferences, reading material, etc., that are related to this idea.

Just to be clear, I don't mean teaching kids to code. And I don't mean using software to support the current educational paradigm (e.g., Chromebooks in schools, etc.). People seem to automatically roll back to those two pits.

I'm in pursuit of the next part of my career. I don't know what it will look like, but I want it to be productive.

pond’ring aloud:

The value of Gutenberg’s printing press is that it taught kids to read, not to build printing presses.

The value of computers is that they teach kids to ???, not to write code.

pond’ring aloud:

I wonder if the problem with VPLs is the word “language”.

It appears to me that the word “programming” has been generally accepted to mean “sequential language” or writing sequential codes (aka “coding”). I view this view as being too restrictive. Programming is more than just commanding a machine with sequentialistic instructions. Programming a CPU , though, is - by definition - sequentialistic. But,,, programming a machine(s) need not be sequentialistic. Especially in the age of nothing-is-central. In fact, LLMs are an example of non-sequentialism. The machines that run LLMs were programmed, arduously, in sequential notation, but, the inner success of LLMs is not sequential, but something else (massively parallel plinko?).

VPLs and DPLs are, to me, not sequentialistic things. Maybe they should be called “notations” instead of “languages”? VNP and DNP? Visual Notation for Programming, Diagrammatic Notation for Programming? [In which case, “programming languages” as we know them, are TNPs - Textual Notations for Programming].

In fact, programming is not the difficult part. Re-programming is the novel aspect of Design that computers bring to the world. We have been programming machines to do single things for centuries (using metal lathes, etc.). This time through, though, we have built machines capable of doing many things.

💬 Shen Li

Related to my last post, where I believe we shouldn’t make decisions outside the context of a problem or goal.

I’ve observed the same issue with secondary goals, where they are discussed outside the context of primary goals.

I don’t know if this bothers other people, but it bothers me a lot. Maybe I’m not smart enough to see the implied connections.

One example I can give is that many times I’ve been given the goal of “consistency,” whether in the UI or the code style. I’m not saying “consistency” is a bad thing, but without connecting it to the primary pre-shared goal, the value of this secondary goal becomes trivial and nullified. Logically, it doesn’t make sense either, especially for a start-up, because a start-up is doing something new, and you can’t do new things by pursuing consistency. If we did things consistently, we’d still be using XML instead of JSON.

Again, to be clear, I’m not saying doing things consistently is bad. I’m just saying that, for me, when given the goal of “consistency” without the context of why it’s important for our primary goal, I’d be much more motivated.

Another example is “patterns.” I think initially “patterns” are just solutions to some pre-existing problems, but we put too much emphasis on them to the point where we forget about the goals of these patterns, and the patterns themselves become the goal. To be clear, I’m not saying patterns are bad or that we shouldn’t use them. We should know them, in the same way we should know other just-in-case knowledge, to perform better. Some patterns are just cool, and we derive joy from them, the same way we get joy from movies and music. I’m just saying we probably shouldn’t treat them as primary goals (unless in school, I guess, where you get points for implementing a pattern).

Now that I think about it, this may just be a communication issue within an organization, where secondary goals are communicated without the connection to primary goals. I’ve never worked in a big organization, and I wonder how they do it. Also, am I alone in this? Do other people feel demoralized too when given just a secondary goal?

Content

📑 Programming languages resources via Mariano Guerra

This page is a collection of my favorite resources for people getting started writing programming languages.

🔨 Breaking Silos via Mariano Guerra

Breaking Silos by Gilad Bracha

Experiment: AI assisted summary edited by me to pique your interest (let me know what you think):

Modern applications are siloed and have difficulty cooperating with each other.
This was not always the case, exemplified by the Apple Newton, a mobile device released nearly 30 years ago.
Apps on the Newton were written in NewtonScript, a prototype-based language.
Newton applications had a flexible top-level view, enabling app compositionality where entire apps could be nested within others.
Objects in NewtonScript (called frames) inherited properties from both their prototype and their parent, facilitating UI use.
This inheritance allowed an app to function as a widget inside another app, enabling dynamic interaction between nested and enclosing apps.
Apps on the Newton persisted their data in object stores called soups, which were accessible by multiple apps.
The concept of co-designing language and UI existed earlier, exemplified by the Boxer system from the 1980s.
Another example of compositionality is Morphic, a graphics system developed in Self and later adapted for Squeak and Lively Kernel, focusing on graphical structure rather than application logic.
Inspired by Morphic, the idea of an app store with composable apps was proposed about twenty years ago.
These apps would live-update, synchronize automatically, and be local-first, a concept predating Apple's app store.
Newspeak language derived partly from this effort.
A practical example of app composition is in travel, where a button for weather lookup could be embedded into an itinerary and dynamically interact with surrounding widgets to display relevant weather information.

💡 The Interfaces With Which We Think via Mariano Guerra

The concepts in modern operating systems — apps, windows, desktops, notifications, and so on — have so permeated our understanding of personal computing that it’s hard to imagine anything else, let alone believe there could be anything better.It’s easy to assume that this is, somehow, simply, how computers work .

But this can’t be further from the truth.

🎥 progrium technology thesis 2022 via Ivan Reese

Youtube Thumbnail

Revisited Jeff Lindsay's 2022 thesis video and, yep, it still kicks ass.

🧫 cell thingy via Lu Wilson

Incredible project: "cell thingy" inspired by CellPond and MarkovJunior

🐦 Tweet from @x via Duncan Cragg

x.com/_rygo6/status/1809346180650004992

I replied to this point mentioning my unshakeable belief in what I am doing, and it occurred to me that there aren't actually many on this FoC Slack who can equally say that they know exactly what they are certain is right for the Future of (Programming)! We get a lot of speculative and experimental thoughts here which is the reason we all engage, but who amongst you can say you are 110% certain you've found what you believe to be the Future, with the uncertainty only being in "whenever that comes about"? Which of course, as the Twitter thread mentions, is about the seemingly trivial but of course 110% important factor of "memeing" to the Internet. Personally, I'm crap at that bit.

📑 Ashley Blewer's Halt and Catch Fire Syllabus via Walker Griggs