Hacker News new | past | comments | ask | show | jobs | submit login
Garnet – a graphical toolkit for Lisp (sourceforge.net)
54 points by cronjobber on Mar 5, 2016 | hide | past | favorite | 23 comments

The name of the C32 spreadsheet mentioned in the article is an acronym:

"C32 has been implemented as part of the Garnet system. It is an acronym, and stands for CMU’s Clever and Compelling Contribution to Computer Science in CommonLisp which is Customizable and Characterized by a Complete Coverage of Code and Contains a Cornucopia of Creative Constructs, because it Can Create Complex, Correct Constraints that are Constructed Clearly and Concretely, and are Communicated using Columns of Cells that are Constantly Calculated so they Change Continuously and Cancel Confusion."


Im actually more confused

I am Completely Confused by the Cacophonous Cascade of Cryptic Cant and Catchphrases in this Comment.

It will all make more sense after you read some more BAMcronyms.


Yay Garnet! ;) I worked on Garnet with Brad Myers at CMU, on the PostScript printing driver. Brad is really into mineral acronyms, and I came up with an acronym he liked: "GLASS: Graphical Layer And Server Simplifier".

Garnet had a lot of cool ideas in it, especially its constraints and prototype based object system.

A few years ago I wrote up a description of a similar system called OpenLaszlo, and how OpenLaszlo's constraint system compared with Garnet's constraint system. Garnet had a lazy "pull" constraint system, while Laszlo had an event/delegate based "push" system. Each used a compiler to automatically determine the dependencies of constraint expressions.

Constraints and Prototypes in Garnet and Laszlo


The problem we ran into with supporting PostScript with Garnet is that we wanted to use Display PostScript, but Garnet was using CLX, the Common Lisp X Protocol library which was of course totally written purely in Lisp.

Of course CLX had no way to use any client side libraries that depended on XLib itself. I'd steer clear of using anything that depends on CLX for anything modern. (Does CLX still even exist?)

Brad Myers produced "All the Widgets," which must have some Garnet demos in there somewhere! [1]

[1] All the Widgets, sponsored by the ACM CHI 1990 conference, to tell the history of widgets up until then: https://www.youtube.com/watch?v=9qtd8Hc90Hw

> http://www.donhopkins.com/drupal/node/69

"Constraints are like structured programming for variables"

Love it! Having been very interested in constraint programming and also dabbled a bit here and there[1][2][3], what do you think is holding back constraint programming?

[1] http://2016.modularity.info/event/modularity-2016-mvpapers-c...

[2] http://blog.metaobject.com/2014/03/the-siren-call-of-kvo-and...

[3] http://blog.metaobject.com/2015/09/very-simple-dataflow-cons...

> what do you think is holding back constraint programming?

All the constraints. ;)

As you mentioned, there are tricky two-way mathematical constraints, like Sutherland's Sketchpad [1] and descendants [2], and Gosling's PhD Thesis [3], where the system understands the constraint expressions mathematically and transforms them algebraically.

[1] Ivan Sutherland's Sketchpad: https://en.wikipedia.org/wiki/Sketchpad

[2] Geometer's Sketchpad: https://en.wikipedia.org/wiki/The_Geometer%27s_Sketchpad

[3] Algebraic Constraints; James Gosling; CMU CS Department PhD Thesis: http://digitalcollections.library.cmu.edu/awweb/awarchive?ty...

And there are simpler one-way data flow constraints like Apple's KVO notification [4], Garnet's KR based constraints [5], and OpenLaszlo's event/delegate based constraints [6].

[4] Introduction to Key-Value Observing Programming Guide: https://developer.apple.com/library/mac/documentation/Cocoa/...

[5] KR: Constraint-Based Knowledge Representation: https://docs.google.com/viewer?url=http%3A%2F%2Fwww.cs.cmu.e...

[6] Oliver Steel: Instance-First Development: http://blog.osteele.com/posts/2004/03/classes-and-prototypes...

As you pointed out, KVO constraints simply say that object.x = otherObject.y, so there's not much to them.

I think one thing holding back constraint programming is that they require an interpreter or compiler to understand them, or the programmer to write code in a constrained syntax.

Garnet's KR constraints are written as Lisp expressions implemented by Lisp macros, that parse the expressions and recognize certain expressions like "gvl" for "get value", and named path expressions. KR wires up the dependency graph based on that information, and marks the constraint as invalid if any of the links along the dependency path change, as well as when any of the final values the expressions reference change. But it doesn't understand the mathematical expressions themselves. At the time I was working on it, it didn't know hot to figure out which branches of conditional expressions mattered, so it would assume it depended on everything in the expression. (i.e. like the C expression "size = window.landscape ? parent.width : parent.height" -- if window.landscape is true, it depends on parent.width, else it depends on parent.height, but ). It only recalculates the constraint values lazily when you read them. ("pull" constraints).

OpenLaszlo constraints are written as JavaScript expressions that the OpenLaszlo compiler parses, and it creates some JavaScript data and hidden methods behind the scenes that go along with the class, which are used at runtime to keep track of all the dependencies. You don't have to use a special expressions in constraints to read values, but you do have to use object.setValue("key", value) to write values. (This was because OpenLaszlo was targeting the Flash runtime, and that was the most efficient trade-off, since Flash didn't support property setters like modern JavaScript does.)

OpenLaszlo constraints used a "push" model of propagating all dependent changes forward when you called "setValue", because that was the best trade-off at the time for speed and usability and how it was intended to be used. But with getters and setters you could implement a more convenient constraint system that didn't put so many constraints on the programmer and how you use them.

CLX not only still exists, it's the only working backend for McClim, and implementation of CLIM which is a specification for a particular gui API.

The C32 acronym is just for fun - here's some more: http://www.cs.cmu.edu/~bam/acronyms.html

We continue to do research on constraints in my group, see: http://cjs.from.so/ (but it's in JavaScript - not Lisp). There are many commercial uses of constraints today, such as for graphical layout and "data bindings" (connecting the model and the view) in many toolkits.

Brad Myers, CMU

Interesting, but are there any actual modern GUI frameworks for Lisp?

Probably not very modern or useful, but good for seeing how far we've come:

Here are RMS's designs for a Lisp window system called "Window-Win" from 1985, inspired by his work on the Lisp Machine window system:


"Window-win is a new design for a window system which is intended to have all the power of the Lisp machine window system, and more flexibility, with less complexity."


"For now, I will give commands long names for clarity. Actually they will be represented by one- or two-character codes. Since there are currently only 80 or so commands, one-character codes are possible."

There are Common Lisp bindings to most of the common GUI toolkits like QT and GTK and OpenGL, there have been Carbon bindings for the Mac and probably there are some native Windows bindings. As most Common Lisp implementations have an interface to call C functions, there are no fundamental limits to what you could do. For basic needs, there is also a binding to TK written entirely in Lisp (http://www.peter-herth.de/ltk/index.html) which is simple to install and use.

Can you give an example of what you consider an "actual modern GUI framework"? I've sporadically been on the lookout for something like that, and I don't think I've seen it for any language. I don't mean to sound negative; it's just that GUIs seem to be one of those things that tend to progress by the brutality of evolution rather than by recasting everything in light of recent revelation. Most of the battle-tested patterns are 30+ years old.

Think winforms(not XAML) and all of the stuff that Microsoft IDEs provide out of the box. The one thing they got right was GUI builders. Pity they had to ruin it with XAML.

CommonQt is a set of Qt bindings. It works just fine.

Last post I saw here said they're just wrapping Qt:


I've looked into it a bit. The answer appears to be… sort of. It depends on your definition of "modern," how many hoops you're willing to jump through, and which dialects of Lisp you're willing to use. These are some of the more promising options I found.

For Common Lisp, one of the longer-lasting and best supported options appears to be CAPI, which comes with LispWorks (http://www.lispworks.com/products/capi.html), but that costs a grand and is not open source, so that's kind of out of the picture for most people. If you're looking for commercial option that will just work, though, this might be worth investigating. (They seem to have recently released a "hobbyist" version that is only $500, but you can only use it for "non-commercial and non-academic purposes," so I'm not really sure how useful that is.)

Ceramic (http://ceramic.github.io/) lets you use Common Lisp to make desktop web apps using Atom's framework (http://electron.atom.io/). While that comes with all the disadvantages of making desktops apps with HTML+CSS+JS, it seems to be one of the more professional and easier to set up options.

If you're using a Java implementation of Common Lisp, such as ABCL (http://abcl.org/), you can presumably use any Java GUI framework. I've heard, however, that using Java libraries is significantly more awkward in ABCL than, say, Clojure, and that you might need to write some Java code to bridge the gap. The main attempt to get that to work I've seen appears to be this framework ( https://common-lisp.net/project/snow/ )—I'm unaware of any applications actually written like this.

Clozure CL (not to be confused with Clojure) has bindings to Apple's Cocoa framework (http://trac.clozure.com/ccl/wiki/CocoaBridge). Apparently there's a fairly battle tested cross-platform implementation of Cocoa that you can use to make it run on Windows and Linux too, but I'm having trouble finding a link to that right now. I think it was the framework used to port Comic Life to Windows, if that helps. Regardless, though, this sounds like a pretty scary option for someone without prior Cocoa experience.

Most of the more practical looking options I found seemed to be for Scheme.

Racket (https://racket-lang.org/) comes with a GUI toolkit that was originally forked from wxWidgets. The IDE is built in it, among other things. It has some quirks that wxWidgets doesn't, though—for example, all the widgets are native except for all text entry controls, which makes accessibility… interesting. (Also, on my computer, at least, they don't quite cooperate with high DPI displays.)

Chicken Scheme apparently has good bindings to IUP (http://wiki.call-cc.org/eggref/4/iup, http://webserver2.tecgraf.puc-rio.br/iup/), a fairly lightweight framework that uses native widgets on Windows and Motif/GTK on Linux/Unix/OS X. I wouldn't really call it modern, but it does look fairly convenient—the Scheme API seems to basically let you define GUIs in structured s-expressions (http://wiki.call-cc.org/iup-tutor#porting-some-examples-from...). (Also, I'm pretty sure it does support Unicode, and that the IUP site is just out of date.) This is the option I'm leaning towards learning.

Kawa Scheme runs on Java, providing the same benefits as ABCL, but it seems a little more battle tested, and provides native support for making Android applications (http://www.gnu.org/software/kawa/Android-view-construction.h...). It's used to, among other things, power MIT App Inventor. (You can actually unzip App Inventor projects and find Scheme files inside, which is kind of fun. I kind of wish the App Inventor team would make the framework more accessible from Scheme. :p)

And, of course, if you're willing to settle for dialects of Lisp more distant from Common Lisp or Scheme, you can use Hy and any Python GUI framework (http://docs.hylang.org/en/latest/), or Clojure and anything Java.

Hopefully there are some good ones I missed, because Lisp-like languages seem like they would be pretty cool for GUIs.

> Racket (https://racket-lang.org/) comes with a GUI toolkit > that was originally forked from wxWidgets.

The GUI was rewritten in 2005 and there are no signs of wxWidgets left (http://blog.racket-lang.org/2010/12/racket-version-5.html)

There are now native widgets on Windows, OS X, and, Linux.

> (Also, on my computer, at least, they don't quite cooperate > with high DPI displays.)

There are support for high resolutions displays at least on OS X - maybe the situation is different on Linux?

> because Lisp-like languages seem like they would be pretty cool for GUIs.

There was also Curl (a language, not the Net lib) some years ago. Tim Berners-Lee was involved in the company as an advisor or something. Around the 2000s, IIRC. Lisp-like in the sense that nested expressions were the main syntax. Had tried it briefly then. Was mainly for web apps though. Acquired later, maybe, by a Japanese company.


It got a 2008 InfoWorld award in the RIA category.

Oooh. thanks for the link on Chicken Scheme. I've been looking for ages for a more declarative-style GUI framework in a Scheme and I really like the look of that s-exp syntax.

I've used web interfaces when I've wanted to put a GUI on Common Lisp. Seems pretty workable.

Also not modern, but if you're into XLisp and Motif, you'll love Neils Mayer's WINTERP! [1]

[1] http://nielsmayer.com/winterp/

You can just use the GTK or Qt bindings. Or make a web app.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact