

Ask HN: Graphical Languages / IDE - jdavid

when the web was young and so was java, I remember programing my first java app in much the same way you wire up a circuit.  this was when macromedia was macromedia and flash was shockwave, and people used angelfire, and geocities over second life.  The web was young and it was innovative and people were playing with graphical ways or programing, even before GPUs were around.<p>One might say that graphical programing languages were ahead of their time.<p>today, i think labview is the most prevalent graphical programing language out there.<p>do you know others?  i am looking for one that might be good for multi-processing.<p>i wonder what metaphors would be the bare min to make it functional.<p>for example a few metaphores<p>* all base types, should visually show their byte structure<p>* sets(arrays, vectors, collections) should be squares, or blocks of memory<p>* objects should be circles or spheres<p>* public functions should be marked on the surface of an object, where privates are internal<p>* multiple inheritance could look like a ven-diagram, with a new circle enclosing the composite set.<p>* variables should be picture hashes, with a dominate color, the variable namespace could be used to generate the hash like a 'code of arms', so it's inheritance might be easily visible.<p>* all functions have an id, but they also have a creation date, last update, and last editor, all versions of functions exist, and you must attach to a version or a set of versions. once a function lacks any attachment, it can be deleted.<p>* functions, should just be an array of instructions, supporting full CRUD.<p>.. what would you want?
======
ktharavaad
I think you might want to take a look at this:

<http://ffnnkk.org/>

Fact is that graphical programming languages are only good for certain kinds
of programs which is why they have only gained traction in the data
acquisition world ( labview, lego mindstorm..etc ) where the metaphor of
"data-flow" fits in very well with the domain. Sometimes they are just really
slow to create general purpose programs compared to traditional text-based
programming. I still remember the labs I had to do in Labview where to insert
an element into an array, I had to drag like 3 different blocks unto the
screen, convert the data into right types the and then wire them up, just
inefficient.

------
silentbicycle
While I haven't used it, Processing (<http://processing.org/>) sounds like it
may be worth a look.

~~~
jdavid
processing is a framework for creating graphics and visualization. i am sure
this is a good way to write the graphical language container, but i was
looking more for what graphical metaphors should exist if we wanted to solve
problems using a graphical layout.

~~~
silentbicycle
All right, for starters: Most algorithms can be decomposed into graph
problems. (Trees are a subset of graphs.) Set operations, as you noted, can
usually be visualized with venn diagrams. Multiple inheritance may make more
sense as a tree growing together. A garbage collector's arena could show its
data fading away when it hasn't been accessed for a while. I like the idea of
a hash of a variable affecting its color, making structurally equal items
easier to spot.

Have you ever seen lavaps
(<http://www.isi.edu/~johnh/SOFTWARE/LAVAPS/index.html>), by the way?

To turn the question on its head, I wonder what concepts remain undiscovered
because people tend to brainstorm visually (on whiteboards, etc.), but some
ideas are intrinsically hard to depict visually. (Speaking as somebody who is
more textually-minded, but has become good at spatial thinking because of 3D
programming.)

Brainstorming in terms of sound (harmonic scales or rhythms) could bring out
different solutions, for example. I find anthropomorphizing components of a
problem (like the actor model) helpful, too.

~~~
jdavid
i like the idea of any vr, or augmented reality components being brought into
the programing language environment.

the way i see it, text based languages lend them selves well to linear
thinking and linear processing. i think we are moving to a place where we need
to move passed linear thinking and move more towards networked processes.

it seems to me that on large sites, you might want to do A/B testing on a
number of features to see which ones work better, this means staged
deployment, testing and programing are done in a really complex way. we should
accept this as part of the pattern and design environments and tools to make
this easier to debug, without a whole bunch of "if" statements cluttering the
code to determine the configuration state.

i also see writing functions now as part of the design process, and i always
like some of the metaphors in UML, but UML also always lacked into translating
directly into code.

