Node-based environments can be powerful for exploring solutions like this, but they don’t often make it to Hacker News.
Node-based environments can be powerful for exploring solutions like this, but they don’t often make it to Hacker News.
And unlike a text-based language where there is (usually) a single flow path going towards a single direction, with graphics like the one in the article you have several "flows" so your eyes need to move all over the place all the time to connect the "bits" in order to figure out what is going on.
Though that last part could probably be solved by using DRAKON graphs instead (which can also use less screen space) since those have a more strict flow.
IMO graph-based visual languages are nice for very high level flows but the moment you need to use more than a couple "dot product" or "add values" nodes, it is time to switch to a text-based one.
I disagree about the single-direction “1D” nature of textual programs being unequivocally a benefit. When there are many independent paths that eventually combine, it’s easier to see the complete flow in a 2D graph. Linear text creates the illusion of dependency and order, even if your computation doesn’t actually have those properties.
Conserving screen space is a double-edged sword. If that were the most important thing in programming, we’d all be writing APL-style dense one-liners for production. But code legibility and reusability is a lot more than just who does the most with the least symbols.
This is where having separate functions help - as a bonus you can focus on that independent path without the rest being a distraction.
If there are multiple independent paths that connect at separate points where you can't isolate them easily if they were a function, the graph is already a mess.
> Conserving screen space is a double-edged sword. If that were the most important thing in programming, we’d all be writing APL-style dense one-liners for production.
That is a bit of an extreme case, it isn't about conserving all the screen real estate, just not being overly wasteful. After all the most common argument you'd see about -say- Pascal-style syntax is that it is too verbose compared to C-like syntax, despite the difference not being that great. You'll notice that despite APL-like syntax not being very popular, COBOL-like syntax isn't popular either.
You don't have to go to extremes - notice that in my comment i never wrote that all uses of graphs should be avoided.
Think of it like using a shell script vs something like Python: you can do a ton of things in shell scripts and write very complex shell scripts, but chances are if a shell script is more than a few lines that glue other programs together, it'd be better to use Python (or something similar) despite both being "scripting" languages.
Geometry nodes, on the other hand, I think are amazing. They really do provide a very useful abstraction over what would be a lot of tedious and error-prone boiler plate code.
With just a few nodes I can instances and properly rotate some mesh on every face of some other mesh. Boom, done in two minutes. And you can do so, so much more, of course.
The obvious downside is in complex scenarios the graph can be more difficult to manage and because of the nature of how its evaluated there are times you need to think about "capturing" attributes (basically a variable to hold an older value of something that gets changed later). But nothing is perfect.
Looks like blender has something reminiscent? Maybe? I haven't used it. https://docs.blender.org/manual/en/latest/render/shader_node...
https://github.com/derkork/openscad-graph-editor
though I usually use: