> Technically the language is Turing complete at this point, but will be excruciatingly laborious to use, violating my design rule #2.

I stopped at step #1 with my Lambda Diagrams [1]. The bottom of that page links to all other graphical lambda calculus notations I know of (just added this one).

[1] https://tromp.github.io/cl/diagrams.html

It's all way over my head, but this is amazing work! The 2 obfustication techniques are pretty insane.

Had some issues trying to upload my own png's, maybe too big(?)

That looks like a fun project to build!

Why did it have to be pixelated in appearance? It would be far more attractive as anti-aliased vector lines and type.

The red highlighting reminds me of electricity in the classic circuit problem game _Rocky's Boots_ on the Apple ][.

As I've posted in similar discussions: https://news.ycombinator.com/item?id=42051536

The problem here, as always is that there isn't an agreed-upon answer for the question:

>What does an algorithm look like?

The problem is expressiveness of such a diagram is bounded by the size of a screen or a sheet of paper, and once one starts to scroll, or can't see the entire flow at a glance, things get complicated.

The node/wire programming folks have this a bit rougher to the point that there are sites such as:

https://blueprintsfromhell.tumblr.com/

https://scriptsofanotherdimension.tumblr.com/

I prefer to work visually, but not sure if that's actually valid --- unfortunately https://www.blockscad3d.com/editor/ doesn't support all of OpenSCAD and https://github.com/derkork/openscad-graph-editor has problems with a stylus (I have to leave the Windows Settings app open to toggle stylus behaviour which is enough friction that I don't use it as much as I would otherwise).

There are promising tools though: https://nodezator.com/ and https://ryven.org/ are very cool.

Sure a fun project, but that neither looks good, nor is it easy to understand. Reminds me of Frege's notation on steroids.

This reminds me of Lukasa memory boards, analogous to written language as this is to traditional programming (or as a table is to a chart). It's amazing how the way information is encoded and presented can affect its interpretation.

Nice ideas. I like the notebook where can I get it ?

Some other very visual programming environments/languages that I have found. They are different from other visual programming where you connect nodes with lines. These can be categorised differently but I don't what that will be.

Piet https://www.dangermouse.net/esoteric/piet.html

Turnstyle https://jaspervdj.be/turnstyle/ https://github.com/jaspervdj/turnstyle

Markovjunior https://github.com/mxgmn/MarkovJunior

Cellpond https://cellpond.cool/ https://github.com/TodePond/CellPond https://www.youtube.com/watch?v=xvlsJ3FqNYU

Imagegram https://zaratustra.itch.io/imagegram

Color Code http://colorcode.bananabanana.me/ https://www.youtube.com/watch?v=5M5hy9xsqKc Color Code 2 http://colorcode2.bananabanana.me/ https://www.youtube.com/watch?v=tTvvX4sjZWw Splaty Code http://splatycode.bananabanana.me/ https://www.youtube.com/watch?v=gd_e85lAKOs (By Muril Polese https://github.com/murilopolese/ http://gallery.bananabanana.me/)

Alchemy Online https://maxbittker.github.io/alchemy-online/ https://github.com/MaxBittker/alchemy-online

Reminds me of the 1987 “Wireworld”, of course Wikipedia has an article [1]. I’ve seen 8-bit counters implemented in wireworld, which is quite something, though this looks a bit more … succinct.

[1]: https://en.wikipedia.org/wiki/Wireworld

Wow, I love this -- all the more so because it's implemented in Javascript! The purists are spinning in their beds/graves, but it clearly made the visualization and audio followup steps easier, at the very least. The visuals are killer, and the obvious next step is to somehow translate the higher-level structure of existing programs into this; I would imagine nerds would pay good money to get Djikstra's algorithm on their wall, or an ANN backprop algorithm.

I did find this part funny:

  One interesting problem that I did not anticipate while imagining the language was that it turned out so purely functional and absolutely state-less, that it becomes impossible to implement a "print" statement, for to print is to change state, to expect some things to be printed in some particular order is to assume that some expressions will be evaluated in some order.

Isn't this just to say "not imperative"? Regardless, it does make me wonder how one would encode state... maybe introduce variables (icon + color?) and have individual statements ordered on one or both axes?

Direct link to the online demo: https://l-2d.glitch.me/

If you like this, you may find automation project engineer work fun... or at least familiar. Function block diagrams are quite like this: There function blocks are connected together with wires, and the order of operations is defined by block order. Blocks themselves are like builtin functions in the engine, or they can also be composites. The diagram is executed once per control cycle and generally (if no jump blocks exist), each block is always executed exactly once per control cycle regardless of if their inputs have changed or not.

And that is how control logic for anything from breweries to petrochemical plants is implemented! Fun stuff! I happen to work on the UI side of an FBD-based control system, so I float around this stuff day-to-day.

"The area of non-verbal programming languages has not been unexplored."

Starting out with the aggressive triple negative in sentence two!

Looks unreadable and reminds me of Factorio.

Something that always struck me about this sort of thing, or in similar games, is that it is only 2D and so rapidly becomes incredibly crowded with lines going everywhere.

We code in a 2D nature (rows and columns) but the flow is non-euclidean I guess

Takes me back to the good-old-days of block diagrams. Those went away with few complaints.

These things have been done in Labview, and it's hard to get anywhere. It's also been done in sound/music generation programs, with Max [max] as a (the?) granddaddy. While you can get things done, it quickly becomes messy too.

Does it look good? I don't think so.

[max] https://en.wikipedia.org/wiki/Max_(software)

Beautifully executed. The animated run feature on the online demo is exciting to watch.

I've been interested in graphical formal specifications since I first heard about Petri Nets like a decade ago. It always felt like engineers would be more likely to utilize formal methods if there was a graphical representation instead of a bunch of scary math notation and language associated with it. Sadly, every time I've tried showing Petri Nets to other engineers, they get pretty disinterested almost immediately.

Before I abandoned my PhD at University of York, I was working with something called "RoboChart" and RoboSim [1], which I actually think might be more approachable, but it's pretty tied into the robotics semantics. A pet project I've been working on has been trying to adapt and extend RoboSim to something a bit more useful for the network and server world.

[1] https://robostar.cs.york.ac.uk/robotool/