It was fun, but drawing those graphs is so slower than just writing code in text... Especially, if you made a mistake somewhere and have to rearrange parts.
No-one has yet made an effort to parse code and programmatically create these graphs? I hope someone does, seems very doable!
Has any visual programming language ever been successful?
The guys at Epic are really pushing their blueprint system, and a lot of people like it... but its inherantly tied to the engine.
That is a very insightful quote.
> vvvv is a hybrid visual/textual live-programming environment for easy prototyping and development. It is designed to facilitate the handling of large media environments with physical interfaces, real-time motion graphics, audio and video that can interact with many users simultaneously.
Ok, you're not going to write an OS in it - but for building games it's amazing. I use it to teach kids coding - some of the work they produce is astounding.
The people at Epic. Sorry, I know it's annoying, but sexism in computing isn't going to change if we don't pay attention to the language we use.
"You guys" is the only usage that can refer to a mixed-gender group. Obviously, that isn't how GP used it.
A relevant section from its man page:
[When given a file as input, sexist prints alternatives]
using neutral terms instead of sex-related terms.
For example "business executive" could easily replace
the stereotypic "businessman."
 I'm citing Bell Labs because they're prestigious and respected by HN.
 Because I'm trying to influence the vox populi, I'm using "we" imprecisely. I hope that those who disagree with me follow my argument even though I'm not speaking for them.
> but its inherantly tied to the engine
There's no successful (like C in text-based programming) visual programming environment for general-purpose programming at the moment.
It's really quite efficient to draw out an algorithm and let the computer turn it into code. Doesn't work for every problem - but it is very good at what it does.
(it is at the bottom of Wiki page but added it here for quicker access).
Also Stepan Mitkin gave an Erlang Factory talk this year about the Erlang backend for DRAKON:
I would reckon the strictness of the straight line has positive side effects – or avoids a class of negative side effects.
At any rate, some food for thought when it comes to trying to ideate programs away from a computer or at least away from a repl or IDE.
This is sort of rambly, but in pd/max/msp you end up with at least 2 types of data flow rates (common in musical stuff like supercollider as well) for musical sample rates (aka 44.1khz or whatnot) and 'control flow' rates (like an LFO wub at 120bpm half notes). Those are all still wired up with the same "lines" in pd so it can end up being confusing if you put a control rate into a sample rate or vice versa. I'm sure current MaxMSP has ways to separate and handle those (along w/ "bangs" which are one off messages), but the beauty of something like drakon is that it is just control flow. The data is explicitly defined in the boxes. So even though dataflow is the phrase google and microsoft are throwing around, the real art is in the control flow. Look at the scopes and contexts from the naiad paper: http://www.frankmcsherry.org/dataflow/naiad/2014/12/29/TD_ti... I think that drakon would be an interesting way to draw that diagram out. Not one hundred percent sure, but it's a thought.
What is ERIL? ERIL is a graphics language for representing data model. It is based on entity-relationship and class diagrams. Thus the name, Entity-Relationship and Inheritance Language.
ERIL is a counterpart for DRAKON. The DRAKON language describes algorithms and behaviour. It is an improved version of flowcharts. DRAKON introduces some rules that make flowcharts more human-eye-friendly.
However, the article misses one vital point: Undo!
Persistent saving without undo is a no-go. If I try something and the program (or OS) crashes, my previous state would be lost. It would be a state worse than not having saved the changes at all.
In particular, I find it troubling that they describe their SQLite actions as "insert", "update", "delete". I would have expected this to be insert-only, to preserve undo functionality after a crash. Then, from time to time some "delete" for garbage collection (maybe triggered by the user).
Having started down the dataflow route, further advantages then manifest themselves: most program development can be done by drag and drop, rather than typing; strong type checking can be done while edges are being drawn; the directed graphs used to draw code can double as completely general data structures; and the graphics libraries used to develop the language can be made available to the programmer.
The visual dataflow programming language I am developing is described here: http://web.onetel.com/~hibou/fmj/FMJ.html
Some visual languages, such as DRAKON and GRAIL, are based on conventional flowcharts showing flow of control, rather than flow of data. Flow of control, however, can be adequately represented as text.
Grasshopper  is very data flow oriented and functional, so you can program loops implicitly by flowing arrays, arrays of arrays, and trees along the wires, and the nodes know how to implicitly iterate over their inputs.
SimAntics (the visual programming language in The Sims)  (and I presume Dracon, but I haven't programmed in it) is very control flow oriented and imperative, almost like visual assembly language, and there is an implicit state (like a set of registers or local variables) that travels along with the program counter that flows along the lines between nodes.
A data flow switching "if" statement can be embodied in a data flow programming language as a node that takes three inputs: Condition, A and B, and outputs A if Condition is true, or B if Condition is false. Like "Condition ? A : B".
Or a control flow branching "if" statement can be embodied in a control flow programming language as a node that takes one input: a Condition (or it is activated by a flow of control input and the node contains a condition to evaluate against the VM state, like a flow chart branch node), and outputs the flow of control to A if the condition is true, or B if the condition is false (the road not taken). Like "if Condition goto A else goto B".
Some languages have a mix of both. Body Electric (aka Bounce)  is a real time data flow oriented visual programming language used for VR simulations, that primarily uses data flow switching "if" statements. The order of execution of the nodes is implicitly determined by a partial ordering of their dependency graph, and each node has an optional explicit "enable" input and output that you can use to turn on and off the execution of any node (behaving like an on-off switch type of "if" statement), and explicitly wire up the dependencies to control the order of execution (if the order of side effects is important, like for drawing commands).
Grasshopper is a good example of a successful data flow oriented visual programming language, with an excellent user interface, and a vast library of powerful features that elegantly dovetail together. I'm working on a project that uses Grasshopper for 3d printing houses. 
I'd caution against casually projecting anything you know about one visual programming language (like "it sucks" or "it rocks") onto any other visual programming language (and especially all other visual programming languages), because they can be EXTREMELY different! (Just like text programming languages.) And a lot of it boils down to ergonomics and user interface design, as well as the vocabulary of built-in primitives and libraries and abstraction mechanisms.
 http://donhopkins.com/home/movies/TheSimsPieMenus.mov and http://simswiki.info/wiki.php?title=SimAntics
 http://www.art.net/~hopkins/Don/lang/bounce/bounce.html and http://c2.com/cgi/wiki?BounceLanguage and http://www.jaronlanier.com/vpl.html and http://www.jaronlanier.com/instruments.html
 http://3dprintcanalhouse.com/ and this screenshot http://imgur.com/avYXU6Y from this video https://www.youtube.com/watch?v=TAoW1iA385w
Advantage: It seemed easy for beginners to learn how to do simple things, such as sequencing the operations and measurement in a lab experiment or instrument prototype. That's pretty cool.
Disadvantages: 1) For me, I happen to suffer from severe eyestrain and wrist / neck fatigue when dealing with tiny graphics and fine mouse work. I would not be able to program a graphical language all day.
2. My impression that it's hard to modify / refactor code because of the laborious manual effort needed to move graphics around. Programs tend to become unwieldy when they expand beyond one screen.
3. I think that text is the easiest and quickest way to prototype a new programming language idea, and there is rapid evolution and proliferation of both text based languages and programming tools like specialized editors and environments. It's also easier to port a text based language to a new machine. I think that evolution would be slower if people had to develop a graphical framework to try out a new language. It's also very easy to share source code, either full programs or snippets, on the Internet via text, even across different languages with a bit of manual translation.
2. Programs, or rather functions/procedures/subroutines should, with very few exceptions, be displayable on a single screen. If they are larger, they should be split up. This applies whether the language is textual or graphical. Moving graphics around should make no difference to how a dataflow program executes.
3. Yes, it's easier to develop a new text-based language, because so much research has been done on them, and you don't need to develop an editor along with the language. But there are hundreds in active use, which are constantly evolving. If you want a new set of features, you can add it to an existing language or create your own dialect. Visual code must have either a text or binary representation of the source which can be shared. It may not be human-readable but that's not the intention.
3) It's essentially a way of displaying code, so perhaps any new languages could reuse the same graph/flowchart environment. But inherently visual languages are designed either towards people who don't want to learn a language or who are performing specific tasks where the graphic flow improves their reasoning. I'd say for the vast majority of 'coding' those are not the case, since the "concept density" is very low (but visual UIs may help a lot of get started programming people anyway).
Having a graphical environment also helps remove a lot of cruft from languages that newcomers shouldn't really have to deal with.
For example, if I want to make a C program to computer the distance between tow points on a plane, I have in my head something like "d=sqrt((x1-x2)^2+(y1-y2)^2); output d", and actually programming I'm going to have to import a couple of libraries to take care of both floating point arithmetic and IO. The only way a novice can know that is looking at an online reference basically; while a decent UI could easily provide a searchable list of math/IO functions and include libraries automatically. Those are always taken care of in visual programming languages. The syntax itself of languages is arbitrary in many ways you have to learn on a case by case basis (in the example, how exactly do you use printf to "output d"?), while in an UI you are forced to use the correct syntax, because it's the only option.
When you are programming an operating system or low level application none of those really matter, but for a newbie making a simple Mobile app it's going to involve googling a lot and copious amounts of copy-pasting templates for getting trivial things done.
But still, I think your point stands. The tools that beginners like to use, whether the underlying "language" is represented by text or graphics, tend to be fairly self contained with zero overhead and a built in lookup system for library functions and user interface design, and those systems tend to be implemented as graphical software.
Diff, merge, search/replace, copying code directly from chat or websites into a REPL or file to try it out.
I have used a handful of other visual languages and when I see a new one I am on the lookout for use cases that involve more than one programmer, sometimes not even knowing each other; features that make it compatible with existing file and line oriented version control systems or provide an alternative(which is a project in itself, hard, and might not be as modular)
Learning about visual programming languages gave me a new appreciation for the simple elegance of text and IMHO the future of them will be those that easily map back and forth between text and graphics so you can have the best of both worlds and continue to stand on the shoulders of giants.
Does anyone konw of languages that translate to/from text well?
It would be interesting to drag functions around (and so forth) in blocks.