Ugh.... similar to BitGrid[1] (my own hobby horse), but not. I imagine bits marching in parallel across a grid in the ultimate simplification of an FPGA. It's an idea that either has supreme utility (Petaflops for the masses), or doesn't... it's all down to how much energy a DFF takes on an ASIC. (This is a pair of numbers I've been trying to find forever... static power, and energy to load a bit)
Oh... and the programming model, nobody likes plopping logic down on a grid, they try to abstract it away as fast as possible. I don't have sufficient focus to be able to do that bit.
[edit] Somewhere in exploring this, I came across Von Neumann cellular automaton[2] and Nobili cellular automata[3], which I've not encountered, despite being interested similar ideas for decades. It's frustrating just how little discoverability there is in this portion of computer science.
Of course both share the same insane foundation:
The set of FSAs define a cell space of infinite size. All FSAs are identical in terms of state-transition function, or rule-set.
[1] https://github.com/mikewarot/Bitgrid
[2] https://en.wikipedia.org/wiki/Von_Neumann_cellular_automaton
[3] https://en.wikipedia.org/wiki/Nobili_cellular_automata
pps: If anyone wants to run with the idea of a BitGrid, I'd appreciate it
> 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).
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.
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.
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.
"The area of non-verbal programming languages has not been unexplored."
Starting out with the aggressive triple negative in sentence two!
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.
Direct link to the online demo: https://l-2d.glitch.me/
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
In terms of the programming paradigm this is not dissimilar to Funciton:
I explored this idea a while ago https://ouwi.org/ I wasn't able to get the perfect crystal I wanted but I think whatever works will need to be a lot more visually differentiated than the MIT version
The input reminds me a lot of the work pointed to here (good ole jart)[https://justine.lol/lambda/#diagrams]
Now if only I could get my head around it (shout out to the alligator eggs ref too)
Looks cool! I believe the demo would really benefit from
image-rendering: crisp-edges;
This will make the pixel art style rendering look much nicer, without the slight smoothing that makes the pixel edges a little blurry.
Takes me back to the good-old-days of block diagrams. Those went away with few complaints.
Beautifully executed. The animated run feature on the online demo is exciting to watch.
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.
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
Visual programming languages are very common.
Examples are game engines (Unreal and Unity), 3D art/effect tools (Houdini), Simulink etc.
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(?)
unicode program note for people who share the curiosity I had:
Λ-2D
< >
V
the original article uses lowercase λ
Nice ideas. I like the notebook where can I get it ?
Nobody gave a shout out to Robot Odyssey yet?
Looks unreadable and reminds me of Factorio.
That looks like a fun project to build!
Pffft, come back to me when these can all be auto-mapped to Factorio or Stardew Valley-esque metaphorical actions, then we'll talk
But no, seriously, this is super cool - I do honestly expect we're very close to diffusion-based image models being full programming suites (and compiling down to much more efficient representations, of course, but programming is abstracted for useful human understanding!)
Sure a fun project, but that neither looks good, nor is it easy to understand. Reminds me of Frege's notation on steroids.
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.
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.