Hello,
can someone help me compare these languages? It seems that a lot of
people can develop very fast in Lisp.
Do you think Lisp is superior to the other FPL(functional programming
languages)? If so, why?
What about Ocaml?
There is a study comparing different languages(FPL and non-FPL also)
at this URL:
http://haskell.org/papers/NSWC/jfp.ps
I extracted this table from that study:
Language Lines of code Lines of documentation Development time
(hours)
(1) Haskell 85 465 10
(2) Ada 767 714 23
(3) Ada9X 800 200 28
(4) C++ 1105 130 --
(5) Awk/Nawk 250 150 --
(6) Rapide 157 0 54
(7) Griffin 251 0 34
(8) Proteus 293 79 26
(9) Relational Lisp274 12 3
(10) Haskell 156 112 8
Number 1 & 10 where two implementations with Haskell by independent
persons.
What impresses at this table is the short development time with Lisp:
only 3 hours! On the other hand this may be explained because there is
harly any documentation written for the Lisp implementation.
Unfortunately Ocaml didn't take part of that contest, how do you think
it would be placed?
Maybe it would be interesting if this study would be conducted again,
by us from this Newsgroup. So we could compare our favourite languages
to each other.
Best regards...
From: Tom Breton
Subject: Re: Comparing Ocaml, Lisp and other functional languages
Date:
Message-ID: <m3ofgku5r1.fsf@panix.com>
·········@gmx.net (thelifter) writes:
[]
> There is a study comparing different languages(FPL and non-FPL also)
> at this URL:
> http://haskell.org/papers/NSWC/jfp.ps
>
> I extracted this table from that study:
>
> Language Lines of code Lines of documentation Development time
> (hours)
> (1) Haskell 85 465 10
> (2) Ada 767 714 23
> (3) Ada9X 800 200 28
> (4) C++ 1105 130 --
> (5) Awk/Nawk 250 150 --
> (6) Rapide 157 0 54
> (7) Griffin 251 0 34
> (8) Proteus 293 79 26
> (9) Relational Lisp274 12 3
> (10) Haskell 156 112 8
>
> Number 1 & 10 where two implementations with Haskell by independent
> persons.
> What impresses at this table is the short development time with Lisp:
> only 3 hours! On the other hand this may be explained because there is
> harly any documentation written for the Lisp implementation.
Does this include docstrings in the documentation line count? Unlike
the other languages (those that I'm familiar with) on the chart, Lisp
typically makes documentation part of the code itself (docstrings).
--
Tom Breton at panix.com, username tehom. http://www.panix.com/~tehom
From: Carl Shapiro
Subject: Re: Comparing Ocaml, Lisp and other functional languages
Date:
Message-ID: <ouy7kn71tpq.fsf@panix3.panix.com>
·········@gmx.net (thelifter) writes:
> What impresses at this table is the short development time with Lisp:
> only 3 hours! On the other hand this may be explained because there is
> harly any documentation written for the Lisp implementation.
> Unfortunately Ocaml didn't take part of that contest, how do you think
> it would be placed?
Does anybody out there have any references for this "relational lisp"
developed at ISI? I have tried querying Google with various
combinations of the keywords "relational", "lisp", and "isi", but
nothing relevant turned up.
"Carl Shapiro" <·············@panix.com> schrieb
> ·········@gmx.net (thelifter) writes:
>
> > What impresses at this table is the short development time with Lisp:
> > only 3 hours! On the other hand this may be explained because there is
> > harly any documentation written for the Lisp implementation.
> > Unfortunately Ocaml didn't take part of that contest, how do you think
> > it would be placed?
>
> Does anybody out there have any references for this "relational lisp"
> developed at ISI? I have tried querying Google with various
> combinations of the keywords "relational", "lisp", and "isi", but
> nothing relevant turned up.
>
May be this one: http://ap5.com
The Knight of the Google
From: Joachim Durchholz
Subject: Re: Comparing Ocaml, Lisp and other functional languages
Date:
Message-ID: <3CBC4BE6.9030106@gmx.de>
thelifter wrote:
> There is a study comparing different languages(FPL and non-FPL also)
> at this URL:
> http://haskell.org/papers/NSWC/jfp.ps
You have to be *extremely* careful interpreting the results of such a
contest. Languages that work well for one-person projects can break down
horribly for larger teams, and vice versa. Tool support and available
libraries often contribute.
Such studies are good for establishing anecdotal evidence. One can take
some very, very tentative estimates of orders of magnitude. (In other
words, I don't think that the time difference between 3 and 8 hours is
relevant, but I think 3 vs. 54 hours does say a little bit about the
comparative productivity of Lisp vs. Griffin - but not very much. And
you have to be extremely careful to check whether the persons doing the
development were at a comparable level of expertise, whatever that may
be, and that both programmers had access to all reasonably relevant
library, whatever that may mean.)
The two Haskell entries show the influence of non-language factors.
Programmer 1 wrote 85 lines, programmer 2 156 - that's almost the double
size. The documentation size is quite the reverse - programmer 1 did
more than fourfold in documentation (but this took him just 2 out of 10
hours more than his competitor).
These are variations just within the same language - I don't even want
to guess about the comparability of results where the languages differ!
> Maybe it would be interesting if this study would be conducted again,
> by us from this Newsgroup. So we could compare our favourite languages
> to each other.
You'd not be safe from cheating^H^H^H^H^H^H^H^H^Hbookkeeping differences.
Regards,
Joachim
--
This is not an official statement from my employer.