[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: problems with lisp

On Freitag, August 22, 2003, at 05:40  Uhr, Russ Ross wrote:

> I've used Lisp a bit but not extensively.  I see several things that
> would deter me from using it over other available alternatives.
> Some of these could be flat out wrong (again, my experience is
> limited) and I'd be interested to hear either corrections or
> rebuttals to what appear to me to be problems.

You should consider restating your questions wrt Common Lisp in 
comp.lang.lisp - you will probably get some excellent advice there.

> The main problem is that there isn't a good choice of a standard
> lisp that is well suited for general development tasks.
> Common Lisp lacks a good module system, has messy semantics that
> reflect its lineage too much, and doesn't have the right (standard)
> libraries for things like networking, string handling, and database
> access.  It's also big and complicated which reminds me too much of
> C++.  Whenever I decide I should finish learning Common Lisp and
> start reading up on the nitty-gritty of it I start feeling dirty and
> grinding my teeth.

AFAICT, the Common Lisp standard was not intended to be complete. You 
get a lot of add-ons in particular implementations, especially from the 
commercial vendors. Modularization concerns are typically covered by 
system construction facilities; networking, database access and the 
likes are also covered.

The standard libraries might not be integrated as well as could be, but 
at least they were designed around tried and proven practices. In my 
experience, the libraries typically provide exactly the features you 
need for the domain at hand.

> Performance is still a bit of a sore spot, too.  I hear that tuned
> lisp code runs as fast as C code, but I'm still sceptical.  I
> recently implemented a fairly simple solution to the ILC programming
> contest in both CL and OCaml.  I wrote it first in OCaml as an
> exercise to learn the language and then ported it to Lisp.  It was
> a purely functional solution and I was careful to use tail calls
> when possible.  The two solutions are almost identical in structure,
> but the lisp version is about 10x slower.  I tried it with two lisp
> compilers (clisp and gcl) and they were about the same.

OCaml reportedly comes with an excellent compiler while clisp and gcl 
are not among the best CL implementations with regard to efficiency.

You might want to try the exercise again with CMUCL or SBCL.

Another idea is to post the code to comp.lang.lisp and get some advice.


P.S.: Is this still considered on-topic on this list? I don't want to 
annoy anyone...