Know any good GUI languages?

Recently an urge has been growing inside me. I have been wanting to play with graphical programming; I believe the age of textual programming is nearly over1, and I want to experiment with the next phase.

I’m asking for recommendations for languages or libraries in which to create this experiment. It’s purely an experiment, so experimental languages and environments are okay. Things along the lines of Squeak are okay (I don’t know smalltalk, but I was going to start researching it, until I realized that there might be something better I’ve never even heard of). Basically I want it to be a nice match for what I’m doing; I want it to be ridiculously easy to create a GUI (and I don’t care how it looks, so long as it does the right thing).

I’ll describe what I’m doing. My first experiment is a dependently-typed “environment”. I’m picturing bubbles floating around (could be boxes in a table, I don’t care) which are not organized in any linear fashion. These bubbles are tagged with a type and possibly a name, and they represent “I have an object of type t“. Arrow types are multi-parameter and look like this:

Visualization of an Arrow type

Where the things on the left are “important” parameters, the thing on the right is the return type, and the things on the bottom are “extra” or “implicit” parameters. And you can drag a bubble onto a parameter of an arrow to represent application, and to get a new curried composite bubble representing it. That’s basically the whole environment. What could I make that in?

1 The same way that C is an obsolete language today. :-)


11 thoughts on “Know any good GUI languages?

  1. In some engineering circles they swear by LabView, but I haven’t spent much time with it myself.

  2. I see plenty of text in your mockup — are you sure it’s not a TUI with some spatial syntax?

    You can do spatial syntax in ASCII, for example

    Remember that text is just an arrangement of graphical icons. In other words, text is a technology based on graphics, not the other way around.

  3. Thanks for the suggestions everyone. I’m looking into Squeak first (seems to be a good fit so far, but it is going to cause me to go on a rant about OOP pretty soon :-). Open Quark looks promising.

    yaxu: That’s… ridiculous. Even if it were (indeed I’m not convinced this first run is not), I would not do it in ASCII, if only for the pride of the Haskell people.

    The experiment is about a constructive interpretation of proofs, based on sets of terms. If you have as an assumption or intermediate conclusion “x is an integer”, then there’s a tangible blob on the screen that represents that fact. Combining facts you have into ones you want is like putting them through factories. It’s essentially a cognitive experiment, to see if a touch of spatial reasoning can make dependent type programming any easier.

    Another key idea is that you’re not so much refining a proof as working in a world. Things that are true are true whether or not they’re relevant, so there is no need to delete conclusions. Instead you interactively build up a world of true things, and at the end of the day you have a thing representing what you wanted to compute or prove. Perhaps that blob could write itself out to a transcript only citing the things it needed. That latter part isn’t a piece of the short-term plan though.

  4. I have always been curious about the possibility of coding in SVG (or some other vector format), basically just using SVG instead of ASCII. Then you could code in any vector editor that can save as SVG, and also do whatever kind of documentation graphics you want right inside the document. Parsers could be made incrementally more flexible to recognize more different kinds of constructs, and it could provide a nice sandbox for testing different kinds of visual programming methods.

  5. I wasn’t suggesting that you make your system in ASCII Art, I’m just pointing out that you are claiming the textual programming era is nearly over while presenting a textual programming language.
    A triangle is a symbol, and so in a sense is textual.
    Haskell has a 2D syntax, which is in a sense spatial.
    Are you going to consider spatial semantics in conceptual space, where meaning is built from distance relationships instead of syntax? I think that’s where new paradigms in programming may lie. I think if your GUIs don’t include meaningful distance along meaningful dimensions then you will still always end up with a symbolic programming language.

  6. @Luke; It looks like you want the guy who started to finish it. Maybe you can contact him by the info on the site, and either 1) get him to finish; or 2) get him to allow you to finish you own version.

    Either way, it looks interesting… :)

  7. Yeah I saw the subtext demo a while ago and quite liked it. My colleagues have different opinions.

    However I’m not quite sure how to adapt the idea to dependent types, and my goal is more than just to create a visual language; it’s also to create an interface to dependent types that’s as easy as possible.

    As soon as I have a nice gui library set up in an frp framework (who knows when that will be — soon hopefully) I plan to hook into Coq, doing something not entirely like the interface I described in this post.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s