I mean it hasn't be done has no one seems to think about it, at best you have an overall fonts for all the code, but never a style guide like we have for books (brb googling to be sure) nope find no evidence of that, and by that I mean I complete rethink of how we visually see code (what to put emphasis on and why), not aesthetics variation of the same tropes.
In general there is some define school of thought:
- Text is bad we will rethink code around visual element like block or diagram to make accessible and approachable
- code is fine, we will just choose a better set of color and fonts to theme your IDE
- text is fine but current presentation is ugly verbose and a sore to the eyes(ex c++ brackets), let's design a new cleaner language (ex ruby)
The problem is that we don't think outside these model at all, and they seems to address to many things at once while ignoring so many other, there is no cross analysis, it's either all or nothing. For example moving away form text paradigm seems to not learn from the strength and weakness of that format, they identify one major problem and then toss away everything to start from scratch on a new paradigm that is presented as a silver bullet, it's visual therefore it's better and accessible, without a deep analysis of that assumption and of the many problem inherent to coding itself.
My take is that there should be a comparative analysis base on identifying the problem of each without necessary tossing everything, acknowledging what works and why and translating into a solution that address all parts.
For example most visual implementation are based on a data flow model, which is great to see what "become" what and track dependency but it generally become a visual mess, also data element get mixed with command element and it's hard to separate both because most of them don't have a visual emphasis in the difference (at best data link is colored and command link is monochrome, even though the block themselves are all look alike), also despite being visual, they have weak representation of actual important command flow like loop, and finally they don't take advantage of the tree structure to perform alternate view of particular structure (for example following the influence of a single variable).
Text paradigm on the other side, seems to emphasize things that are not actually useful past a certain level, I mean highlighting keyword is nice and all, but I care about what's what more than what keyword I already know does, especially when the syntax structure already give the relevant info, I know it's a type because the identifier is last, position is already an information. And the root of all evil is the said identifier, I understand it's a human readable key to uniquely identify a value, but god we hacked it to do much more to compensate. Not only that using identifier obfuscate data flow big time.
Visual design translated in text is basically Output = Node(node(),node(), [inputs...]); it's tedious to read and write (people hated lisp, and also why it's hard to generate readable code with visual language, though that should be fixable on the visual side by ACTUALLY ALLOWING NAMING THE LINKS), so we create generally little link with temporary variables like String Link = Playername(); Output = Node(Link); to make more visible, but it open the possibility to reuse the identifier Link after the data as been process once, which don't happen in visual data flow format, and that mean the same identifier can actually represent very different things, obfuscating the behavior of the code, not only that, it can teleport data across the code base without proper visibility of dependency , which make tracking bug hard, it can even hold and inject obsolete data when the code is modified, creating hard to find bugs. They are great on a local view of data but link in visual language are better for overall view and analysis (they are already parsed tree).
One key problem in visual language is to combine command flow and data flow in a way where "expression" are actually readable and not weird floating tree, I mean "health + 1 + score / stamina" shouldn't be these spaghetti monster that scared text code apologist high priest into damning the whole paradigm.
Code need a rethink
Edit note:
The funny things is that language "presentation" is often confuse with language "paradigm", when I say "all or nothing", when they change one of this, they also change the other, python is cleaner (presentation) but also typeless (paradigm). It's always the case, for example I believe it's possible to make a c# language look like python by using just a syntax conversion, not touching anything else, it would create regular c# text then it is compile as usual. But no currently you have to go python OR c# OR javascript, and these brackets and semi colon are getting on my nerves
Developer
