Hello!
I'm new to programming in general. My schooling consists of a AAS degree
in networked systems administration. I have had some C in school, but as
this was not a CIS degree nothing advanced. I taught myself some Delphi
but again nothing advanced. I do have an interest in programming, and
have enrolled in a 4-year CIS program.
I realize that career wise, C/C++ is probably the language to master. I
base this on the number of jobs offered to c/c++ programmers in my local
paper. Unfortunately I don't like C. (Which is why I started to work with
Delphi.) I suppose as an independent programmer, it really doesn't matter
what language I use, but I don't plan on being an independent, at least not
right away
First, what kind of a language is Lisp? I'm looking for an objective
answer on some strengths and weaknesses, not only on the language itself,
but on it's uses. I'm not looking for any language bashing. Just some
honest answers from professionals.
My other question to all of you Lisp programmers is Why did you choose
Lisp, Given all of the different languages out there?
I have just received the Allegro CL starter kit and was pretty excited. I
mentioned this to some of the engineers at work. (I'm a network support
tech, but work around some software engineers) and the more or less told me
I would be wasting my time as Lisp and Smalltalk were dead. Now, these are
C++ programmers, so I understand there will be some bias. However, it
brings up a question of What could I expect as a Lisp programmer? Who
needs them (Scientific, business, games..) Where is it most used.?
Keep in mind that I'm new to programming, It was not my intention to
offend. I figured since I had questions about Lisp, this would be the
place to ask. I'm trying to make a somewhat informed decision on the
direction of what I hope to be a new career.
Thanks for your input, and sorry for such a long post...
-Pat
==================================================
Patrick Kemp
Anti-spam return address, please send replies to
Cynewulf AT Qadas DOT com
"They're not dead. They're metaphysically challenged." - Joel
==================================================
With a mighty <··························@cynewulf.qadas.com>,
········@qadas.com uttered these wise words...
> I realize that career wise, C/C++ is probably the language to master. I
> base this on the number of jobs offered to c/c++ programmers in my local
> paper. Unfortunately I don't like C. (Which is why I started to work with
> Delphi.) I suppose as an independent programmer, it really doesn't matter
> what language I use, but I don't plan on being an independent, at least not
> right away
I share your situation, as I too dislike C, and I think even less
fondly of C++. However, many people will expect us to use these
languages.
> First, what kind of a language is Lisp? I'm looking for an objective
> answer on some strengths and weaknesses, not only on the language itself,
> but on it's uses. I'm not looking for any language bashing. Just some
> honest answers from professionals.
I'm promise to be objective - at least, not about C++. I don't know
whether I'm objective about Lisp...I like it far too much! ;-)
> My other question to all of you Lisp programmers is Why did you choose
> Lisp, Given all of the different languages out there?
Origianally, I was simply curious. Then I became fascinated. The first
language that I fell in love with was Smalltalk, but here was another
language that could beat ST.
Today, I'd say it was the meta-linguistic features that I like so
much. I love being able to design a specialised language for a very
specific purpose, write a compiler that translated code in this
language into Lisp, and perhaps then write another compiler to produce
code in a much lower level language, like C or assembly.
The app that initially excited me was parsers for compilers, as that's
what I was doing at the time. I realised that the recursive decent
parsers I was writing in C used a very small part of C, and this code
could just as easily be written in Lisp, tested, and then compiled to
C for actual use. That was my "conversion experience".
Incidently, my first "compiler" did something like this in Basic, by
drawing to the screen to create a logo, then adding code to write the
memory image of the display to assembly source code. This then would
load into the memory mapped display, and insert some machine code into
the Basic app which would flash the logo (by inverting the screen
colours - dark green and light green, as this was 15+ years ago), and
then quit. The Basic app could then run this "logo" program when it
started up.
Don't worry, yo udon't have to write compilers to like Lisp! I'm just
one of those odd people who _do_ like compilers, and this is one of
the reasons why Lisp appeals to me. It actually makes everything
easier, not just compiler writing.
> I have just received the Allegro CL starter kit and was pretty excited. I
> mentioned this to some of the engineers at work. (I'm a network support
> tech, but work around some software engineers) and the more or less told me
> I would be wasting my time as Lisp and Smalltalk were dead. Now, these are
> C++ programmers, so I understand there will be some bias. However, it
> brings up a question of What could I expect as a Lisp programmer? Who
> needs them (Scientific, business, games..) Where is it most used.?
I like ACL/PC a lot. LispWorks for Windows might also be worth looking
at, altho I don't know if an evaluation version is available yet.
I get the same reaction from colleages, tho it's usually more of an
odd look, or perhaps a question like, "Are people still using Lisp?",
as if I'd suggested using COBOL. People still use COBOL, but I've not
yet met anyone who didn't hate it. This may be why people assume that
Lisp is no good: It's old, therefore we must hate it - surely? It's
hard to prove this is wrong without showing people something.
> Keep in mind that I'm new to programming, It was not my intention to
> offend. I figured since I had questions about Lisp, this would be the
> place to ask. I'm trying to make a somewhat informed decision on the
> direction of what I hope to be a new career.
No problem. Much tougher questions have been asked here, and many of
them have been asked by C++ programmers with no interest in Lisp.
It's been a little easier since 1995, so I suspect that most of them
are now hassling the Java people instead. ;)
I hope that Lisp can help you, but it might take a while to get into
it. Some people never do. However, if you feel unhappy with C/C++,
then you'll have more than a chance.
Good luck, whatever you do.
--
<URL:http://www.wildcard.demon.co.uk/> You can never browse enough
Martin Rodgers | Programmer and Information Broker | London, UK
Please remove the "nospam" if you want to email me.
With a mighty <··························@cynewulf.qadas.com>,
········@qadas.com uttered these wise words...
> I realize that career wise, C/C++ is probably the language to master. I
> base this on the number of jobs offered to c/c++ programmers in my local
> paper. Unfortunately I don't like C. (Which is why I started to work with
> Delphi.) I suppose as an independent programmer, it really doesn't matter
> what language I use, but I don't plan on being an independent, at least not
> right away
I share your situation, as I too dislike C, and I think even less
fondly of C++. However, many people will expect us to use these
languages.
> First, what kind of a language is Lisp? I'm looking for an objective
> answer on some strengths and weaknesses, not only on the language itself,
> but on it's uses. I'm not looking for any language bashing. Just some
> honest answers from professionals.
I'm promise to be objective - at least, not about C++. I don't know
whether I'm objective about Lisp...I like it far too much! ;-)
> My other question to all of you Lisp programmers is Why did you choose
> Lisp, Given all of the different languages out there?
Origianally, I was simply curious. Then I became fascinated. The first
language that I fell in love with was Smalltalk, but here was another
language that could beat ST.
Today, I'd say it was the meta-linguistic features that I like so
much. I love being able to design a specialised language for a very
specific purpose, write a compiler that translated code in this
language into Lisp, and perhaps then write another compiler to produce
code in a much lower level language, like C or assembly.
The app that initially excited me was parsers for compilers, as that's
what I was doing at the time. I realised that the recursive decent
parsers I was writing in C used a very small part of C, and this code
could just as easily be written in Lisp, tested, and then compiled to
C for actual use. That was my "conversion experience".
Incidently, my first "compiler" did something like this in Basic, by
drawing to the screen to create a logo, then adding code to write the
memory image of the display to assembly source code. This then would
load into the memory mapped display, and insert some machine code into
the Basic app which would flash the logo (by inverting the screen
colours - dark green and light green, as this was 15+ years ago), and
then quit. The Basic app could then run this "logo" program when it
started up.
Don't worry, yo udon't have to write compilers to like Lisp! I'm just
one of those odd people who _do_ like compilers, and this is one of
the reasons why Lisp appeals to me. It actually makes everything
easier, not just compiler writing.
> I have just received the Allegro CL starter kit and was pretty excited. I
> mentioned this to some of the engineers at work. (I'm a network support
> tech, but work around some software engineers) and the more or less told me
> I would be wasting my time as Lisp and Smalltalk were dead. Now, these are
> C++ programmers, so I understand there will be some bias. However, it
> brings up a question of What could I expect as a Lisp programmer? Who
> needs them (Scientific, business, games..) Where is it most used.?
I like ACL/PC a lot. LispWorks for Windows might also be worth looking
at, altho I don't know if an evaluation version is available yet.
I get the same reaction from colleages, tho it's usually more of an
odd look, or perhaps a question like, "Are people still using Lisp?",
as if I'd suggested using COBOL. People still use COBOL, but I've not
yet met anyone who didn't hate it. This may be why people assume that
Lisp is no good: It's old, therefore we must hate it - surely? It's
hard to prove this is wrong without showing people something.
> Keep in mind that I'm new to programming, It was not my intention to
> offend. I figured since I had questions about Lisp, this would be the
> place to ask. I'm trying to make a somewhat informed decision on the
> direction of what I hope to be a new career.
No problem. Much tougher questions have been asked here, and many of
them have been asked by C++ programmers with no interest in Lisp.
It's been a little easier since 1995, so I suspect that most of them
are now hassling the Java people instead. ;)
I hope that Lisp can help you, but it might take a while to get into
it. Some people never do. However, if you feel unhappy with C/C++,
then you'll have more than a chance.
Good luck, whatever you do.
--
<URL:http://www.wildcard.demon.co.uk/> You can never browse enough
Martin Rodgers | Programmer and Information Broker | London, UK
Please remove the "nospam" if you want to email me.
"Patrick Kemp" <········@qadas.com> writes:
> First, what kind of a language is Lisp? I'm looking for an objective
> answer on some strengths and weaknesses, not only on the language itself,
> but on it's uses. I'm not looking for any language bashing. Just some
> honest answers from professionals.
I don't think an objective assessment of a programming language can
exist; there are too many personal preferences involved and there are
too many different programming tasks. Here's my personal opinion:
There are several dialects of Lisp. The most common ones these days
seem to be Scheme and Common Lisp. While sharing many important
features these languages have quite different aims. From the
definition of Scheme (R4RS):
"Programming languages should be designed not by piling feature on top
of feature, but by removing the weaknesses and restrictions that make
additional features appear necessary. Scheme demonstrates that a very
small number of rules for forming expressions, with no restrictions on
how they are composed, suffice to form a practical and efficient
programming language that is flexible enough to support most of the
major programming paradigms in use today."
The small size of Scheme has some obvious advantages (easier to learn,
formal semantics defined etc.), furthermore it is easy to define your
own language extensions to make programming in the large possible.
However this is also one of the main disadvantages of Scheme: If you
pick two arbitrary libraries from the net chances are that they use
different package concepts, that each has its custom made object
system and so on.
There are a number of good free Scheme environments available; you'll
find pointers in the FAQ. At least two Scheme to C compilers (Gambit
and Stalin) exist. There are several Scheme interpreters that can be
used as extension languages for programs written in other languages.
Common Lisp on the other hand is a very large language, sometimes not
as elegant as Scheme, maybe somehow daunting for the beginner. But
you can rely on almost every feature that you'll need for your
programming task being there in the language, something that I really
like when implementing large systems. Common Lisp offers a wealth of
iteration constructs, packages, conditions and an object system
already defined in the standard.
There are a number of good free Common Lisp environments available;
the MIT CL compiler is one of the finest compilers that I've ever used
and delivers executables that are in most cases competitive with C
programs, at least if you don't make extensive use of the Common Lisp
Object System (CLOS).
There are some commercial Lisp environments available, again you might
want to check the FAQ for vendor addresses.
But apart from the differences, what is the commonality between these
two languages? Both have a "functional flair" although they are not
purely functional languages like e.g. Haskell is. This means that
programs in Lisp will often use recursion where imperative languages
would use iteration (i.e. while or for loops).
[Rant mode on:]
Please note that this has no a priori performance penalty since most
modern compilers can transform many recursive calls into iterative
constructs (this is referred to as "this compiler is properly tail
recursive"). However the myth that recursion is inherently
ineffective still persists in the programming community and
unfortunately it is in part kept alive by stupid examples of the
functional programming community themselves. Can anybody stop
textbook authors and lecturers from presenting an exponential
implementation of Fibonacci numbers as first example of recursion? At
least without mentioning that this implementation is plain stupid?
Can anybody forbid presenting implementations of quicksort with
quadratic complexity as examples that show the superiority of
functional languages? At least without a warning that the program
should be written in a different manner for a real implementation? No?
Well..., ok, then not.
[Rant mode off]
"Functional flair" also means that functions are "first class values";
they can be passed as arguments to functions and they can be returned
as arguments from functions, they can be assigned to variables and
they can be stored in data structures. This is related to, but much
more powerful and convenient, than function pointers in C.
The type systems of Scheme and Common Lisp are quite different from
the type system that you probably know from C: in Lisp types are
associated with values, not with the variables that happen to hold
them. This gives you considerable freedom but some people claim that
a stricter type system allows you to detect errors in your program
earlier.
Then the most striking feature of Lisp for everybody looking at a Lisp
program for the first time, the syntax. Lisp's syntax is very simple,
basically it has no syntax at all. Some people like this, others
don't, but in any case you won't have problems remembering operator
precedences, whether to put commas or semicolons as separators into
for statements...
Some strenghts and weaknesses in brief outlines:
* CL and Scheme are very flexible and powerful languages.
* The are good for building abstractions and therefore large systems.
* There are very good (free and commercial) development environments
for Lisp.
* With a good compiler well written Lisp programs can be as fast as
programs written in less powerful languages.
* Good compilers exist, but the freely available CL compilers don't
allow you to deliver small standalone executables. The commercial
compilers do, but are quite expensive.
* It is easy to write hopelessly inefficient programs in Lisp if you
don't know what you are doing, much more so than in most other
languages.
* The Lisp runtime takes care of memory management and garbage
collection.
> My other question to all of you Lisp programmers is Why did you choose
> Lisp, Given all of the different languages out there?
This question is much easier. Why do I program in Lisp?
a) Why don't I use C/C++?
Because I need less time to write programs in Common Lisp than in
C(++). (I don't know whether this is true for everybody but the
experience seems to be rather common. And given the much higher level
of abstraction of Lisp compared to C(++) it is not really surprising.)
Because I don't need to spend a lot of time coding around deficiencies
in the language and its libraries. I am thinking about overflowing
integers, buffers of fixed length and other rather common errors in
C(++) programs that are sometimes difficult to detect or fix.
In my experience programs written in Lisp are often more robust than
programms written in C because the Lisp system does a lot of things
automatically that you'd have to do yourself in C. Even if it is
possible to do all the error checking yourself it gets boring and
often complicated and so many C programs are quite fragile when
presented with unexpected input. All right, I am overgeneralizing
here.
And most of all because programming in Lisp is more fun than
programming in other languages.
b) Why don't I use some of the more "modern" programming languages?
This is mostly a matter of taste or, if you will, of prejudice. I
like the type system of Lisp and the flexibility it allows me while
developing programs. And the object system of Common Lisp fits quite
well to my way of thinking about problems . And I like the simple
syntax of Lisp. Oh yes, and the dynamic development environments.
(I have to admit that when a usable Dylan compiler will be delivered I
will think about switching to Dylan as my main programming language.)
> I have just received the Allegro CL starter kit and was pretty excited. I
> mentioned this to some of the engineers at work. (I'm a network support
> tech, but work around some software engineers) and the more or less told me
> I would be wasting my time as Lisp and Smalltalk were dead. Now, these are
> C++ programmers, so I understand there will be some bias. However, it
> brings up a question of What could I expect as a Lisp programmer? Who
> needs them (Scientific, business, games..) Where is it most used.?
People who claim that Lisp and Smalltalk are dead are in my experience
mostly people who have never used one of those languages; I know very
few programmers who have written at least one significant program in
C(++) and one in Lisp or another modern functional language and who
prefer C over Lisp. Actually I know no such programmer, but this may
be due to the fact that (unfortunately) I don't know many programmers
who have written more than toy programs in functional languages.
I don't know what the career opportunities are for Lisp programmers or
whether there is such a thing as a typical job for Lisp guys; see the
Lisp-FAQ part 1-7 for the LISP-JOBS mailing list. The archive address
given there is ftp.cs.cmu.edu:/user/ai/jobs/lisp/.
Sorry for this very long post.
tc
--
Matthias Hoelzl (··@gauss.muc.de)
"Patrick Kemp" <········@qadas.com> writes:
> First, what kind of a language is Lisp? I'm looking for an objective
> answer on some strengths and weaknesses, not only on the language itself,
> but on it's uses. I'm not looking for any language bashing. Just some
> honest answers from professionals.
I don't think an objective assessment of a programming language can
exist; there are too many personal preferences involved and there are
too many different programming tasks. Here's my personal opinion:
There are several dialects of Lisp. The most common ones these days
seem to be Scheme and Common Lisp. While sharing many important
features these languages have quite different aims. From the
definition of Scheme (R4RS):
"Programming languages should be designed not by piling feature on top
of feature, but by removing the weaknesses and restrictions that make
additional features appear necessary. Scheme demonstrates that a very
small number of rules for forming expressions, with no restrictions on
how they are composed, suffice to form a practical and efficient
programming language that is flexible enough to support most of the
major programming paradigms in use today."
The small size of Scheme has some obvious advantages (easier to learn,
formal semantics defined etc.), furthermore it is easy to define your
own language extensions to make programming in the large possible.
However this is also one of the main disadvantages of Scheme: If you
pick two arbitrary libraries from the net chances are that they use
different package concepts, that each has its custom made object
system and so on.
There are a number of good free Scheme environments available; you'll
find pointers in the FAQ. At least two Scheme to C compilers (Gambit
and Stalin) exist. There are several Scheme interpreters that can be
used as extension languages for programs written in other languages.
Common Lisp on the other hand is a very large language, sometimes not
as elegant as Scheme, maybe somehow daunting for the beginner. But
you can rely on almost every feature that you'll need for your
programming task being there in the language, something that I really
like when implementing large systems. Common Lisp offers a wealth of
iteration constructs, packages, conditions and an object system
already defined in the standard.
There are a number of good free Common Lisp environments available;
the MIT CL compiler is one of the finest compilers that I've ever used
and delivers executables that are in most cases competitive with C
programs, at least if you don't make extensive use of the Common Lisp
Object System (CLOS).
There are some commercial Lisp environments available, again you might
want to check the FAQ for vendor addresses.
But apart from the differences, what is the commonality between these
two languages? Both have a "functional flair" although they are not
purely functional languages like e.g. Haskell is. This means that
programs in Lisp will often use recursion where imperative languages
would use iteration (i.e. while or for loops).
[Rant mode on:]
Please note that this has no a priori performance penalty since most
modern compilers can transform many recursive calls into iterative
constructs (this is referred to as "this compiler is properly tail
recursive"). However the myth that recursion is inherently
ineffective still persists in the programming community and
unfortunately it is in part kept alive by stupid examples of the
functional programming community themselves. Can anybody stop
textbook authors and lecturers from presenting an exponential
implementation of Fibonacci numbers as first example of recursion? At
least without mentioning that this implementation is plain stupid?
Can anybody forbid presenting implementations of quicksort with
quadratic complexity as examples that show the superiority of
functional languages? At least without a warning that the program
should be written in a different manner for a real implementation? No?
Well..., ok, then not.
[Rant mode off]
"Functional flair" also means that functions are "first class values";
they can be passed as arguments to functions and they can be returned
as arguments from functions, they can be assigned to variables and
they can be stored in data structures. This is related to, but much
more powerful and convenient, than function pointers in C.
The type systems of Scheme and Common Lisp are quite different from
the type system that you probably know from C: in Lisp types are
associated with values, not with the variables that happen to hold
them. This gives you considerable freedom but some people claim that
a stricter type system allows you to detect errors in your program
earlier.
Then the most striking feature of Lisp for everybody looking at a Lisp
program for the first time, the syntax. Lisp's syntax is very simple,
basically it has no syntax at all. Some people like this, others
don't, but in any case you won't have problems remembering operator
precedences, whether to put commas or semicolons as separators into
for statements...
Some strenghts and weaknesses in brief outlines:
* CL and Scheme are very flexible and powerful languages.
* The are good for building abstractions and therefore large systems.
* There are very good (free and commercial) development environments
for Lisp.
* With a good compiler well written Lisp programs can be as fast as
programs written in less powerful languages.
* Good compilers exist, but the freely available CL compilers don't
allow you to deliver small standalone executables. The commercial
compilers do, but are quite expensive.
* It is easy to write hopelessly inefficient programs in Lisp if you
don't know what you are doing, much more so than in most other
languages.
* The Lisp runtime takes care of memory management and garbage
collection.
> My other question to all of you Lisp programmers is Why did you choose
> Lisp, Given all of the different languages out there?
This question is much easier. Why do I program in Lisp?
a) Why don't I use C/C++?
Because I need less time to write programs in Common Lisp than in
C(++). (I don't know whether this is true for everybody but the
experience seems to be rather common. And given the much higher level
of abstraction of Lisp compared to C(++) it is not really surprising.)
Because I don't need to spend a lot of time coding around deficiencies
in the language and its libraries. I am thinking about overflowing
integers, buffers of fixed length and other rather common errors in
C(++) programs that are sometimes difficult to detect or fix.
In my experience programs written in Lisp are often more robust than
programms written in C because the Lisp system does a lot of things
automatically that you'd have to do yourself in C. Even if it is
possible to do all the error checking yourself it gets boring and
often complicated and so many C programs are quite fragile when
presented with unexpected input. All right, I am overgeneralizing
here.
And most of all because programming in Lisp is more fun than
programming in other languages.
b) Why don't I use some of the more "modern" programming languages?
This is mostly a matter of taste or, if you will, of prejudice. I
like the type system of Lisp and the flexibility it allows me while
developing programs. And the object system of Common Lisp fits quite
well to my way of thinking about problems . And I like the simple
syntax of Lisp. Oh yes, and the dynamic development environments.
(I have to admit that when a usable Dylan compiler will be delivered I
will think about switching to Dylan as my main programming language.)
> I have just received the Allegro CL starter kit and was pretty excited. I
> mentioned this to some of the engineers at work. (I'm a network support
> tech, but work around some software engineers) and the more or less told me
> I would be wasting my time as Lisp and Smalltalk were dead. Now, these are
> C++ programmers, so I understand there will be some bias. However, it
> brings up a question of What could I expect as a Lisp programmer? Who
> needs them (Scientific, business, games..) Where is it most used.?
People who claim that Lisp and Smalltalk are dead are in my experience
mostly people who have never used one of those languages; I know very
few programmers who have written at least one significant program in
C(++) and one in Lisp or another modern functional language and who
prefer C over Lisp. Actually I know no such programmer, but this may
be due to the fact that (unfortunately) I don't know many programmers
who have written more than toy programs in functional languages.
I don't know what the career opportunities are for Lisp programmers or
whether there is such a thing as a typical job for Lisp guys; see the
Lisp-FAQ part 1-7 for the LISP-JOBS mailing list. The archive address
given there is ftp.cs.cmu.edu:/user/ai/jobs/lisp/.
Sorry for this very long post.
tc
--
Matthias Hoelzl (··@gauss.muc.de)
In article <··············@gauss.muc.de>, ··@gauss.muc.de (Matthias Hoelzl
(tc)) wrote:
> The small size of Scheme has some obvious advantages (easier to learn,
> formal semantics defined etc.), furthermore it is easy to define your
> own language extensions to make programming in the large possible.
I can't see why the latter is a result of the small size of Scheme.
> There are a number of good free Common Lisp environments available;
> the MIT CL compiler is one of the finest compilers that I've ever used
> and delivers executables that are in most cases competitive with C
> programs, at least if you don't make extensive use of the Common Lisp
> Object System (CLOS).
You are talking about the CMU CL compiler?
> Then the most striking feature of Lisp for everybody looking at a Lisp
> program for the first time, the syntax. Lisp's syntax is very simple,
> basically it has no syntax at all.
This is wrong. Many Lisp systems have a lot of syntax. Most
of the syntactic sugar is being written with macros.
> * Good compilers exist, but the freely available CL compilers don't
> allow you to deliver small standalone executables. The commercial
> compilers do, but are quite expensive.
Around $600 for Macs and PCs.
> b) Why don't I use some of the more "modern" programming languages?
>
This is second time that I hear about "more "modern" programming languages".
What languages are you talking about? Languages with defined
semantics like Scheme, verified implementations like some Scheme
systems, reflective languages like CLOS?
--
http://www.lavielle.com/~joswig/
In article <················@news.sydney.apana.org.au>,
····@gco.apana.org.au wrote:
> >> b) Why don't I use some of the more "modern" programming languages?
> >>
> >
> >This is second time that I hear about "more "modern" programming languages".
> >What languages are you talking about? Languages with defined
> >semantics like Scheme, verified implementations like some Scheme
> >systems, reflective languages like CLOS?
>
> Haskell, ML, Miranda
> Eiffel, Java, Objective C , C++
> Beta , Ada95.
Huh?
In what way are these languages more *modern* than Common Lisp?
In what way do these languages now support concepts provided by
Common Lisp (macros, reflection, dynamic objects,
flexible syntax, first class functions, incremental compilation,
object oriented condition handling, logical pathnames, ...).
Some of those languages you list don't even support higher-order
functions.
--
http://www.lavielle.com/~joswig/
"Patrick Kemp" <········@qadas.com> writes:
>
>
> I realize that career wise, C/C++ is probably the language to master. I
> base this on the number of jobs offered to c/c++ programmers in my local
> paper. Unfortunately I don't like C. (Which is why I started to work with
> Delphi.) I suppose as an independent programmer, it really doesn't matter
> what language I use, but I don't plan on being an independent, at least not
> right away
Even if you will be writing C/C++ the rest of your life learning Lisp
is worthwile. You will be thinking in different terms and this may be
very useful.
······@lavielle.com (Rainer Joswig) writes:
> In article <··············@gauss.muc.de>, ··@gauss.muc.de (Matthias Hoelzl
> (tc)) wrote:
>
> > The small size of Scheme has some obvious advantages (easier to learn,
> > formal semantics defined etc.), furthermore it is easy to define your
> > own language extensions to make programming in the large possible.
>
> I can't see why the latter is a result of the small size of Scheme.
I was unclear. I should have written: The small size of Scheme has
some obvious advantages [...]. Some small languages are only useful
for teaching. This is not the case with Scheme, because it is easy...
> > There are a number of good free Common Lisp environments available;
> > the MIT CL compiler is one of the finest compilers that I've ever used
> > and delivers executables that are in most cases competitive with C
> > programs, at least if you don't make extensive use of the Common Lisp
> > Object System (CLOS).
>
> You are talking about the CMU CL compiler?
Of course. Sorry, I was still thinking about whether to mention MIT
Scheme (the "UnCommon Lisp" as it is called in the manual) a paragraph
above as an example for a Scheme with some very useful extensions.
> > Then the most striking feature of Lisp for everybody looking at a Lisp
> > program for the first time, the syntax. Lisp's syntax is very simple,
> > basically it has no syntax at all.
>
> This is wrong. Many Lisp systems have a lot of syntax. Most
> of the syntactic sugar is being written with macros.
I think we disagree what "a lot of syntax" means. Could we agree that
Lisp has a very uniform syntax (which would better express what I was
trying to say with "no syntax")? Of course there are a lot of
syntactic constructs, you can create your own syntax and yes, even
some syntactic constructs from CLTL (like the loop facility) are quite
complicated. But if the syntactic complexity of your Lisp code is a
problem you are doing something wrong, IMO.
> > * Good compilers exist, but the freely available CL compilers don't
> > allow you to deliver small standalone executables. The commercial
> > compilers do, but are quite expensive.
>
> Around $600 for Macs and PCs.
>
> > b) Why don't I use some of the more "modern" programming languages?
>
> This is second time that I hear about "more "modern" programming languages".
> What languages are you talking about? Languages with defined
> semantics like Scheme, verified implementations like some Scheme
> systems, reflective languages like CLOS?
I think this is the only time in my post that I wrote about more
"modern" languages and I deliberately put it in quotes.
I am mainly thinking about functional languages that appeared later
than Lisp, like ML (ca. 1977) or Haskell (1987) and are thus more
"modern". I was neither implying any kind of superiority of one
language over the other nor any kind of feature that makes a language
"modern" nor do I equate "modern" == "better".
It is however the case that one sometimes hears the statement that the
development of (functional) programming languages proceeded from the
impure and "weakly typed" Lisp to more or less pure functional
languages with some variant of Hindley/Milner type system. This is
why I pointed out two things I like about Lisp, namely the type system
and CLOS (there doesn't seem to be a generally accepted way of
integrating pure languages and object oriented programming).
(The other time I talk about "Lisp or another modern functional
language" because I think that Lisp is still quite alive and kicking.
One might argue whether Lisp is a functional language, though.)
Sorry for the inaccuracies in my previous posting (MIT CL, how
embarrassing...)
tc
--
Matthias Hoelzl (··@gauss.muc.de)
In article <··············@gauss.muc.de>, ··@gauss.muc.de (Matthias Hoelzl
(tc)) wrote:
> > > Then the most striking feature of Lisp for everybody looking at a Lisp
> > > program for the first time, the syntax. Lisp's syntax is very simple,
> > > basically it has no syntax at all.
> >
> > This is wrong. Many Lisp systems have a lot of syntax. Most
> > of the syntactic sugar is being written with macros.
>
> I think we disagree what "a lot of syntax" means. Could we agree that
> Lisp has a very uniform syntax (which would better express what I was
> trying to say with "no syntax")?
I would even disagree here. You can read the Lisp statements
with READ, but that doesn't help you a bit. To analyze it
you still need a code walker. The code walker needs
knowledge about the language (constants, function calls,
macro expressions, special forms, variables).
That Lisp has parentheses around some expressions doesn't
remove the syntax magically.
with-separator-group (stream)
directional-light-node stream :direction direction
perspective-camera-node stream
:position camera-position
:orientation camera-orientation
:focal-distance 10.84)
with-separator-group (stream)
material-node stream :diffuse-color diffuse-color1
translation-node* stream 3 0 1
sphere-node stream :radius 2.3
with-separator-group (stream)
material-node stream :diffuse-color diffuse-color2
transform-node stream
:translation translation
:rotation rotation
cube-node stream
One could define a syntax that let's code look like the above
(indentation defines the grouping).
Lisp usually just chooses to have an external representation
that uses its list notation:
(with-separator-group (stream)
(directional-light-node stream :direction direction)
(perspective-camera-node stream
:position camera-position
:orientation camera-orientation
:focal-distance 10.84)
(with-separator-group (stream)
(material-node stream :diffuse-color diffuse-color1)
(translation-node* stream 3 0 1)
(sphere-node stream :radius 2.3))
(with-separator-group (stream)
(material-node stream :diffuse-color diffuse-color2)
(transform-node stream
:translation translation
:rotation rotation)
(cube-node stream)))
> I am mainly thinking about functional languages that appeared later
> than Lisp, like ML (ca. 1977) or Haskell (1987)
Common Lisp appeared in the early 80s. CLOS a bit later.
ANSI Common Lisp has been approved Dec 8th 1994.
> and are thus more
> "modern".
Not even more "recent" (-> ANSI Common Lisp).
> It is however the case that one sometimes hears the statement that the
> development of (functional) programming languages proceeded from the
> impure and "weakly typed" Lisp to more or less pure functional
> languages with some variant of Hindley/Milner type system. This is
> why I pointed out two things I like about Lisp, namely the type system
> and CLOS (there doesn't seem to be a generally accepted way of
> integrating pure languages and object oriented programming).
Practical Lisps most of the time have been *multi-paradigm*
languages. Common Lisp for example directly supports
procedural, functional and object oriented programming.
There are a lot of extensions to Common Lisp that
will integrate just perfectly into the language
to provide static typing, logic, rules, non-determinism,
parallel programming, ...
> (The other time I talk about "Lisp or another modern functional
> language" because I think that Lisp is still quite alive and kicking.
> One might argue whether Lisp is a functional language, though.)
You can program in a functional style in Lisp. This is one of
the main advantages of Lisp.
> Sorry for the inaccuracies in my previous posting (MIT CL, how
> embarrassing...)
;-)
--
http://www.lavielle.com/~joswig/
······@lavielle.com (Rainer Joswig) writes:
> In article <··············@gauss.muc.de>, ··@gauss.muc.de (Matthias Hoelzl
> (tc)) wrote:
>
> > > > Then the most striking feature of Lisp for everybody looking at a Lisp
> > > > program for the first time, the syntax. Lisp's syntax is very simple,
> > > > basically it has no syntax at all.
> > >
> > > This is wrong. Many Lisp systems have a lot of syntax. Most
> > > of the syntactic sugar is being written with macros.
> >
> > I think we disagree what "a lot of syntax" means. Could we agree that
> > Lisp has a very uniform syntax (which would better express what I was
> > trying to say with "no syntax")?
>
> I would even disagree here. You can read the Lisp statements
> with READ, but that doesn't help you a bit. To analyze it
> you still need a code walker. The code walker needs
> knowledge about the language (constants, function calls,
> macro expressions, special forms, variables).
>
> That Lisp has parentheses around some expressions doesn't
> remove the syntax magically.
>
> [snip]
>
> One could define a syntax that let's code look like the above
> (indentation defines the grouping).
> Lisp usually just chooses to have an external representation
> that uses its list notation:
>
> [snip]
I don't consider your first example to be non-uniform syntax. And I
did not claim: "you need no code walker for analyzing Lisp". Please
consider the context in which I wrote the original post. Would you
tell somebody who asks: "First, what kind of a language is Lisp?"
--"Well, if you want to learn Lisp, be prepared to spend your time
learning a lot of non-uniform syntax." This is not the way Lisp looks
to me.
> > I am mainly thinking about functional languages that appeared later
> > than Lisp, like ML (ca. 1977) or Haskell (1987)
>
> Common Lisp appeared in the early 80s. CLOS a bit later.
> ANSI Common Lisp has been approved Dec 8th 1994.
The final draft of Standard ML was approved in May 1985, a more recent
standard was released a few months ago if memory serves me right; the
report on the programming language Haskell (Version 1.3) is dated
May 1, 1996 with another revision in preparation; the
C++-ANSI-Standard isn't approved yet. We are getting silly here.
> > and are thus more
> > "modern".
>
> Not even more "recent" (-> ANSI Common Lisp).
Lisp appeared early on the stage and evolved into some eminently
useful dialects. Some other languages appeared later and have since
disappeared. Some other languages have appeared later and are
probably here to stay, just as Lisp is. Most languages that are
around for some time are evolving. So what?
Please reread the next paragraph on why I used the word "modern" in
this context. Please note that I put it in quotes in the original
statement. Please note that I was explaining why I use Lisp and not
one of the other languages.
>> It is however the case that one sometimes hears the statement that
>> the development of (functional) programming languages proceeded from
>> the impure and "weakly typed" Lisp to more or less pure functional
>> languages with some variant of Hindley/Milner type system. This is
>> why I pointed out two things I like about Lisp, namely the type system
>> and CLOS (there doesn't seem to be a generally accepted way of
>> integrating pure languages and object oriented programming).
tc
--
Matthias Hoelzl (··@gauss.muc.de)