Ask HN: Graphical Languages / IDE | Hacker News Reader

Ask HN: Graphical Languages / IDE

8 pointsjdavid6 comments

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.

One might say that graphical programing languages were ahead of their time.

today, i think labview is the most prevalent graphical programing language out there.

do you know others? i am looking for one that might be good for multi-processing.

i wonder what metaphors would be the bare min to make it functional.

for example a few metaphores

* all base types, should visually show their byte structure

* sets(arrays, vectors, collections) should be squares, or blocks of memory

* objects should be circles or spheres

* public functions should be marked on the surface of an object, where privates are internal

* multiple inheritance could look like a ven-diagram, with a new circle enclosing the composite set.

* 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.

* 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.

* functions, should just be an array of instructions, supporting full CRUD.

.. what would you want?

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.

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

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.

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.

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.

It's the output of Processing that's visual. In graphical PLs, it's the input that's graphically manipulated; take a look at Scratch, you drag a "for loop" from a toolbox and drop it into a visual "control flow", then watch the FOR snap into place and presto.

http://scratch.mit.edu/

Reply on news.ycombinator.com