[DrMiaow]

I have seen dozens of these things and have made a few myself.

Beyond some specific use cases, they don't seem to scale cognitively. The tangle of connections is a problem. The previous HN link from @andsoltis has a better critique than me.

Don't get me wrong. Besides being experientially cynical about these things, I'm also firmly in the camp of "one more UI breakthrough, bro and we might crack it!"

This one has some deep design that definitely attempts to extend the state of the art but still struggles with that aforementioned problem.

TBH though, the coolest feature is that widget that focuses on what you are doing. There is something there with it, I'm just not sure what the "there" or "it" is, but I do know I like it.

[vidarh]

I spent a lot of time on this too, many years ago, including working on a language designed specifically for it, and my conclusion was that I couldn't find a way to make it work without making the visual representation "just a tool" for working with a textual representation, because we still need to be able to communicate about code in all kinds of context where a largely visual system would mean being forced to share screenshots, as well as being able to handle e.g. diffs and source control. And once you still need to know and understand and work with a textual representation it feels like a lot of the potential evaporates, and that made me gradually lose interest.

I'd love it if someone found a solution to that, but it feels like an intractable problem beyond some specific use cases as you say.

I really hope I'm wrong.

[skybrian]

There needs to be some way of sharing diagrams, but hopefully not as screenshots? Maybe more like a higher-level SVG, where there is text and you can look at it, but it’s not the preferred way of viewing it. It would need to be easy to embed these diagrams in other documents, which suggests a standard format and viewers readily available, for browsers and editors at least.

Support for embedding such things in another language (Like we do with SQL and regular expressions) would be important, too.

That might be a place to start. Can we replace regular expressions with a visual language? What would it take to have “railroad diagrams” widely available in at least one programming language and many editors?

[vidarh]

The problem is now you're reinventing the entire software stack of everyone you ever need to communicate with about it.

Consider how hard it is to even get people to use additional symbols, like the APL's do...

[skybrian]

Yes, good example. On the other hand, emojis seem pretty popular, and many programming languages do support non-ascii symbols in identifiers. We just don’t use them much for actual code.

Along with markdown, there’s also increasing support for math equations in forums and blogging software.

[vidarh]

Emojis have universal appeal. Coding symbols doesn't.

Math symbols are a better example, but also extremely well established, and it's still taken a very long time to get widespread support, and it's still far from universal.

But note that non-ASCII symbols etc. was an example of the difficulty of even getting support for something "that simple". Now try to take the step up to e.g a node-based editor.

[adastra22]

That’s fine though? Ultimately everything you do on the computer is just a representation of bits being shuffled around. That doesn’t diminish its meaning or effective’s of a better user interface.

[vidarh]

The problem becomes if the form you're used to working with the code in is very different from the form you need to communicate about it in.

In practice every attempt I've looked at either become hard to communicate about the code in, or the visual aspect tends to end up just becoming a secondary visualisation of code that you still treat as textual first.

In the latter case, turning it into a better UI is an unsolved problem, because round tripping reliably between something readable as text and a meaningful visual representation is really hard.

As I said, I hope someone solves this, but most attempts aren't even pushing the boundaries into uncharted territory - a lot of attempts have been made over the years.

[conartist6]

The trick is that you don't round trip. You choose one immutable data structure that captures both the textual source of the program and the semantic information captured by the parser at the same time.

[vidarh]

That doesn't solve anything. The problem isn't how to represent the AST, but defining both a visual and textual version that can unambiguously represent the same thing without either or both representational becoming unusable.

[conartist6]

Right. I think it's already a solved problem though. HTML and the HTML DOM are a living solution to that exact problem. All that we have to do is take the patterns used to power general UI and develop a DOM for code.

[worldsayshi]

Part of the solution is probably to rethink the whole UX context. One interesting example to think about is ProtoFlux, a part of Resonite:

https://youtu.be/70PH5cQQEdQ?si=y4YmhnimzferVpCD

Since you develop inside vr you can also talk about and show the code in the same vr environment.

It's probably at this level we need to rethink stuff to make visual programming practical.

[vidarh]

But then you want to write about it and explain it to someone else, and you're back to needing a way to represent it that fits on a page or can be explained verbally.

[worldsayshi]

ProtoFlux is largely explained through tutorial videos I think. And I'm not saying that is superior. But I can imagine a lot of quality of life features around explaining it through voice that could be added to make it potentially superior or at least competitive.

You could for example explain every node verbally and visually to an AI bot that can then explain it to the next person, or selectively retrieve parts of your explanations on demand. (OK, I realize that sounds unnecessary complex.)

[adastra22]

Better to round-trip to the AST, and have the textual representation be derivative of that (e.g. by a code formatted like Go).

This also makes it easier to verify that you have all the same capabilities in both representations, as the ways of manipulating the AST are enumerable.

[vidarh]

Many people have tried that.

I built a language and UI around that way back, and many others have. I ditched mine because there were way too many unsolved problems I felt made it useless.

The problem is that if your primary means of working with the code is visual, the textual representation of your code then tends to be foreign to you when you're trying to use it to communicate aspects of the code, and when you constrain yourself to something that can be represented in a readable manner in a textual form, it turns out to be really hard to get to a point where the visual form is easier to work with.

E.g. something as basic as how you comment code in ways that roundtrips nicely is an unsolved problem.

If I have code represented as a graph, I'd be inclined to want to label relationships and dataflows that would be hard to place textually in a way that is meaningful in a textual version and that would roundtrip back to labels in the right place in the visual version.

I've not seen any attempts at visual code that gets even that right.

I've not managed to get it right myself either. If you force users to use an editor built into this tool, and edit a textual representation where some information is hidden, you can do better, but then if people e.g. copy a textual representation of the code into another application and back in, you end up with a mess.

Again, I want to be proven wrong about this. Badly. I love the idea. I've just seen enough failed attempts (and made enough failed attempts) to be disillusioned about it.

[adastra22]

Why would you want to work with the text representation, except when debugging or in the backend? I mean I get why you'd want the text representation to exist--we have mountains of infrastructure around text-based representations of code. Git for version control and LLM code models would work out of the box, for example. But that can all be handled on the backend by transpiling the AST to text as needed. Why would the user need to interact with the textual representation?

Commenting needs to be solved at the language level, and there are many languages that have solved this exact problem. Python, newLISP, and Smalltalk IIRC all have methods for docstring commenting APIs such that the docstring is available as text to the running program / REPL. Use similar syntax to allow any statement to have comments attached, and use this instead of free-form /* */ comments.

[dllthomas]

I think diffs, snippets, and source control are crucial, but I think they only tie you to a textual representation if you are trying to use existing, text-oriented tools for them.

I grant that this makes the project significantly larger if you're going to remove that constraint.

[conartist6]

I'm pretty sure I have a general solution to that problem. The key is that hierarchies can be embedded in text, as HTML and XML do. Check out https://github.com/bablr-lang/

[vidarh]

I'm not sure how that is solving it? It needs to be compact, and readable.

[conartist6]

I personally think CSTML is both compact and readable, though I understand why it would look the opposite the very first time you see it (and without any syntax highlighting at that).

Open up the source code for this web page: is it compact and readable? The answer seems to be that HTML is "good enough" in that regard, and I suspect CSTML will be the same especially as more developer tooling for it becomes available.

[vidarh]

The problem is that I'm not talking about markup. Markup - unless it's so lightweight as to be near unnoticeable is not a solution. Unless every application you're transferring it via supports CSTML, the representation needs to be as compact and readable as a regular programming language.

To take your example, pretty much anything longer than [1, true, "3"] is a non-starter if someone is pasting it into Slack, or sending an e-mail. The CSTML representation isn't readable to them, and would take additional steps on both sides vs. just writing the source representation. I'm not going to tell people how to do something by writing it into some other tool and pasting some large blob into Slack or my e-mail client and expect the recipient to reverse the process.

That is the problem space. How you represent that as an AST isn't the problem - that's easy. How you represent it in a way that everyone can read and write and that "passes seamlessly" via existing tools is the problem.

(I must also admit that I think the choice of serialization format for CSTML is utterly baffling and feels like it adds a lot of NIH)

[conartist6]

We're using markup to communicate right now and it's the overhead is small enough to be unnoticeable.

Try copy and pasting some HTML-formatted text from this page into your paste buffer.

I assure you that what goes into the buffer is HTML. You can verify this because if you paste the text into an HTML-embedding WYSIWYG editor (such as an HTML email composer) the formatting will be preserved. But if you paste the content of the same HTML buffer into VSCode, notice that you don't get the raw HTML but rather the textual content that was embedded in that HTML.

[WillAdams]

I use such tools when I can, and am fascinated with the concept, since it evokes Herman Hesse's _Glass Bead Game_ (from his novel _Magister Ludi) which was a book I remember fondly from my youth.

Advantages are:

- discoverability --- it seems pretty easy to arrange all elements in a hierarchy and make them accessible via clicking/revealing

- no syntax errors --- if things fit together/connect, then it should be a syntactically valid program

The problem is, it relies on a couple of concepts we don't seem to have a good solution for:

- What does an algorithm look like?

- How to deal with an algorithm which is larger than the current screen/window size? (it's all-too easy to have the same sort of problem of a not-wrapped program with lines longer than the current window size and more lines than will fit in a window, and there doesn't seem to be a 2D graphical equivalent of turning on word-wrapping)

- If programs are broken down into discrete modules, then connected together, one is back to the wall-of-text description which presumably one was trying to escape from, just wrapped up in boxes and connectors

Two pages with cautionary images are:

https://blueprintsfromhell.tumblr.com/

and

https://scriptsofanotherdimension.tumblr.com/

I've been trying to use OpenSCAD Graph Editor: https://github.com/derkork/openscad-graph-editor in my own work:

https://github.com/WillAdams/gcodepreview

and the screen grab from there sums up the difficulties pretty well:

https://raw.githubusercontent.com/WillAdams/gcodepreview/mai...

[Rhapso]

Looking at those, I feel like we are approaching the problem entirely wrong.

Even in text, you don't try and look at everything at once, zooming out for a "structure overview" seems useful, but that is not what is happening here, its just imperative code being shoehorned into a DAG and left wherever a user left it instead of organizing itself, which is the whole benefit to graphical programming.

This demo of "unit" at least seems to organize nodes and views of nodes better.

[WillAdams]

Sort of?

One of the really nice things in Literate Programming

http://literateprogramming.com/

is that one gets a nicely typeset PDF which has a hyperlinked ToC which does serve as a "structure overview": https://github.com/WillAdams/gcodepreview/blob/main/gcodepre...

I agree, some facility for automatic re-organization and adjusting what is shown/readable in terms of hierarchy based on how much or little of the program is being shown would help a lot.

[mdaniel]

> - no syntax errors --- if things fit together/connect, then it should be a syntactically valid program

for consideration, one need not change the encoding medium to achieve this: JetBrains MPS <https://www.jetbrains.com/mps/#:~:text=Why%20MPS> (Apache 2 licensed: https://github.com/JetBrains/MPS ) is like a middle ground between "flashing cursor in a textarea" and "drag-and-drop programming" and they alleged to have written their bugtracker (YouTrack) using MPS but they have since removed the citation in the footer so I don't know if it was true or is true

[mikhailfranco]

But Hesse never actually describes the glass bead game. I thought that was the whole point of the book. He alludes to aspects of the alleged game, and let's the reader imagine perfection. Often similar elisions and allusions with the latest UI framework de jour.

[WillAdams]

Folks have been thinking (and dreaming) about it for a while now:

https://www.glass-bead.org/?lang=enview

[analog31]

I used LabVIEW extensively in the past. It was possible to organize code for readability, but it was physically laborious and I got massive eyestrain headaches and wrist fatigue from all of the fine mouse work needed. To be fair, maybe that's a personal ergonomic issue. I also can't use CAD for the same reason.

I can sling text with my eyes closed, and have managed the ergonomics of typing well enough that it hasn't injured me in almost 50 years.

On the other hand for applications where dataflow was a good paradigm for the problem being solved, I appreciated its benefits.

[bmitc]

> Beyond some specific use cases, they don't seem to scale cognitively. The tangle of connections is a problem.

This just isn't true. I've actually built things in visual languages. It just requires the same organization as text-based languages. One could write an entire text-based program in a single file in a single function, which would be a similar mess. In fact, the benefit or feature of visual languages is that they showcase poor code more readily than text-based code.

[patrick451]

I have also actually built things in a visual programming language. They are simply not capable of the same level of organization as a text based language because pictures is a bad way to communicate. There is a reason humans advanced past cave painting and hieroglyphics.

[bmitc]

Are you able to elaborate more? What language?

I have used LabVIEW, among other visual languages, and built systems with 1,000+ VIs, which are the fundamental building blocks of code organization, and hundreds of classes. LabVIEW has VIs, clusters, classes, libraries, and projects, all of which are useful and required for a well-managed, decoupled code system.

With good software principles, there's nothing that says you can't organize and scale visual code well.

I one time interviewed at a place that had swore off LabVIEW and were moving to Python. The reasons of switching from LabVIEW were the same tired reasons of organizational issues. When I asked to see their Python code, they showed me a single Python file over 10,000 lines long, and there were function signatures that were over 20 lines long. That was just the function signatures. This example, along with many more, and my experience in both visual languages and text-based languages make me very skeptical about claims about not being able to organize and scale code in visual languages.

[DrMiaow]

This is why I still have hope.

We see the tangle representing a complex system and say the tangle is ugly. We hide the tangle in text and names and say it is better. There is something odd there.

That the tangle is perceived to be uglier than the word.... is it that our brains deal better with a sliding window of symbols rather than gazing upon the sprawled true tentacled glory of some large algorithmic expression?

The promise of VP is that the program is the architecture is the monitoring tools.

Should we learn to love the sprawl?

So, I'm making two parallel attempts at this again. One more serious ( https://youtu.be/sqvHjXfbI8o?si=-PDXQes5i4JglBQj&t=411 ) and one as a game/exploration.

The first will be for tiny machine-generated programs linked together, which will be for a research project. The second is for an abstract physics game which will be for learning, fun, and hopefully some tiny profit on Steam. (Will appear here https://store.steampowered.com/search/?publisher=My64K when playable)

In, both I am adding severe constraints to the VP design but the game one will be the most interesting. I'm looking to add a kind of cellular automata mediated physics that also provides gradual automated optimization. Think programming in Minecraft with Redstone but with multiple dimensions and a regular polygon substrate. The key ideas I am exploring in both are:

1) Can we design a substrate that enforces some order that solves the tangle problem?

2) Within a substrate, can an algorithm be "crystalized" or "folded" into something recognisable by its shape?

I am starting next week. I have six months off work. It should be fun.

[Firadeoclus]

Visual programming languages are not prevented from using textual symbols, though. And many people use diagrams to communicate ideas more efficiently than they could with text alone.

[stcredzero]

Beyond some specific use cases, they don't seem to scale cognitively. The tangle of connections is a problem.

Tons of things like this were built in Smalltalk. (Including a UI->Domain model connection layer in the IBM VisualAge Smalltalk IDE.) They all had scaling problems, especially, "they don't seem to scale cognitively."

It's not as if the problem doesn't exist in most codebases. It's more that the problem is invisible without such tools. Tools making the tangle visible make themselves seem unusable.

The fundamental problem, is that we don't have ways of introspecting these horrendous relationship graphs for specific contexts. If IDEs and other programming tools generally could create custom browsers/IDE windows for things based in queries like:

"All of the methods that contain references to ClassA.Member1 and ClassB.Member2 which also call function Y."

...where this query can be modified or further specified at runtime. Then there could be specific built in queries that cover everything touched by canned refactorings. Then these further could be intersected or unioned.

EDIT: Forgot to complete my thought. If the graphical diagram could show contextually relevant slices of the system, it would greatly cut down the confusing web aspect of the diagrams.