On 9 mar, 21:30, André Thieme <address.good.until.
Hi, André.
In fact, I tried almost all Lisps around: Franz, SBCL, Clozure (with
z)... every Lisp that is fast. My intention is not to build commercial
applications, but my group has money to spend. Right now, we received
a grant to study global warming and urban heat islands. I decided
that the number crunching must be done in SBCL. To reach this
conclusion, I played with Franz, CMUCL, and Clozure. I discarded Franz
because of it has a very complicated IDE. Instead of learning Lisp, my
programmers were clicking buttons, and trying to find their way in a
maze of menus, windows, dialogs, etc. After one week, nobody was able
to figure out how to save a standalone application. What I need is
something basic, that I run from a DOS box. My programmers believe
that the most friendly and direct Common Lisp is SBCL. Clozure is also
very friendly, but it is slow.

Now, for Clojure. One of the problems is to collect what experts call
ground truth to study the urban heat island. There are satellites
shooting infrared images from Earth. We are supposed to obtain a map
of temperature for large cities, like New York, Mexico City, etc. The
first thing is to eliminate atmospheric and surface effects from the
infrared images. If we were able to do that with perfection, we could
infer the temperature from the satellite images. The image correction
is obtained by solving equations given by Chandrasekhar in his book
Radiative Transfer. The equations are solved by large Lisp programs,
that I intend to run using SBCL.

Since the radiative transfer models are unlikely to work perfectly
well, the researchers need to correct the temperature maps before
sending them "to the table of the governor". This correction is called
ground truth. We connect small temperature meters to the personal
computers of volunteers. These devices send their measurements through
the Internet. A program (written in Lisp) compare the map of the
volunteers and correct the satellite. The satellite image contains
many more points than the volunteers image. So the governor will know
that the temperature is very high indeed --- he has no means of
knowing it because of the air conditioning (that is a joke :-).

We are looking for a good language for writing the small programs that
will collect the gound truth. You know what I mean, the programs that
go into the volunteers machines. Here are the languages we analyzed:

1 --- Pliant -- a language by a fellow from France; his name is
Hubert Tonneau. We rulled out Pliant because it is necessary to
install it in the volunteers machine.

2 --- Java -- Since most people have Java in their machines, it is not
necessary to install a runtime into volunteer computers. We rulled out
Java because it is too messy.

3 --- Scala -- is a language that generates code for the JVM. We ruled
out Scala because it requires to install a large runtime in volunteer
machines (3M). In fact, Scala runtime is larger than Pliant.

4 --- Clojure -- the problem with Clojure is exactly the same problem
that we had with Scala: a large runtime (smaller than Scala, but still
large).

5 --- Nice -- people around here became very enthusiastic about Nice.
It passed all tests. It is fast, generates Java VM, no runtime, it is
safe (compared to Java), easy to deploy (it packs all classes into the
same archive) etc. The problem with Nice is that its inventor, a
Frenchman called Daniel Bonniot, stopped supporting it.

The ground truth program is an applet. Since all languages that we
examined have problems, we still don't have a solution. Suggestions?