I know this is advocacy-related and has the at least indirect potential to
spark flames. Knowing that, please forgive the following question:
As a Lisp beginner, I am very interested in the comparative value of LISP.
What are Lisp's fortes? How might Lisp be compared to other languages? To
what sorts of problems and projects is Lisp particularly adapted? What are
the pros and advantages in favour of Lisp?
Thanks for your input.
* "Esteban" <····@catfish.net>
| As a Lisp beginner, I am very interested in the comparative value of
| LISP.
I'm not trying to fuel any flames, either, but you won't see the
comparative values of (Common) Lisp as a beginner, and especially not
as a beginner programmer, but I assume you are somewhat experienced or
you probably wouldn't have discovered Lisp to begin with.
| What are Lisp's fortes?
It is by far more natural for some programmers to think in than any
other programming language available. To those who "think Lisp" and
discover it, there is not so much a question of fortes of Lisp, but of
relief from all the pain they experienced expressing themselves in
other languages. This point really cannot be underestimated, but it
is also very hard to explain to people. It also comes across as so
arrogant to people who cannot fathom that people are fundamentally
differently "wired" and that forcing people to work against their
wiring is really detrimental to their productivity and even happiness
that they write off the whole language and start to hate it -- for
_exactly_ the same reasons that Lisp people feel pain about other
languages, so they unwittingly underscore and prove the point with
their own hostility to a language that rubs _them_ the wrong way.
There's an hypothesis in language theory that states that languages
determine what we can think about, called the Sapir-Whorf hypothesis.
Even if it is not actually provable or has to be weakened before it is
true, it is an important contribution to our understanding of the
relationship between language and expressibility. I believe (in) this
hypothesis and I'm willing to argue that it is more true of artificial
languages than it is for natural languages, in that artificial
languages are intentionally restricting by their very nature: There
are large areas of human communication needs that are expressly
intended _not_ to be covered by artificial languages. This means that
the ease of expression will have been optimized, and optimization for
particular purposes is the worst possible thing you can do to a
language -- it may well be the best argument in favor of the strong
Sapir-Whorf hypothesis -- humans do not do what is more difficult than
the perceived average effort required or even the "effort baseline":
If it is too hard to do, it must be wrong. This is a very good thing
in any encounter with the physical world -- applying excessive force
to anything (other than the arm of George W. Bush so he quits whining)
is usually a sign that some important relationship is being violated.
| How might Lisp be compared to other languages?
Through a very careful process of looking at how programmers approach
problem-solving in different languages. Any problem can be solved in
any language. It is not the solution that is interesting, it is the
process of arriving at it, because that is what programming is about.
Programming is _not_ about staring at finished code and solutions.
Using software is different from creating software. Using software
does not involve appreciation for the programming language, creating
it does. E.g., in the C world, they write tiny little programs that
say "hello, world!" and such to demonstrate how to get "interaction"
from the environment, but some people then get the lunatic idea to
count the number of bytes in the source file and the binary image,
ignoring every relevant aspect of such numbers. In the Common Lisp
world, we have interactive environments and find writing a "hello,
world!" program about as exciting as writing echo "hello, world!" to a
Unix shell (except if it's some BSD csh derivatie crap that whines
like a presidential candidate about that exclamation mark, in which
case you just follow the old adage "If at first you don't succeed,
cry, try again").
| To what sorts of problems and projects is Lisp particularly adapted?
Absolutely everything, nothing excluded, that Lisp-thinking
programmers will turn their attention.
| What are the pros and advantages in favour of Lisp?
The biggest advantage of all is that it actually fits very well with
how some programmers think. I cannot stress this enough. Programming
is a thinking process and you need to be able to express your thoughts
in a way that is natural for you. Something about Lisp appeals so
strongly to some programmers that there is no need for any other pro,
forte, or advantage. The language is up to it, too, that's the really
scary part. John Foderaro has been quoted putting the essence of Lisp
in one sentence: "Lisp is a programmable programming language". This
is not for everybody, and everybody should realize that not all people
can even begin to approach a programmable programming language, but if
you can, there is no limit to what you can do with it. (There may be
a limit to what others can understand that you have done if you take
it too far, but that is a management problem, not a language problem.)
If you think programming computers is a worth-while task, programming
the language you use to program the computer should be such an obvious
and strong advantage that everything else just pales to insignificance
in comparison. What we need, however, is a little better ability to
tap into the vast resources of the native compiler and make it produce
code without necessarily going through standard Common Lisp forms.
(Allegro CL has a "low-level lisp" that can be used in this fashion,
but it is not documented, nor is it intended to be used, externally.)
#:Erik
--
Solution to U.S. Presidential Election Crisis 2000:
Let Texas secede from the Union and elect George W. Bush for
their very first President, relieving the rest of the world.
Thanks, everyone, for the replies.
"Erik Naggum" <····@naggum.net> wrote in message
·····················@naggum.net...
> * "Esteban" <····@catfish.net>
> | As a Lisp beginner, I am very interested in the comparative value of
> | LISP.
>
> I'm not trying to fuel any flames, either, but you won't see the
> comparative values of (Common) Lisp as a beginner, and especially not
> as a beginner programmer, but I assume you are somewhat experienced or
> you probably wouldn't have discovered Lisp to begin with.
>
> | What are Lisp's fortes?
>
> It is by far more natural for some programmers to think in than any
> other programming language available. To those who "think Lisp" and
> discover it, there is not so much a question of fortes of Lisp, but of
> relief from all the pain they experienced expressing themselves in
> other languages. This point really cannot be underestimated, but it
> is also very hard to explain to people. It also comes across as so
> arrogant to people who cannot fathom that people are fundamentally
> differently "wired" and that forcing people to work against their
> wiring is really detrimental to their productivity and even happiness
> that they write off the whole language and start to hate it -- for
> _exactly_ the same reasons that Lisp people feel pain about other
> languages, so they unwittingly underscore and prove the point with
> their own hostility to a language that rubs _them_ the wrong way.
>
> There's an hypothesis in language theory that states that languages
> determine what we can think about, called the Sapir-Whorf hypothesis.
> Even if it is not actually provable or has to be weakened before it is
> true, it is an important contribution to our understanding of the
> relationship between language and expressibility. I believe (in) this
> hypothesis and I'm willing to argue that it is more true of artificial
> languages than it is for natural languages, in that artificial
> languages are intentionally restricting by their very nature: There
> are large areas of human communication needs that are expressly
> intended _not_ to be covered by artificial languages. This means that
> the ease of expression will have been optimized, and optimization for
> particular purposes is the worst possible thing you can do to a
> language -- it may well be the best argument in favor of the strong
> Sapir-Whorf hypothesis -- humans do not do what is more difficult than
> the perceived average effort required or even the "effort baseline":
> If it is too hard to do, it must be wrong. This is a very good thing
> in any encounter with the physical world -- applying excessive force
> to anything (other than the arm of George W. Bush so he quits whining)
> is usually a sign that some important relationship is being violated.
>
> | How might Lisp be compared to other languages?
>
> Through a very careful process of looking at how programmers approach
> problem-solving in different languages. Any problem can be solved in
> any language. It is not the solution that is interesting, it is the
> process of arriving at it, because that is what programming is about.
> Programming is _not_ about staring at finished code and solutions.
> Using software is different from creating software. Using software
> does not involve appreciation for the programming language, creating
> it does. E.g., in the C world, they write tiny little programs that
> say "hello, world!" and such to demonstrate how to get "interaction"
> from the environment, but some people then get the lunatic idea to
> count the number of bytes in the source file and the binary image,
> ignoring every relevant aspect of such numbers. In the Common Lisp
> world, we have interactive environments and find writing a "hello,
> world!" program about as exciting as writing echo "hello, world!" to a
> Unix shell (except if it's some BSD csh derivatie crap that whines
> like a presidential candidate about that exclamation mark, in which
> case you just follow the old adage "If at first you don't succeed,
> cry, try again").
>
> | To what sorts of problems and projects is Lisp particularly adapted?
>
> Absolutely everything, nothing excluded, that Lisp-thinking
> programmers will turn their attention.
>
> | What are the pros and advantages in favour of Lisp?
>
> The biggest advantage of all is that it actually fits very well with
> how some programmers think. I cannot stress this enough. Programming
> is a thinking process and you need to be able to express your thoughts
> in a way that is natural for you. Something about Lisp appeals so
> strongly to some programmers that there is no need for any other pro,
> forte, or advantage. The language is up to it, too, that's the really
> scary part. John Foderaro has been quoted putting the essence of Lisp
> in one sentence: "Lisp is a programmable programming language". This
> is not for everybody, and everybody should realize that not all people
> can even begin to approach a programmable programming language, but if
> you can, there is no limit to what you can do with it. (There may be
> a limit to what others can understand that you have done if you take
> it too far, but that is a management problem, not a language problem.)
>
> If you think programming computers is a worth-while task, programming
> the language you use to program the computer should be such an obvious
> and strong advantage that everything else just pales to insignificance
> in comparison. What we need, however, is a little better ability to
> tap into the vast resources of the native compiler and make it produce
> code without necessarily going through standard Common Lisp forms.
> (Allegro CL has a "low-level lisp" that can be used in this fashion,
> but it is not documented, nor is it intended to be used, externally.)
>
> #:Erik
> --
> Solution to U.S. Presidential Election Crisis 2000:
> Let Texas secede from the Union and elect George W. Bush for
> their very first President, relieving the rest of the world.
> "Erik Naggum" <····@naggum.net> wrote in message
> ·····················@naggum.net...
> > There's an hypothesis in language theory that states that languages
> > determine what we can think about, called the Sapir-Whorf hypothesis.
> > Even if it is not actually provable or has to be weakened before it is
> > true, it is an important contribution to our understanding of the
> > relationship between language and expressibility. I believe (in) this
> > hypothesis and I'm willing to argue that it is more true of artificial
> > languages than it is for natural languages [...]
It has definitely been the case in my experience of artificial languages.
Not every language but every *class* of language has quite significantly
affected the range of solutions I can dream up. Quite often the language(s)
I'd used previously could well have supported the new solutions, but I would
never have thought of doing it that way in the "old" language.
OP: I think whichever language or type of language one settles upon as a
favourite, there's a lot to be said for learning other languages from
different classes. Lisp crosses a lot of those class boundaries. (The
technical ones, at least) ;-)
Erik Naggum <····@naggum.net> writes:
> What we need, however, is a little better ability to tap into the
> vast resources of the native compiler and make it produce code
> without necessarily going through standard Common Lisp forms.
> (Allegro CL has a "low-level lisp" that can be used in this
> fashion, but it is not documented, nor is it intended to be used,
> externally.)
I caught this comment here, and couldn't really decipher exactly what
you meant. Are you saying that somehow Lisp programmers should be
able to write things that they currently cannot, such as special
operators? Or that they should be able to malloc/free memory
directly, such as in C? What kind of behavior, exactly, are you
referring to?
dave
* David Bakhash <·····@alum.mit.edu>
| I caught this comment here, and couldn't really decipher exactly what
| you meant. Are you saying that somehow Lisp programmers should be
| able to write things that they currently cannot, such as special
| operators? Or that they should be able to malloc/free memory
| directly, such as in C? What kind of behavior, exactly, are you
| referring to?
New functions that utilize low-level features of the processor and/or
the internal representation of objects. E.g., you could write bignum
arithmetic that basically store values directly into an unnormalized
bignum and process them as integers in machine registers. You could
write your own functions that produce inlined instructions to support
particular optimizations. Intel has a BSWAP instruction that can be
used to convert between network byte order and native byte order, and
it really ought to be inlined and available at a very low level when
you basically stuff a bignum into a fixed-encoding field in a protocol.
Suppose you want a byte rotate function. You can write a fully
portable version that no compiler would be smart enough to optimize
into a rotate instruction if the processor has one and the byte was
supported by the hardware, but it would be nice if you could define
the general case portably and optimize into a single instruction when
that is possible. This is not particularly hard to do, but it does
require intimate knowledge of the compiler in most languages and
environments. Allegro CL lets me define and use new "instructions"
and new low-level forms to invoke them. Amazingly powerful stuff.
I do not think there should be a lower limit to what you can program
in a Common Lisp environment. Recall that several operators in Common
Lisp were originally instructions in processors of old. Common Lisp
has such an unfair reputation for being high-level when it can easily
be more low-level than C, with far greater access to the hardware
since Lisp does _not_ pretend that certain types are abstract when
they aren't and vice versa, like C does.
I do not consider allocating and freeing object low-level in this
sense, however. Both tasks are very complex and actually high-level
due to the many tasks involved. It is a high-level policy decision
whether either should be done manually or automatically and whether
you need an ownership protocol for all objects. However, once you
have an object, regardless of means, how you choose to use it may be
low-level, such as playing with the individual bit fields of a boxed
floating point number in order to, say, be able to compute logarithms
of arbitrarily large integers.
#:Erik
--
Solution to U.S. Presidential Election Crisis 2000:
Let Texas secede from the Union and elect George W. Bush their
very first President. All parties, states would rejoice.
In article
<··················································@lp.airnews.net>,
"Esteban" <···············@yahoo.com> wrote:
> I know this is advocacy-related and has the at least indirect potential to
> spark flames. Knowing that, please forgive the following question:
>
> As a Lisp beginner, I am very interested in the comparative value of LISP.
> What are Lisp's fortes? How might Lisp be compared to other languages? To
> what sorts of problems and projects is Lisp particularly adapted? What are
> the pros and advantages in favour of Lisp?
>
> Thanks for your input.
You will find a lot of material on the web site of the
Association of Lisp Users:
http://www.lisp.org/
Especially see:
http://www.lisp.org/table/lisp.htm
http://www.lisp.org/table/compare.htm
http://www.lisp.org/table/good.htm
--
Rainer Joswig, Hamburg, Germany
Email: ·············@corporate-world.lisp.de
Web: http://corporate-world.lisp.de/
In Peter Norvigs PAIP (page 25) (One of the best books I've ever read):
* Built-in Support for Lists
Is good because lists are a very versatile data-structure.
This is a real benefit if you write highly dynamic applications
* Automatic Storage Management
Highly dynamic Applications with explicit memory-management
are very difficult to handle - but in lisp we have a garbage collector
so we don't have to think so much about that.
* Dynamic Typing
You are not forced to declare types (-> enables Rapid Prototyping)
Functions are more generic.
* First-Class Functions
You can call, pass as an argument store in a variable and _create_
functions _at_runtime_!
* Uniform Syntax
Few rules. Easy to parse. Easy to generate.
* Interactive Environment
No Edit-Compile-Debug cycle. No hour-long compiling sessions...
Enables explorative programming.
* Extensibility
Highly extensible through e. g. macros. Lisp is able to adapt to nearly
anything you can imagine.
* History
Lisp exists for many years. A huge amount of higly-complex applications
was written in Lisp. It has proven to be the right tool for many tasks.
Regards
Jochen Schmidt
Esteban wrote:
> I know this is advocacy-related and has the at least indirect potential to
> spark flames. Knowing that, please forgive the following question:
>
> As a Lisp beginner, I am very interested in the comparative value of LISP.
> What are Lisp's fortes? How might Lisp be compared to other languages?
> To
> what sorts of problems and projects is Lisp particularly adapted? What
> are the pros and advantages in favour of Lisp?
>
> Thanks for your input.
>
>
>
>
Of course this was _not_ a complete listing of the outstanding
features of Common Lisp ;-)
Regards,
Jochen Schmidt
Jochen Schmidt wrote:
> In Peter Norvigs PAIP (page 25) (One of the best books I've ever read):
>
> * Built-in Support for Lists
> Is good because lists are a very versatile data-structure.
> This is a real benefit if you write highly dynamic applications
>
> * Automatic Storage Management
> Highly dynamic Applications with explicit memory-management
> are very difficult to handle - but in lisp we have a garbage collector
> so we don't have to think so much about that.
>
> * Dynamic Typing
> You are not forced to declare types (-> enables Rapid Prototyping)
> Functions are more generic.
>
> * First-Class Functions
> You can call, pass as an argument store in a variable and _create_
> functions _at_runtime_!
>
> * Uniform Syntax
> Few rules. Easy to parse. Easy to generate.
>
> * Interactive Environment
> No Edit-Compile-Debug cycle. No hour-long compiling sessions...
> Enables explorative programming.
>
> * Extensibility
> Highly extensible through e. g. macros. Lisp is able to adapt to nearly
> anything you can imagine.
>
> * History
> Lisp exists for many years. A huge amount of higly-complex applications
> was written in Lisp. It has proven to be the right tool for many tasks.
>
> Regards
> Jochen Schmidt
>
> Esteban wrote:
>
> > I know this is advocacy-related and has the at least indirect potential
> > to
> > spark flames. Knowing that, please forgive the following question:
> >
> > As a Lisp beginner, I am very interested in the comparative value of
> > LISP.
> > What are Lisp's fortes? How might Lisp be compared to other languages?
> > To
> > what sorts of problems and projects is Lisp particularly adapted? What
> > are the pros and advantages in favour of Lisp?
> >
> > Thanks for your input.
> >
> >
> >
> >
>
>
"Esteban" <····@catfish.net> writes:
> I know this is advocacy-related and has the at least indirect potential to
> spark flames. Knowing that, please forgive the following question:
>
> As a Lisp beginner, I am very interested in the comparative value of LISP.
> What are Lisp's fortes? How might Lisp be compared to other languages? To
> what sorts of problems and projects is Lisp particularly adapted? What are
> the pros and advantages in favour of Lisp?
I allow myself to participate to this potentially "will get long"
thread. I'm not so long on a "Lisp-Trip". Ok I was using Emacs since I
encountered Unices (nearly, of course vi was the first Editor on
Unix, Beep Beep Beep ... ;-)
My "background" is maybe not typical, at least I come from another
well written language which is understimated too. I started lookin
into functional languages. But I feeled a combination out of at least
functional and OO facilities is the way to go.
A bit later I encountered Scheme and fight down my prefudices because
of it's syntax ((()))) ;))). With the kind help of some long term
users of Lisps (especially Common Lisp) I was pointed to the benefits
of Common Lisp. I downloaded really soon the Hyperspece and do not
understand anything ;(
But there seems to be more fun, power and flexibility in it that I got
curious. I tried to get my hands on a somewhat decent IDE. But I was
out-of-luck. IMHO Scheme offers here much more (see DrScheme), but
fortunatly I found that there are trial versions out there.
I downloaded them and feel a bit more comfortable with it. So I tried
to express my support while trying to buy the Environments. To that
time the prices were mind-boggling. So I retained from buying. But I
started to buy all the suggested books. And now I got all this nice
things here ;-) With reading trough this books I get impressed by
Common Lisp more and more.
I looked into the prices again and guess what they dropped to a level
which I feel is justified for just learning. So I bough Lispworks. And
since then I'm on my journey to Lisp.
I wished I would have learned Lisp earlier (2 years back). I can't
imagine a language which is more flexible than Lisp is. From all the
languages I tried to learn (and have learned) Common Lisp is the most
impressive. The astonishing combination of features, the amazingly
good documentation (once you understand how to read it;-) The
possibilities to extend the language is unbelievable. Learning Common
Lisp inspired me too to learn my "all-day-tool" (X)Emacs. I now feel
comfortable reading and understanding and changing it.
I would surely drop all the tools for using Common Lisp. But (of
course you expected this). I'm using Linux and the interfacing to the
System is better solved e.g in SCSH, my Editor uses Emacs-Lisp, which
is a Lisp but surely not a Common Lisp. There are compatibility
packages, but it's not the "real stuff". My window-manager is SCWM
(uses Scheme).
So in fact I'm not using Common Lisp for my "all-day-work" and without
really using it I hardly will master it. If this tools would use
Common Lisp from scratch, I would be very happy using it. But I guess
this will never happen.
Sorry for the lengthy message which might even be boring, but it's to
point out that I regard myself as a fan of Lisp-ish languages now.
Lisps are about one thing, beeing there for programmers. No arbitrary
limits, well though ought elements; in short Common Lisp is a very
good balanced language which of course carries overhead caused by it's
long history.
Regards
Friedrich
--
for e-mail reply remove all after .com