Doc/history.tex

   1 \chapter{Development history}
   2
   3 The idea of {\gs} can be traced back to 1994, when {\rs} proposed a
   4 DESS project \footnote{A DESS is an obsolete degree (obtained after
   5 five years of study at the university) of the French educational
   6 system which has since been replaced by a \emph{Master} degree}.
   7 This project was conducted by {\kerhoas} (and ...), and resulted
   8 in the first real prototype of {\gs}.  The main features of this
   9 prototype was that it was written in {\tcl}, and that its \emph{user
  10   model} (see chapter \ref{user-model}) was quite different from the
  11 current one.
  12
  13 As a summer internship, what-is his-name continued working on the
  14 project.  This work was important in that it revealed some severe
  15 problems with the user model.
  16
  17 Although {\kerhoas} had determined that {\tcl} was a good choice (I
  18 don't think he would say that today), I (i.e., {\rs}) was unsatisfied
  19 with this solution.
  20
  21 {\rms} had already (correctly, in my opinion) determined that (so
  22 called) scripting languages posed a problem because although they were
  23 supposed to be used as \emph{glued} between modules written in a more
  24 efficient language such as C, and that their implementation was
  25 usually to slow for implementing basic functionality, users preferred
  26 them to the lower-level language.  This created two major problems:
  27 first, applications written in the scripting language were slow
  28 (because of the poor implementation of the scripting language), and
  29 second, the part of the applications written using the scripting
  30 language was unmaintainable (due to the poor abstraction capabilities
  31 of the scripting language).  For that reason, he used a
  32 Lisp-derivative (Emacs Lisp) to create Emacs.
  33
  34 Emacs Lisp was created at a time when there were many, substantially
  35 different Lisp dialects.  The choice was not obvious to {\rms}, so he
  36 created his own dialect, which was a reasonable solution at the time.
  37
  38 In 1994, there were two main dialects of Lisp remaining, {\commonlisp} and
  39 {\scheme}.  At the time, I thought {\scheme} was more modern and that
  40 {\commonlisp} was going to lose, so I opted for {\scheme}.
  41
  42 The problem was that {\scheme} did not have any standard library for
  43 graphic user interfaces (determined essential for {\gs}); in fact it
  44 did not have any standard library for anything higher level at all.
  45 It was thus necessary to choose not only a language, but an
  46 implementation of a language.  Based on my knowledge at the time, I
  47 choose {\elk}.  It had a library for interfacing to {\xwin} which was
  48 determined essential to {\gs}.
  49
  50 As it turned out, {\elk} had exactly the problems {\rms} had
  51 predicted: it was too slow to use for the main parts of the system, so
  52 one ended up writing major parts in C, which was too low level for
  53 this kind of software.
  54
  55 At about this time, the {\gnu} project started promoting {\guile},
  56 a new {\scheme} dialect to be used in {\gnu} projects.  The main idea
  57 of {\guile} was that, since it was a dialect of {\scheme}, and that
  58 {\scheme} is strictly more powerful that most other languages (mainly
  59 due to its first-class continuations), it would be possible to
  60 translate other languages (such as {\tcl}) in a fairly
  61 straight-forward way to {\guile}, and thus allow for any less powerful
  62 scripting language to be used as extension language for any future
  63 {\gnu} application.
  64
  65 I jumped on the {\guile} bandwagon and converted {\gs} to Guile in
  66 around 1995 (with the help of some students, as usual of course).
  67 Unfortunately, the {\guile} project made some very unfortunate
  68 choices, such as basing it on Aubrey Jaffer's {\scm}.  Although {\scm}
  69 was one of the fastest known interpreters for {\scheme} it was still
  70 an interpreter.  And after the {\guile} team had added essentials
  71 (like classes and such) to {\scm} to obtain {\guile}, it was no longer
  72 very fast.  In addition, {\guile} turned out to be a moving target for
  73 years to come, and often obliged me to rewrite parts of {\gs} that I
  74 thought were done.  I did spend some effort on this, though, writing a
  75 library for accessing {\xwin} and some other important
  76 infrastructure.  Ultimately, {\guile} turned out to be too hard to
  77 track, and it was not clear that it was going to be fast enough to
  78 write an application in, nor that it would ever be stable enough for
  79 me.
  80
  81 For a while I was stuck and lost interest.  After spending a
  82 sabbatical year in Austin (working with the RScheme research group), I
  83 realized that I had been distracted from the obvious choice of
  84 language many years before.  I started looking into {\commonlisp} for the
  85 first time after having been mainly into {\scheme} since around 1985.
  86 It turned out that {\commonlisp} was the perfect choice for several reasons:
  87 it had a standard (ANSI); it had good, fast implementations that were
  88 free (in the {\gnu} sense of the term); it had a semi-standard
  89 interface to {\xwin}; it did not lack any fundamental features such as
  90 classes and exceptions.
  91
  92 So, I re-implemented {\gs} in {\commonlisp} starting late 1998.  I then no
  93 longer had to worry about tracking a ``standard'' or whether my
  94 language implementation was going to be fast enough.  And, I could
  95 safely use techniques from object-oriented programming without
  96 worrying whether my language implementation would support them.
  97
  98 But even this solution had a major problem.  The interface to {\xwin},
  99 although very good, was not high level enough.  I needed a real
 100 library for graphic user interfaces.  Many such libraries existed,
 101 though not for {\commonlisp} at least not freely available.  In fact {\commonlisp} had
 102 (and still does have) a semi-standard library called {\clim} (Common
 103 Lisp Interface Manager) which turns out to be an order of magnitude
 104 more advanced than such libraries for other languages, and which has a
 105 public specification.  The only (major) problem was that it had no
 106 freely available implementation.  {\commonlisp} vendors had versions that they
 107 charged an arm and a leg for, and which would be unacceptable to {\gs}
 108 anyway, since not freely available.
 109
 110 I therefore decided to put the {\gs} project on hold in order to write
 111 a freely available implementation of {\clim}.  To make a long story
 112 short \footnote{This story is told in great detail in the McCLIM
 113   documentation, part of the McCLIM software distribution}, it took a
 114 little more than three years, and lots of help from other
 115 contributors, to get the freely available implementation of {\clim} to a
 116 state where it would be good enough to implement Gsharp.
 117
 118 Starting in 2002, I gradually integrated {\gs} with {\clim}.  Arnaud
 119 Rouaned worked on it for a while, but it was not until August of 2003
 120 that I finally had time to spend time on it myself again.  During the
 121 first two weeks of August, I re-implemented anti-aliased fonts, an
 122 improved version of the Obseq library, and a new system for graphics
 123 output based on {\clim} recording streams.