Re: Chestnut Lisp translator
D Herring
> While I was browsing the archives I fell on this: "Chestnut Lisp-to-C
> translator" was a $12,000 commercial Common Lisp to C translator.
> Chestnut went out of business (product was too expesnsive), and the
> rights to the product have been bought by a major software vendor
> (Oracle?). But some customers had the right to get the source code
> when Chestnut went out of business"... That was in 1991... Do you
> think that now after almost 20 yrs this is available for the public
> somewhere or all that work and effort was wasted?
I would consider it a loss. Is there any reason to believe it was
better than ECL is today?
- Daniel
kod...@eurogaran.com
type A) Those generating C code that is human-readable.
type B) Those generating C code that is not very easily readable by
humans.
Whereas both types are justifiable by the convenience to use C as a
"high level assembler"
the need for type A is not easily justifiable, since if what you want
is human readability
you have already the original lisp code. It will always be better than
ANY equivalent C code in that aspect.
A good translator of type B is GNU GLISP.
ddd
the sources are on sourceforge.
In the documentation chestnut is mentioned as a precursor for thinlisp.
Hope this helps.
On Sun, 11 Jan 2009 10:44:35 -0800 (PST), Francogrex <fra...@grex.org>
jos...@corporate-world.lisp.de
I think these are two very different systems. Thinlisp was developed
inhouse
at Gensym to run their real-time expert system. It lacks quite a bit
from Common Lisp.
The Lisp-2-C translator was an independent implementation. From the
old Lisp FAQ.
Lisp-to-C Translator translates Common Lisp into human-readable ANSI
C. Release 3.2 supports such features as CLOS, the condition
system,
Lisp type declaration heeding, and Mac, Windows, and Alpha
compatibility. (Release 3.0, introduced in 1992, eliminated the old
requirement that the garbage collector had to be called explicitly).
Works with Lucid, Symbolics, Allegro, Harlequin and MCL. It costs
$11,995. Write to: Chestnut Software, Inc., 2 Park Plaza, Suite
205,
Boston, MA, 02116, call 617-542-9222, fax 617-542-9220, or e-mail
Mr.
Kenneth J. Koocher <k...@chestnut.com>.
The main ideas were that it could translate complex Lisp applications
and that the translated code could be maintained by C programmers.
It seems that the German research project Verbmobil used it, too:
The only realistic choice we had was
to translate our parser with Chestnut Inc.'s Lisp-
to-C-Translator automatically into C. Since the
Lisp functions library is available in C source, we
could insert the necessary Solaris parallelisation
and synchronization primitives into key positions
of the involved fnnctions.
Here is another paragraph about it:
Lisp-to-C Translator - Translates applications written in Common
Lisp
directly into clean, human-readable, compact, efficient, and
highly-portable C code. Supports all of the First Edition of
Guy
Steele's "Common Lisp: The Language", and much of the Second
Edition,
including a complete CLOS implementation. The Translator was
the
collective effort of a team of world-class developers, including
several members of the ANSI Common Lisp standards committee
(X3J13).
It includes a self-contained run-time library, written in C,
which can
be used or marketed separately; a run-time memory manager;
several
very fast garbage collectors; and a comprehensive test suite.
The
code is well-written and extensively documented.
The generated code can be combined with native code written in
either C or C++, and can be delivered even on platforms which
provide
no native Lisp compiler. Configuration switches permit the
creation
of applications with tiny footprints. The product also provides
a
unique way to visualize the effects of optimizations (such as
declarations), even for applications which will be delivered on
a
standard Lisp run-time system. The product is actively used to
deliver widely-distributed industrial applications in the U.S.
and abroad.
ddd
"... In 1993 Gensym changed again to a different Lisp to C translator made
by Chestnut Software. This produced an additional 40% decrease in size, and
a significant improvement in performance. The ThinLisp translator is a
philosophical descendent of the Chestnut translator, though ThinLisp was
written from scratch."
But there was also until a few years ago a CL system called Eclipse:
"Elwood Corp. (Eclipse)
Eclipse is a complete ANSI Common Lisp, made available to programmers in two
ways:
* A traditional top-level Lisp listener.
* A C library containing all ANSI functions and data types. The
functions use normal C naming and argument passing conventions.
In addition, the Eclipse compiler can be used to generate human-readable C
code which uses the library. The generated functions and variables use
normal C naming and argument passing conventions.
Complete applications can be written in C or translated from Lisp to C using
the Eclipse compiler. Object files are then produced using any C compiler
and linked to the Eclipse library to produce stand-alone executables which
can be run without the top-level Lisp listener."
However that system is gone also it seems.
wbr...@panix.com
translator, which covered a small subset of Common Lisp, for in-house
use in 1989. Chestnut was working on A.I.-flavored applications,
particularly a natural-language engine, that we wanted to code in Lisp
-- but had to deliver in C, mostly for memory compactness. Since the
C code would at some point be maintained, and there were Lisp-agnostic
C programmers on the project, we wanted the code to be as clean and
clear as possible. Soon after, we discovered that there was a
significant demand for the translator itself.
The company's encounter with the market, beginning in 1990, was quite
a shock: We assumed that customers would adapt their Lisp code to use
our Common Lisp subset, to explicitly garbage-collect, etc. We wound
up implementing all of CLtL2, including CLOS, and created several
translation modes, one of which was fully automatic; local variables
were saved on a stack so that they could be recognized as roots for
garbage collection. A good number of large Lisp projects were coming
to fruition at about the same time, and had to deliver in C for
various reasons: portability; to work with multilingual teams;
performance and memory footprint; and general fears about Lisp as a
language. Many of them became Chestnut customers.
The project benefited greatly from the work of a small group of Lisp
internals experts, including several members of the ANSI Lisp (X3J13)
standards committee, which had codified Common Lisp only recently.
Kim Barrett wrote all of the CLOS translator; Sandra Loosemore
designed the translation engine and optimization framework; Jonathan
Rees wrote much of the runtime library; he and James O'Toole, both MIT
grad students, wrote several very fast garbage collectors, did a good
deal of optimizing, and worked on portability; Andy Latto, Dmitry
Nizhegorodov, Jeff Brodie, and Rick Harris made major contributions.
Jim Allard, then with Gensym Corp., had built a translator for
Gensym's use that Chestnut eventually replaced, and already had a lot
of good engineering ideas that were incorporated into the product.
The translator was a pricey product: the company provided customers a
good deal of support, and for customers who wanted readable C code
that was also fast, compact, and portable, didn't really have any
competitors. Our customers' best alternative was usually to spend
several million dollars, and a year or two, reimplementing their
applications in C. So Chestnut was able to find a niche, which grew
as the company expanded its marketing efforts and as the amount of pre-
sale engineering work it needed to perform for each customer
drastically fell.
The company went out of business in 1995, several years after I left.
The reason wasn't really price; it was that the board didn't contain
enough members who understood Chestnut's customers, mostly research
groups, or its products, which were highly technical. Unable to
effectively balance engineering, support, and marketing, even on a
small scale, the company lost sales it could have made, alienated some
early customers who were among its strongest "success story"
references, and failed to form relationships with Lisp vendors and
other natural allies. Over time, these defects became fatal.
Its technology was sold to Oracle for use on a single development
project. It's possible that an approach by the Lisp community would
persuade Oracle to release the software as open source. Or Gensym,
now based in Texas, might consent to its release. It would take some
legwork and luck. In its favor are the passage of time and the re-
emergence of Lisp as a platform.
The closest heir to Chestnut's technology seems to be Thinlisp, about
which more above. Led by Jim Allard and Ben Hyde, it starts with some
of the same design philosophy as Chestnut and focuses on the
engineering virtues that, in the developers' experience, were most
critical to a successful "develop in Lisp, deploy in C" engine.
> > and abroad.- Hide quoted text -
>
> - Show quoted text -
vsedach
forgot who it was; the email conversation now lies in an archive that
I still have but don't know where), and as I recall he said the only
obstacle to releasing Eclipse as OSS/FS was the time needed to clean
up the code to make it suitable for public release.
I have a version of Thinlisp with a few tweaks to make it build and
some notes up on my website (http://vsedach.googlepages.com/
code.html), which is not on the Thinlisp SF page. Another CL-to-C
translator that is currently publicly available is CLiCC (http://
www.informatik.uni-kiel.de/~wg/clicc.html), although I've not used it.
Vladimir
Chun Tian (binghe)
> From the thinlisp docs:
>
> "... In 1993 Gensym changed again to a different Lisp to C translator made
> by Chestnut Software. This produced an additional 40% decrease in size, and
> a significant improvement in performance. The ThinLisp translator is a
> philosophical descendent of the Chestnut translator, though ThinLisp was
> written from scratch."
Gensym G2 [1] still use the Chestnut Lisp to C translator today, and
all source code of Chestnut lives in Gensym G2's SVN repository. I saw
them recently.
--binghe
jos...@corporate-world.lisp.de
How are they doing nowadays? I read some time ago that they were
bought
and the maintenance of G2 was to be transferred to India and that the
original maintainers were leaving...
Pascal J. Bourguignon
Well perhaps they're just selling the completed product.
Fact is they're not hiring anybody.
Perhaps that's the doom of Lisp: companies using lisp develop their
product without having to hire armies of programmers, complete them,
and don't need to further hire armies of programmers to maintain them.
They just sell them and live happy forever after.
--
__Pascal Bourguignon__
cartercc
wrote:
> Perhaps that's the doom of Lisp: companies using lisp develop their
> product without having to hire armies of programmers, complete them,
> and don't need to further hire armies of programmers to maintain them.
> They just sell them and live happy forever after.
I have given some thought to the lives of programming technologies.
They can be divided into various classes.
One class would be composed of languages like COBOL and (to some
extent Ada) that came out of a coordinated effort for a particular
purpose, and that still live on in those domains that need them, such
as banking and defense.
One class would be composed of languages like C, Perl, and PHP, that
were created by individuals to solve a particular problem and spread
widely because of the inherent utility of the languages.
One class would be composed of languages like Java, VB, and (possibly)
Erlang, that have a strong tie-in with a particular vendor (Sun,
Microcsoft, Ericsson) and have proved useful beyond that tie-in.
Lisp seems to be in a separate category altogether. Why hasn't it
achieved success as a commonly used technology? I don't think the
reason given above is a sufficient answer. My answer is that people
tend to use what is useful to them, and if a technology isn't useful
on some level, it won't get used.
Obviously, individuals find Lisp useful. I asked the question, and
have had a rude experience on c.l.l. by asking what Lisp is used for.
(Check the archives.) However, it's also obvious that no critical mass
of individuals find Lisp useful for anything. If they had found Lisp
useful, it would have made an impact on the on businesses seeking to
hire developers, i.e., there are multiple times as many jobs
advertised on the job boards for Ada and Cobol and Fortran than Lisp.
To achieve a critical mass of followers, ISTM that Lisp needs a Killer
App. What would be the nature of this Killer App? I can see two
answers, both related to the fact that the world seems to be adopting
a web-centralized mentality. The two answers can be seen as part of
the thin-client/fat-client debate. In the web context, a thin-client
solution would be one that performs the heavy lifting server side and
delivers the finished product to the client, like PHP, JSP, ASP,
traditional CGI-like technologies like Perl, Python, and Ruby ... dare
I mention Google Apps? A fat-client solution relies on the client to
do much of the work, like Flash, Flex, the coming Microsoft efforts
like Silverlight and Moonlight, JavaScript, etc.
I can see two developments for a Lisp Killer App in the web arena. The
first, using Graham's 'Average' essay, is a Lisp application for
server side apps. I don't mean a framework like Struts or Rails or
Django, but a full fledged programming language that's capable of
delivering the goods and that has a subset of vocabularies that are
easy for a typical web developer to absorb and use. (I'm not being
critical of web developers - just using my personal experience as an
example that web developers don't want to delve deeply into the hidden
corners of a language.)
The second development would be a browser based (or client based)
technology, using elisp as a metphor, that would compete with
JavaScript, Flash, Flex, etc.
Either of both of these developments could AND WOULD occur if Lisp
were capable of delivering the goods - some combination of utility and
learnibility. I don't doubt that Lisp /could/ be used for these kinds
of applications. I doubt that Lisp could be made 'easy' enough for an
average developer to use effectively. For example, I know people who
have leveraged JSP and JavaScript as an entry to Java, and who have
leveraged VBS and VBA as an entry to VB. I know from personal
experience that you only need to learn a small subset of Perl to reach
90% usefulness. Is it possible to program effectively in Lisp
learning, say, 5% of the language?
Besides all of that, delivering apps is simple in Java, C/C++, and in
the .NET platform. Delivering Lisp apps seems to be some sort of
arcania that even those who know how to do it can't easily describe.
This is simply my two cents worth from an outsider who is making an
effort to learn Lisp. I don't intend to offend anyone by these
comments.
CC
jos...@corporate-world.lisp.de
...
> I can see two developments for a Lisp Killer App in the web arena. The
> first, using Graham's 'Average' essay, is a Lisp application for
> server side apps. I don't mean a framework like Struts or Rails or
> Django, but a full fledged programming language that's capable of
> delivering the goods and that has a subset of vocabularies that are
> easy for a typical web developer to absorb and use. (I'm not being
> critical of web developers - just using my personal experience as an
> example that web developers don't want to delve deeply into the hidden
> corners of a language.)
There are already simpler languages and solutions available
that can be used by average developers.
> The second development would be a browser based (or client based)
> technology, using elisp as a metphor, that would compete with
> JavaScript, Flash, Flex, etc.
Again, simpler solutions exist.
...
Lisp has seen some success in widely different areas:
* as an implementation or extension language for CAD systems
* as an implementation language for symbolic computing applications
(computer algebra systems, theorem provers, logic languages,
rule-based systems)
* as a implementation language for AI applications with
significant symbolic computing parts (knowledge representation,
case-based reasoning, diagnosis, planning,
computer aided tutoring, ...)
* as an extension language in text/document processing applications
(Emacs, InterLeaf Publisher, DSSSL, ...)
* as an implementation language in algorithmic composition
* as an implementation language in natural language processing
(machine translation, ...)
* as a prototyping tool
Most of the above requires 'brains' and has a significant
part of non-standard programming (it is not about writing web pages or
dialog screens). That you don't know these application
areas or that you don't work in them, does not mean
they don't exist. You also won't see the applications advertised
as 'contains traces of Lisp'.
For example I just saw that a security training application for
the Frankfurt Airport is written in Lisp. You would never
know that and for the users it is not visible. Another application
that you will never heard of is used by the
Spirit and Opportunity Mars rover operations team since
the last five years. These applications exist and are written
to solve very special problems. The security training application
for example contains a Lisp-written framework for keeping
track of the learning progress.
> Besides all of that, delivering apps is simple in Java, C/C++, and in
> the .NET platform. Delivering Lisp apps seems to be some sort of
> arcania that even those who know how to do it can't easily describe.
Really? Each implementation manual describes this. Typically
you call a simple function to dump an executable and
give a startup function as an argument. After a few seconds
you have an executable that you can hand out. Sometimes
people claim that things are difficult, but if you look
closer it is totally easy.
cartercc
world.lisp.de> wrote:
> There are already simpler languages and solutions available
> that can be used by average developers.
Thank you for proving my point, which was that the reason Lisp isn't
used widely is because it doesn't have a popular application domain
and lacks a facility of use combined with good efficacy, i.e., can be
leveraged by the 'average' developer to do a lot with a little effort.
> Lisp has seen some success in widely different areas:
>
> * as an implementation or extension language for CAD systems
<snip>
Yes, yes, yes. You don't have to beat a dead horse. All your examples
miss the point.
> Most of the above requires 'brains' and has a significant
> part of non-standard programming (it is not about writing web pages or
> dialog screens).
Which is a different question entirely. A difficult technology
designed to attack difficult problems ABSOLUTELY has a place. Don't
misunderstand what I wrote as saying that a non-simple tool has no
place in the tool box. The question is, 'Why isn't Lisp more widely
used?' I think it's pretty evident that the answer is twofold: (1) it
requires a substantial investment in time and effort to learn enough
to be useful, and (2) the problems it's good at are not trivial
problems.
> > Besides all of that, delivering apps is simple in Java, C/C++, and in
> > the .NET platform. Delivering Lisp apps seems to be some sort of
> > arcania that even those who know how to do it can't easily describe.
>
> Really? Each implementation manual describes this. Typically
> you call a simple function to dump an executable and
> give a startup function as an argument. After a few seconds
> you have an executable that you can hand out. Sometimes
> people claim that things are difficult, but if you look
> closer it is totally easy.
Well, I don't know, because I've never done it. Right now, I'm
struggling with the basics. After a while, I might agree with you, but
right now I plead ignorance.
Essentially, my point is that Lisp is not PHP. You may say, 'Thank
God!' However, it seems to me that IF PEOPLE ARE CONCERNED ABOUT THE
'UNPOPULARITY' IF LISP, they need to think about the things I
mentioned.
As a last point, I'd like to mention that a person can be quite
effective using Perl, after having learned only a small subset of the
language. A recurring theme on c.l.l. is, 'Why don't more people use
Lisp?' One common answer is, 'Because we are the elite.' I'll buy that
-- elites serve a useful purpose, and it's nice to achieve absolute
mastery of a skill. However, it seems to me that an outreach effort
based on a popular application with a small, simple subset of Lisp
might help the Lisp community. Many people play softball and play the
guitar, and the fact that only a very few reach the highest levels of
athleticism and musicianship doesn't deter the great unwashed from
enjoying amateur games or performances. Same thing with Perl as an
example from the development world. The fact that there is a
legitimate place for Masters Of Lisp isn't necessarily inconsistent
with what I suggested.
CC
Pascal J. Bourguignon
> On Feb 7, 3:29 pm, "jos...@corporate-world.lisp.de" <jos...@corporate-
> world.lisp.de> wrote:
>> Most of the above requires 'brains' and has a significant
>> part of non-standard programming (it is not about writing web pages or
>> dialog screens).
>
> Which is a different question entirely. A difficult technology
> designed to attack difficult problems ABSOLUTELY has a place. Don't
> misunderstand what I wrote as saying that a non-simple tool has no
> place in the tool box. The question is, 'Why isn't Lisp more widely
> used?' I think it's pretty evident that the answer is twofold: (1) it
> requires a substantial investment in time and effort to learn enough
> to be useful, and (2) the problems it's good at are not trivial
> problems.
We prefer to summary it by saying "lisp requires brains".
> Essentially, my point is that Lisp is not PHP. You may say, 'Thank
> God!' However, it seems to me that IF PEOPLE ARE CONCERNED ABOUT THE
> 'UNPOPULARITY' IF LISP, they need to think about the things I
> mentioned.
But we are not concerned about the 'unpopularity' of lisp.
--
__Pascal Bourguignon__
jos...@corporate-world.lisp.de
...
> Which is a different question entirely. A difficult technology
> designed to attack difficult problems ABSOLUTELY has a place. Don't
> misunderstand what I wrote as saying that a non-simple tool has no
> place in the tool box. The question is, 'Why isn't Lisp more widely
> used?' I think it's pretty evident that the answer is twofold: (1) it
> requires a substantial investment in time and effort to learn enough
> to be useful, and (2) the problems it's good at are not trivial
> problems.
Right.
...
> Essentially, my point is that Lisp is not PHP. You may say, 'Thank
> God!' However, it seems to me that IF PEOPLE ARE CONCERNED ABOUT THE
> 'UNPOPULARITY' IF LISP, they need to think about the things I
> mentioned.
I'm not sure if it is 'unpopular' and if that matters at all.
You probably heard of the German car company Porsche?
How many people in your town are driving one? Probably
only few. How many in your town can afford one?
Also few. Are they popular? Based on numbers of sold
cars, no. Is the goal of Porsche to sell a mass
market car? No. But are they popular? They
are probably the most profitable car company in the world
(even if you forget last year, where they
made more profit than revenue (!)). They have an engineering
center, where other companies let them develop
cars, motors, etc. Are they popular? I'd say
so. Do they need a mass market strategy to survive?
Somehow not. They are one of the older car companies
around and one of the healthiest.
> As a last point, I'd like to mention that a person can be quite
> effective using Perl, after having learned only a small subset of the
> language. A recurring theme on c.l.l. is, 'Why don't more people use
> Lisp?' One common answer is, 'Because we are the elite.'
That's a wrong answer. The correct answer is, because Lisp
is in some places complex and often can be replaced with simpler
tools.
I don't think Lisp developers are 'the elite'. It is
true that there are a bunch of very good ones, but there
are lots of brilliant software developers who are using
other languages and tools.
> I'll buy that
> -- elites serve a useful purpose, and it's nice to achieve absolute
> mastery of a skill. However, it seems to me that an outreach effort
> based on a popular application with a small, simple subset of Lisp
> might help the Lisp community.
That's a common theme heard for about 40 years in the Lisp community.
You are not the first one to tell this. The results
to create a simple Lisp were languages like Logo, Scheme, ...
and some others. A somewhat popular application with a
simple Lisp and some true Lisp flavor is Emacs.
To expand on the Porsche theme, the VW Käfer is a 'simpler'
Porsche. It was once widely used.
Selling a simpler, more affordable car can help
Porsche? Only up to a point, beyond that it
hurts the brand. The beetle was a VW, not a Porsche.
My advice: learn Lisp if you a) have an intellectual benefit
from it and/or b) have an application where it can be usefully
be applied as a tool. Otherwise just skip it and use
something else. Really. There is nothing bad about it.
It is a choice one has to make. I like and use Lisp because of
both a) and b).
Don't think so much about popularity. As a software ENGINEER
you should think about all aspects of your problem domain,
but the main task is to SELECT and APPLY technology to solve
problems.
Chun Tian (binghe)
> On 7 feb, 11:09, "Chun Tian (binghe)" <binghe.l...@gmail.com> wrote:
>
> > GensymG2 [1] still use theChestnutLispto C translator today, and
> > all source code ofChestnutlives inGensymG2's SVN repository. I saw
> > them recently.
>
> And the direct link to the SVN repository is located at:???
> (there is no link to that repository from the gensymG2 web site you
> referred to)
Sorry, it's a private SVN repository.
--binghe
cartercc
one has it's own culture. One of the peculiarities of c.l.l. is a
concern over the fact that the Lisp user community is perceived to be
vanishingly small, and that Lisp should be evangelized. If you don't
believe me, read the last 100 threads in c.l.l. and you'll find
several of these kinds of threads. This was what I was responding to.
On Feb 8, 4:34 am, "jos...@corporate-world.lisp.de" <jos...@corporate-
world.lisp.de> wrote:
> I'm not sure if it is 'unpopular' and if that matters at all.
It doesn't matter in any real sense, and 'unpopularity' is certainly
the wrong word. Do you know what the right word is?
> You probably heard of the German car company Porsche?
<snip>
> Somehow not. They are one of the older car companies
> around and one of the healthiest.
This may be true for all fields of endeavor -- the number of people/
groups/enterprises at the very top is small compared to the total
number. Take golf: how many Tiger Woods are there? The difference is
that most people aspire to own a Porsche or play golf like Tiger
Woods? How many people have a burning desire to learn Lisp? Your
analogy is good, but misses the point, because most developers (at
least the ones that I know, and I know a representative number) think
Lisp is a joke, if they have even heard of Lisp.
> > Lisp?' One common answer is, 'Because we are the elite.'
>
> That's a wrong answer. The correct answer is, because Lisp
> is in some places complex and often can be replaced with simpler
> tools.
> I don't think Lisp developers are 'the elite'. It is
> true that there are a bunch of very good ones, but there
> are lots of brilliant software developers who are using
> other languages and tools.
Again, 'elite' is certainly the wrong word. I couldn't think of a
better one at the time, and I can't now.
<snip>
> My advice: learn Lisp if you a) have an intellectual benefit
> from it and/or b) have an application where it can be usefully
> be applied as a tool. Otherwise just skip it and use
> something else. Really. There is nothing bad about it.
> It is a choice one has to make. I like and use Lisp because of
> both a) and b).
>
> Don't think so much about popularity. As a software ENGINEER
> you should think about all aspects of your problem domain,
> but the main task is to SELECT and APPLY technology to solve
> problems.
I'm interested in Lisp because some very accomplished people say that
it's worthwhile to know and use, but so far (for me) this is only
hearsay.
On the other hand, a great many people say that 'popular' languages
like Java, C#, Perl (take your pick out of a dozen) are worthwhile to
know and use.
I've been paying attention to the job market for about ten years now,
and I've yet to see any announcement in my area (the SE US) referring
to Lisp. This tells me that employers in my area are not looking for
Lispers.
Which is more right: the wisdom of the enlightened few or the wisdom
of the masses?
This is a rhetorical question, and I don't expect an answer. I realize
that good arguments exist for both sides.
CC
Tamas K Papp
> has it's own culture. One of the peculiarities of c.l.l. is a concern
> over the fact that the Lisp user community is perceived to be
> vanishingly small, and that Lisp should be evangelized. If you don't
> believe me, read the last 100 threads in c.l.l. and you'll find several
> of these kinds of threads. This was what I was responding to.
There are always people who perceive things differently. The question
is whether I want to care about their opinion. I certainly don't give
a damn about people who know very little of either Lisp or computer
languages in general, yet are always trying to "save Lisp" by
introducing some idiotic feature or evangelize instead of writing
code.
> good, but misses the point, because most developers (at least the ones
> that I know, and I know a representative number) think Lisp is a joke,
> if they have even heard of Lisp.
It is their loss, why should I care? Perhaps you are in the company
of idiots, and for you they are "representative".
For me, they are not, thank God.
> I'm interested in Lisp because some very accomplished people say that
> it's worthwhile to know and use, but so far (for me) this is only
> hearsay.
Too bad for you - you should be interested in Lisp because _you_ find
it useful or interesting or ..., not because other people are saying
those things. It is useful to listen to advice, but that will only
provide a starting point for deciding what you should look at. Once
you start looking at Lisp, you can evaluate those claims yourself,
usually very quickly.
> I've been paying attention to the job market for about ten years now,
> and I've yet to see any announcement in my area (the SE US) referring to
> Lisp. This tells me that employers in my area are not looking for
> Lispers.
>
> Which is more right: the wisdom of the enlightened few or the wisdom of
> the masses?
>
> This is a rhetorical question, and I don't expect an answer. I realize
> that good arguments exist for both sides.
This is an idiotic question, and that's why you should not expect an
answer.
You are trying to decide whether to learn Lisp by considering the
outcome of some popularity contest. Why can't you decide it YOURSELF?
At some point, you have to reach a conclusion, and you are the best
judge of your own needs. But instead of learning CL (or any other
language you like), you are yakking here about some vague abstract
points and wasting your time.
Tamas
jos...@corporate-world.lisp.de
> I lurk in a number of usegroups, technology and otherwise, and each
> one has it's own culture. One of the peculiarities of c.l.l. is a
> concern over the fact that the Lisp user community is perceived to be
> vanishingly small, and that Lisp should be evangelized. If you don't
> believe me, read the last 100 threads in c.l.l. and you'll find
> several of these kinds of threads. This was what I was responding to.
The general impression I sense is that the Lisp community is slowly
(!)
growing. It's commercial importance is much less than it was
in the 80s though.
> This may be true for all fields of endeavor -- the number of people/
> groups/enterprises at the very top is small compared to the total
> number. Take golf: how many Tiger Woods are there? The difference is
> that most people aspire to own a Porsche or play golf like Tiger
> Woods?
I don't aspire to drive a Porsche and I don't aspire to play
golf like Tiger Woods. Still I see a Porsche from time to
time and can appreciate the engineering.
> How many people have a burning desire to learn Lisp? Your
> analogy is good, but misses the point, because most developers (at
> least the ones that I know, and I know a representative number) think
> Lisp is a joke, if they have even heard of Lisp.
There are lots of different opinions.
> I'm interested in Lisp because some very accomplished people say that
> it's worthwhile to know and use, but so far (for me) this is only
> hearsay.
That makes no sense to me. My advice: don't waste your time.
You have invested some time, but you still don't see a real
use? Then skip it and do something else.
It's like an old composer influential people recommend.
Bach? Telemann? Buxtehude?
You will find lots of people that tell you Bach is
the greatest composer of all time (Yet, Telemann
was much more popular at his time.). I have friends
who can't listen to an organ piece by Bach for more than
a few seconds. Bach was already seen as an oldfashioned
composer when he was living. BUT! There are
people that are still playing his music and also still
people listening to it. The music is not in the top ten of
the charts. He is dead, his music is oldfashioned,
Schönberg was much more revolutionary.
Modern music does not use the idea of a Fuge anymore.
Are those people listening to Bach 'idiots'? 'Fanaticals'?
Are they the 'elite'? I'd say it is bullshit
to ask these questions. If you don't like Bach's music,
if you don't enjoy it and it has no purpose for you,
then just give the recordings and books about Bach
to someone else and keep listening to, um,
some other music. Try some Olivier Messiaen for example.
(Posting Britney Spears lyrics to a Bach newsgroup makes
little sense, btw.)
> On the other hand, a great many people say that 'popular' languages
> like Java, C#, Perl (take your pick out of a dozen) are worthwhile to
> know and use.
No doubt about that.
> I've been paying attention to the job market for about ten years now,
> and I've yet to see any announcement in my area (the SE US) referring
> to Lisp. This tells me that employers in my area are not looking for
> Lispers.
>
> Which is more right: the wisdom of the enlightened few or the wisdom
> of the masses?
You should answer that question yourself and act accordingly.
Paul Wallich
> On Feb 8, 2:53 pm, cartercc <carte...@gmail.com> wrote:
>
>> I lurk in a number of usegroups, technology and otherwise, and each
>> one has it's own culture. One of the peculiarities of c.l.l. is a
>> concern over the fact that the Lisp user community is perceived to be
>> vanishingly small, and that Lisp should be evangelized. If you don't
>> believe me, read the last 100 threads in c.l.l. and you'll find
>> several of these kinds of threads. This was what I was responding to.
>
> The general impression I sense is that the Lisp community is slowly
> (!)
> growing. It's commercial importance is much less than it was
> in the 80s though.
Its commercial visibility, at least. Lisp was very hot in the 80s, and
attracted a fairly amount of venture capital, but it wasn't a big
commercial deal. Not a lot of people coded in it or ran
revenue-producing apps (as they do now).
(I think it was at the Philadelphia AAAI meeting in 1986 that Esther
Dyson commented, not entirely in fun, that the corporate party budget
for the conference was as large as the industry's cumulative profits to
date.)
paul
jos...@corporate-world.lisp.de
That could be. There was lots of money burned.
Symbolics had revenues of 114 Million Dollars in 1986 and made a loss
of 10 Million dollars. They had around one thousand employees in that
year. The whole AI business was estimated at almost one billion
dollar - some part (how much? a third?, half?) of that went into Lisp
companies or
companies that sold Lisp based hard/software (Symbolics, Xerox, TI,
DEC, SUN, Intellicorp, Inference, Carnegie Group, ....).
Prices were quite high - this makes up for a small
volume. A Lisp Machine often cost 100 thousand dollars. Some machines
Symbolics sold were much more expensive. Expert System tools like
KEE were in the range of 50000 dollars - just the software.
Much of the bubble was created by funding from the military.
Even after discounts the machines and the software was expensive.
See this price calculation from 1985: http://d116.com/lispm/3675xmas.gif
$185400 for the machine. Minus 55.500 discount. Price: $129900.
For a machine with 474 MB Disk, 8MB Memory, FPA, 24bit Color
That's hardware plus OS. Software like TCP/IP, some graphics stuff,
etc. were 'lavered products' and had to be bought extra. The
graphics software was $50000 per module (model, animate, render, ...)
at some point. The 3675 is the right machine on this picture:
http://lispm.dyndns.org/lisp/pics/3600family.jpg
(around 54 MB RAM max, up to eight disks, 14 expansion slots).
What about today? Hardware is no longer sold (probably only very few
exceptions). Leaves us with software licenses (new/maintenance) and
consulting.
It could be that the software has a higher
commercial importance for the using companies, but the core
Lisp business is much smaller - my guess.
cartercc
> > good, but misses the point, because most developers (at least the ones
> > that I know, and I know a representative number) think Lisp is a joke,
> > if they have even heard of Lisp.
>
> It is their loss, why should I care? Perhaps you are in the company
> of idiots, and for you they are "representative".
Not 'representative' but 'existent.' I know a respected professor of
many years at a university with a well respected software engineering
program that has the opinion that Lisp users ought to be shot. His
poison? .NET and Microsoft C++/CLI. At least he has heard of Lisp. My
point was that the typical developer in my world has never heard of
Lisp.
> > I'm interested in Lisp because some very accomplished people say that
> > it's worthwhile to know and use, but so far (for me) this is only
> > hearsay.
>
> Too bad for you - you should be interested in Lisp because _you_ find
> it useful or interesting or ..., not because other people are saying
> those things.
That's way to harsh. Without exception every language I have learned,
and I have about a dozen notches in my gun handle so far, I've learned
because someone else thought that they would be useful. I have an idea
that you learned Lisp because someone else thought it was important
and turned you on to it.
> You are trying to decide whether to learn Lisp by considering the
> outcome of some popularity contest.
You haven't been paying attention. I have said no such thing. Eric
Raymond said that learning Lisp would make you a better programmer.
Paul Graham credited Lisp for making him millions of dollars. Both
Raymond and Graham are far more knowledgeable and experienced that I
am. Why shouldn't I pay attention to what they say?
> Why can't you decide it YOURSELF?
That is EXACTLY what I'm doing.
CC
cartercc
world.lisp.de> wrote:
> > I'm interested in Lisp because some very accomplished people say that
> > it's worthwhile to know and use, but so far (for me) this is only
> > hearsay.
>
> That makes no sense to me. My advice: don't waste your time.
> You have invested some time, but you still don't see a real
> use? Then skip it and do something else.
Yeah, but you have to learn something well enough to use it before you
can evaluate it. That's like learning to play a scale on a musical
instrument and then giving it up because you don't see yourself making
music. Masters of anything (and everything) will tell you that the
ration of perspiration to inspiration is about 10 to 1, if not 100 to
1.
> It's like an old composer influential people recommend.
> Bach? Telemann? Buxtehude?
> You will find lots of people that tell you Bach is
> the greatest composer of all time (Yet, Telemann
> was much more popular at his time.). I have friends
> who can't listen to an organ piece by Bach for more than
> a few seconds. Bach was already seen as an oldfashioned
> composer when he was living. BUT! There are
> people that are still playing his music and also still
> people listening to it. The music is not in the top ten of
> the charts. He is dead, his music is oldfashioned,
> Schönberg was much more revolutionary.
> Modern music does not use the idea of a Fuge anymore.
> Are those people listening to Bach 'idiots'? 'Fanaticals'?
> Are they the 'elite'? I'd say it is bullshit
> to ask these questions. If you don't like Bach's music,
> if you don't enjoy it and it has no purpose for you,
> then just give the recordings and books about Bach
> to someone else and keep listening to, um,
> some other music. Try some Olivier Messiaen for example.
I play Bach, and have played the organ in various churches, and think
that the St. Matthew Passion is the greatest achievement of the human
mind. My current pastor (after I played a piece by Bach) laid down the
rule: NO MORE BACH! He likes the insipid little praise choruses that
are popular now.
> > Which is more right: the wisdom of the enlightened few or the wisdom
> > of the masses?
>
> You should answer that question yourself and act accordingly.
The answer is that both are equally right and equally wrong.
CC
Raffael Cavallaro
> I have an idea
> that you learned Lisp because someone else thought it was important
> and turned you on to it.
Since lisp is not a mainstream language you are more likely to find
that those who learn it do so because they themselves find it
interesting and useful not so much because others led them to it or
made them learn it. That model of language acquisition is more common
of widely popular languages like c, c++, java, c#, perl, python, ruby,
etc.
--
Raffael Cavallaro, Ph.D.
Tamas K Papp
> Not 'representative' but 'existent.' I know a respected professor of
> many years at a university with a well respected software engineering
> program that has the opinion that Lisp users ought to be shot. His
> poison? .NET and Microsoft C++/CLI. At least he has heard of Lisp. My
> point was that the typical developer in my world has never heard of
> Lisp.
The fact that a CS professor has _heard_ of Lisp is not a major
achievement by any standard. And developers with at least basic CS
education will surely have heard of Lisp. In any case, I don't see
the point of counting who did.
If someone in this field hasn't even heard about Lisp (or Haskell,
Prolog, Forth, etc), then there are major gaps in their education.
These are the very same people who keep wondering why they only get
work as code monkeys and complain about their jobs being outsourced to
distant lands. They are the manual laborers of the industry, and
their contribution is priced accordingly. I fail to see why you are
placing so much weight on their opinion, but this is your problem, not
mine.
>> You are trying to decide whether to learn Lisp by considering the
>> outcome of some popularity contest.
>
> You haven't been paying attention. I have said no such thing. Eric
> Raymond said that learning Lisp would make you a better programmer. Paul
> Graham credited Lisp for making him millions of dollars. Both Raymond
> and Graham are far more knowledgeable and experienced that I am. Why
> shouldn't I pay attention to what they say?
You should, and then make a quick decision and get down to business
and either start learning the language or ignore it altogether.
>> Why can't you decide it YOURSELF?
>
> That is EXACTLY what I'm doing.
Nope. Archives show that you have been posting to CLL since at least
October. You should have had plenty of time to form your own opinion,
yet you are still just yakking about what so-and-so said concerning
Lisp and what the average developer knows etc.
Tamas
Raffael Cavallaro
> I play Bach, and have played the organ in various churches, and think
> that the St. Matthew Passion is the greatest achievement of the human
> mind.
You clearly trust your own judgement over that of the herd with regard
to music. After all, Bach is hardly popular, even in churches
apparently (how sad, by the way).
How much more important is it that you trust your own judgement in
programming which is your life's work? If you trust your own judgement
- which appears to be pretty good given that you like Bach immensely
and are attracted to lisp ;^) - and simply make a good faith effort to
learn lisp - not to complain about the warts of the language, or
speculate on why it's not popular and what might be done about it -
when you run into problems you will get a great deal of useful
assistance here.
I understand your desire for the security of using a popular language.
The price of having good judgement is that sometimes it compels one to
stand apart from the security of the crowd.
At the end of the day, you must trust your own judgement, not because
of some macho sense of self-reliance, but because you have no choice -
even if you take someone else's word on what to do, it is *you* who
decided that other person is worth listening to.
Trust your judgement;learn and use lisp without worrying what the herd
is doing.
regards,
Ralph
--
Raffael Cavallaro, Ph.D.
Mark Wooding
> I think it's pretty evident that the answer is twofold: (1) it
> requires a substantial investment in time and effort to learn enough
> to be useful, and (2) the problems it's good at are not trivial
> problems.
I'd disagree with (2). I think Lisp works just fine at trivial
problems, though it might be considered heavyweight. But there are lots
of other tools which are also good at trivial problems, and it's very
frequently the case that one of them -- and not always the same one --
is better than Lisp.
I will agree with you that Lisp really shines at dealing with nontrivial
problems, though.
> As a last point, I'd like to mention that a person can be quite
> effective using Perl, after having learned only a small subset of the
> language.
I'd say that one can do useful things in Lisp without knowing very much;
the problem is more that people don't. The first chapter of SICP builds
some interesting programs using a very small corner of Scheme, but it
certainly has a different flavour from the corner of Perl that one
learns first.
(Probably. I tend to learn languages largely by reading their reference
manuals, following newsgroups, and reading about their history, by a
kind of osmosis. This seems very different from the way that other
people learn programming languages.)
> A recurring theme on c.l.l. is, 'Why don't more people use Lisp?' One
> common answer is, 'Because we are the elite.' I'll buy that -- elites
> serve a useful purpose, and it's nice to achieve absolute mastery of a
> skill.
Lisp is good at all sorts of stuff, from small hacks to really big and
complicated systems. But trying to explain this to newcomers is
difficult. Basically, for simple stuff, Lisp's surface differences
stand out from other languages and dissuade newcomers; we can explain
why these differences are related to advantages, but you need to get
further into the language to really appreciate them. The conversation
usually goes like this.
OLD HACKER: Lisp rocks. For all sorts of stuff from lowly hacks to
enormous systems.
NEWCOMER: But it's got all of this weird syntax. Too many parentheses
and stuff.
OLD HACKER: The parentheses are part of what makes macros work, and
macros make Lisp mighty. Let me show you...
NEWCOMER: Woah, that's too complicated. I'll go learn Java instead.
And so is lost another promising mind.
Basically, the surface differences seem to discourage casual interest;
but those surface differences are an essential ingredient to Lisp's
power. I don't know how to solve this problem, if indeed it is a
problem to be solved at all rather than merely a state of affairs to be
tolerated.
> However, it seems to me that an outreach effort based on a popular
> application with a small, simple subset of Lisp might help the Lisp
> community.
We called it the small, simple subset `Scheme'. It grew a life of its
own, and stopped being small, or simple (and seems to be trying not to
be a Lisp either[1]).
> Many people play softball and play the guitar, and the fact that only
> a very few reach the highest levels of athleticism and musicianship
> doesn't deter the great unwashed from enjoying amateur games or
> performances.
Hey, I write Lisp and play the guitar. (People paid me to do the
latter, but not the former. Weird, huh?)
[1] Most Lisps describe the evaluation semantics in terms of evaluating
Lisp objects of various kinds -- particularly symbols and lists.
The Scheme reports, on the other hand, seem to go to great lengths
to distance Scheme programs from Scheme values.
-- [mdw]
Mark Wooding
writes:
> It's like an old composer influential people recommend.
> Bach? Telemann? Buxtehude?
> You will find lots of people that tell you Bach is
> the greatest composer of all time
[etc.]
I like that.
Maybe it's just me, but Lisp's homoiconicity seems to have a lot in
common with the sorts of things that Hofstadter was writing about in
GEB, so the analogy with Bach isn't entirely inappropriate. I must
admit that, although I greatly enjoy listening to Bach, I do spend
rather more time listening to loud metal bands...
-- [mdw]
Rob Warnock
+---------------
| > Then skip it and do something else.
|
| Yeah, but you have to learn something well enough to use it before you
| can evaluate it. That's like learning to play a scale on a musical
| instrument and then giving it up because you don't see yourself making
| music. Masters of anything (and everything) will tell you that the
| ration of perspiration to inspiration is about 10 to 1, if not 100 to 1.
Hah! You have just made the very point so many people have been trying to
get you to see, and yet you *still* don't see it!! Yes, you're absolutely
correct: "You have to learn something well enough to use it before you
can evaluate it." And in the case of programming languages, the only way
you can learn one *is* to use it. [If that sounds recursive, well, it is.
You learn a little, you try to use what you've learned. That shows you
the next thing you need to learn, then you try using that. And so on.]
You *CANNOT* learn a language well enough to evaluate it without actually
programming at least a handful of *significant* (not toy) tasks in it,
any more than you can learn to play Bach without ever touching a keyboard.
Reading/discussing/criticizing/comparing musics is not *playing* music.
So *GET MOVING*!! As Kenny is so fond of saying [quite correctly, albeit
bluntly], "Shut up & code."
And then when you have real problems with your Lisp code, I assure you
that if you come back here and present what you've tried so far and say
what you expected it to do and also what it *did* do [including the exact
error message(s), if any, from your implementation] and why you think it
failed to meet your expectation, you will find this community more than
willing to help you with your code: helpful in explaining obscure nuances
of the ANSI Common Lisp Standard; helpful in suggesting better Lisp "style";
helpful in suggesting alternative algorithms.
Until then, however, do not be surprised if you continue to be treated
as a troll...
-Rob
-----
Rob Warnock <rp...@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
cartercc
> Hah! You have just made the very point so many people have been trying >
You evidently haven't followed this thread. The comments I made were
in response to Pascal's post of February 7. That's all.
> You *CANNOT* learn a language well enough to evaluate it without actually
> programming at least a handful of *significant* (not toy) tasks in it,
> any more than you can learn to play Bach without ever touching a keyboard.
Um ... that's what I said, isn't it.
CC
cartercc
> cartercc <carte...@gmail.com> writes:
> > I think it's pretty evident that the answer is twofold: (1) it
> > requires a substantial investment in time and effort to learn enough
> > to be useful, and (2) the problems it's good at are not trivial
> > problems.
>
> I'd disagree with (2). I think Lisp works just fine at trivial
> problems, though it might be considered heavyweight. But there are lots
> of other tools which are also good at trivial problems, and it's very
> frequently the case that one of them -- and not always the same one --
> is better than Lisp.
This isn't like firing up the 18 wheeler to run to the store to pick
up a gallon of milk and a loaf of bread. The trivial problems I deal
with are data transformation problems, and I can do that easily in a
few lines of Perl. For a graphical application, you can churn out one
quickly in Visual Studio using one of the .NET languages.
> I'd say that one can do useful things in Lisp without knowing very much;
> the problem is more that people don't.
This was what I was trying to get at in my original post in this
thread. I think that the culture of Lisp is different from other
languages. I have a friend, a COBOL programmer who has a responsible
position with a large, publicly traded financial services company. I
asked him one day about how he dealt with problematic code. He said
that he rewrote the block in assembly. !!! He's an old school guy that
started by using assembly for 'trivial' problems and is still
comfortable doing that. I have a feeling that almost any language can
be used for quick and dirty programming, but the culture of Lisp works
against that.
> Lisp is good at all sorts of stuff, from small hacks to really big and
> complicated systems. But trying to explain this to newcomers is
> difficult. Basically, for simple stuff, Lisp's surface differences
> stand out from other languages and dissuade newcomers; we can explain
> why these differences are related to advantages, but you need to get
> further into the language to really appreciate them. The conversation
> usually goes like this.
But I don't think that the surface differences are the real drawback.
People say that Lisp is difficult to teach, but I don't really think
that's true. It may be that the PROBLEM DOMAINS that Lisp addresses
are difficult, and that the learning materials focus on that. I've
attempted some of the trivial Chapter 2 and 3 level stuff (like
converting a dollar amount of money into change or converting
different metrics), and that's not hard at all. The logic is identical
regardless of the language you use.
> Basically, the surface differences seem to discourage casual interest;
> but those surface differences are an essential ingredient to Lisp's
> power. I don't know how to solve this problem, if indeed it is a
> problem to be solved at all rather than merely a state of affairs to be
> tolerated.
That's why I suggested a simple problem domain. Using Lisp as a stand
in for PHP or JavaScript can't be much more difficult that PHP or
JavaScript. It might be possible to increase the visibility of Lisp in
the manner. Whether it would be a good idea seems to have generated a
large amount of head in this thread.
> > Many people play softball and play the guitar, and the fact that only
> > a very few reach the highest levels of athleticism and musicianship
> > doesn't deter the great unwashed from enjoying amateur games or
> > performances.
>
> Hey, I write Lisp and play the guitar. (People paid me to do the
> latter, but not the former. Weird, huh?)
The idea is that doing something poorly can be worthwhile, that you
don't have to be proficient to derive enjoyment and pleasure from
doing an activity. I know people who get a lot of mileage from simply
copying (stealing) and modifying JavaScript code. In the Java world,
the largest majority are simply journeyman programmers and occupy just
the bottom rungs of the Java ladder, but they support the Java gurus
that exist in every organization. Is there an equivalent in the Lisp
world?
CC
Dimiter "malkia" Stanev
> thread. I think that the culture of Lisp is different from other
> languages. I have a friend, a COBOL programmer who has a responsible
> position with a large, publicly traded financial services company. I
> asked him one day about how he dealt with problematic code. He said
> that he rewrote the block in assembly. !!! He's an old school guy that
> started by using assembly for 'trivial' problems and is still
> comfortable doing that. I have a feeling that almost any language can
> be used for quick and dirty programming, but the culture of Lisp works
> against that.
Lots of Common Lisp implementations have ways of approaching the
assembler, or the bytecode in someway - off course you won't find much
of it in the spec.
Check for LAP (GOOGLE IT!) Or take a look at Corman Lisp source code
(easier to grasp than say SBCL or OpenMCL).
Also look at this of example how to use "C" structures to your lisp:
http://www.paulgraham.com/carl.html
Yes, most likely you won't see much implementation specific common
lisp code using assembly, because most of the open source stuff wants
to be implementation independent: for example SIMD for SBCL
implementation - http://common-lisp.net/project/sb-simd/
So you, my sire, are certainly confused!
Don't forget CFFI, UFFI and many other FFI's that would help you, even
if your Lisp lacked certain assembly.
There is always a way!
Nicolas Neuss
> But I don't think that the surface differences are the real drawback.
> People say that Lisp is difficult to teach, but I don't really think
> that's true. It may be that the PROBLEM DOMAINS that Lisp addresses
> are difficult, and that the learning materials focus on that. I've
> attempted some of the trivial Chapter 2 and 3 level stuff (like
> converting a dollar amount of money into change or converting
> different metrics), and that's not hard at all. The logic is identical
> regardless of the language you use.
Chapter 2 and 3 of what? Having taught two courses using SICP, I think the
main problem of this approach is that one arrives extremely fast into
interesting but also complicated problem domains. With something like
Java, you have to learn first quite some recipes for using the IDE, for
making the compiler even accept your program, which is nasty, but gives you
some feeling of accomplishment when you have succeeded. OTOH, with
Scheme/Lisp you are in business immediately after you have defined the two
notions
(function arg1 ... argn)
(lambda (arg1 ... argn) body)
because from that point on you have the Turing-equivalent Lambda calculus
available. [Of course, noone teaches as abruptly as that, but the spirit
can be observed from the very beginning in SICP - e.g. by using
tail-recursion for iteration.] This has quite some appeal to
mathematicians but is too hard for students with little mathematical
understanding.
The remedy might be to spend more time on simple concepts and to
incorporate formal program design recipes (like in the HTDP-book on Scheme
by Felleisen et al.). But I fear that also this approach works only if
students are forced to take that Scheme course (which is not so common
anymore). Otherwise, one could do the largest part of that more extended
course equally well in another programming language, say Python, and
students will not see the reason why Lisp is used.
Nicolas
cartercc
wrote:
I've taken the 'first course' in several languages, and I've taught
the 'first course' in Perl, Java, C++, and VB. All these are basically
the same, and the basic problems sets are pretty much interchangeable.
The only exception is Java if an 'objects first' text is used.
> Having taught two courses using SICP, I think the
> main problem of this approach is that one arrives extremely fast into
> interesting but also complicated problem domains. With something like
> Java, you have to learn first quite some recipes for using the IDE, for
> making the compiler even accept your program, which is nasty, but gives you
> some feeling of accomplishment when you have succeeded. OTOH, with
> Scheme/Lisp you are in business immediately after you have defined the two
> notions
>
> (function arg1 ... argn)
> (lambda (arg1 ... argn) body)
>
> because from that point on you have the Turing-equivalent Lambda calculus
> available. [Of course, noone teaches as abruptly as that, but the spirit
> can be observed from the very beginning in SICP - e.g. by using
> tail-recursion for iteration.] This has quite some appeal to
> mathematicians but is too hard for students with little mathematical
> understanding.
Is Lisp inherently any harder to learn than any other language? I
don't think so, and I don't see any reason why it should be. Why then
does it have the reputation of being harder to learn that other
languages. One reason might be the abruptness you mention. A typical
first course only covers about a dozen chapters, and that only gives
you time for selection, iteration, variables, functions, operators,
and so on, so you feel like you have gotten quite a bit, and you can
write some fairly useful stuff. OTOH, with Lisp you cover all these
things in a week or two (as you point out) and then, BANG, you have
all the syntax and you are dealing with the logic.
Unfortunately, logic is the hardest part of programming, and in the
typical course in the languages I mentioned, you really don't have
time to cover logic. In graduate school I was a tutor in the labs, and
time after time a student would call on me for help. I'd look at what
he had written (which wasn't working) and ask him, 'What's the logic?'
Most of the time the response was a blank stare. In my experience,
logic doesn't get emphasized in the basic course, but you have to deal
with logic in Lisp.
> The remedy might be to spend more time on simple concepts and to
> incorporate formal program design recipes (like in the HTDP-book on Scheme
> by Felleisen et al.). But I fear that also this approach works only if
> students are forced to take that Scheme course (which is not so common
> anymore). Otherwise, one could do the largest part of that more extended
> course equally well in another programming language, say Python, and
> students will not see the reason why Lisp is used.
Okay, I'll ask the question. Why is Lisp used? Why use Lisp rather
than Python, or another language?
CC
cartercc
> Nope. Archives show that you have been posting to CLL since at least
> October. You should have had plenty of time to form your own opinion,
> yet you are still just yakking about what so-and-so said concerning
> Lisp and what the average developer knows etc.
>
> Tamas
Hey, Tamas, I have a full time job, taking a full load in graduate
school (I am enrolled in the PhD program in SWE), I have a family with
two small children at home, and I also have other interests. I think I
mentioned elsewhere that I was trying to learn Lisp in ten minutes a
day (and got sucker punched for making such a stupid statement.) I've
been plugging through Wilensky at about two chapters a month, and
feeling lucky to be able to do that. It's not like I have ten hours a
day of empty time to devote to learning a new language.
(Besides, not that it's any of your business, but I've been picking up
SAL for work, so I stay busy.)
Yes, I know it's a matter of priorities. I'm a member of my college
Pipe Band and like to spend some time daily practicing, which time I
guess I could use learning Lisp. So hit me over the head for making
piping a priority over Lisp.
CC
Nicolas Neuss
> Okay, I'll ask the question. Why is Lisp used? Why use Lisp rather
> than Python, or another language?
I can only answer for me personally. I am mathematician, and I use it for
my own purposes, because I find it fits to my way of thinking. I use it
for teaching, because the magic of lambda calculus and (easy) syntax
transformation is possible. Both are not there in Python.
Nicolas
Pascal J. Bourguignon
> On Feb 8, 2:59 pm, Tamas K Papp <tkp...@gmail.com> wrote:
>> Nope. Archives show that you have been posting to CLL since at least
>> October. You should have had plenty of time to form your own opinion,
>> yet you are still just yakking about what so-and-so said concerning
>> Lisp and what the average developer knows etc.
>>
>> Tamas
>
> Hey, Tamas, I have a full time job, taking a full load in graduate
> school (I am enrolled in the PhD program in SWE), I have a family with
> two small children at home, and I also have other interests. I think I
> mentioned elsewhere that I was trying to learn Lisp in ten minutes a
> day (and got sucker punched for making such a stupid statement.) I've
> been plugging through Wilensky at about two chapters a month, and
> feeling lucky to be able to do that. It's not like I have ten hours a
> day of empty time to devote to learning a new language.
>
> (Besides, not that it's any of your business, but I've been picking up
> SAL for work, so I stay busy.)
Wait to go! Leisure leads to sin.
> Yes, I know it's a matter of priorities. I'm a member of my college
> Pipe Band and like to spend some time daily practicing, which time I
> guess I could use learning Lisp. So hit me over the head for making
> piping a priority over Lisp.
You could use Common Music and indulge into music at the same time as
into Lisp! If you still want to blow into a pipe, you could hook a Midi
digital pipe into the system. http://www.music.mcgill.ca/~gary/ThePipe.html
And if you miss the walking, you could hook it on an CL loaded PDA.
--
__Pascal Bourguignon__
cartercc
wrote:
> Wait to go! Leisure leads to sin.
So does non-leisure. But as Martin Luther was reported as saying, 'Sin
bravely.'
CC
Andrew Reilly
> Is Lisp inherently any harder to learn than any other language?
Can't say, but superficially there's a big, clear difference in syntax
between the lisp family and what most programmers will have seen before:
functions are called like (f 1 2 "3") rather than f(1, 2, "3") and
arithmetic is prefix rather than infix. At that level of superficiality,
all of the languages that you mentioned (perl, java, C++ and VB) and a
bunch besides (fortran, pascal, Algol, Ada, Modula-X, and python are
essentially identical. There's not so many people programming in forth,
either, and it also doesn't fit with that collection of languages. This
superficial syntax difference might be a red-herring: anyone determined
to learn the language will have little trouble with that small change.
It might put off those who are merely idly interested, though.
Beyond that there's differences in the capabilities of basic arithmetic,
differences in object models, what ubiquitous garbage collection does to
the style of libraries and APIs (although that's becoming less of a
difference as more common languages "get it"). Different (lack of
special) syntax for accessing elements of collections is another biggie.
From my own perspective, as a newcomer to lisp, the biggest issue was
learning the new vocabulary: *everything* is called something different
from what it is in most other "popular" languages. I felt a similar
learning curve when I started with Java: I spent the first several weeks
with extremely low productivity as I pored backwards and forwards through
the library reference to find the names of the functions and objects that
I knew must be there, in order to get things done. Is it harder with
lisp? I don't think so, but it *is* a function of standard library size,
I think. Oh, and closures. They're so cool. Obviates many small uses
of structs and objects in those "other" languages. And symbols. And
quote. And then there's macros...
Maybe we need a text along the lines of "lisp for programmers from the
Fortran/Algol school", rather than texts that teach it ab initio, as is
usually the case.
Cheers,
--
Andrew
Andrew Reilly
> Okay, I'll ask the question. Why is Lisp used? Why use Lisp rather than
> Python, or another language?
I like the freedom that the extra level of abstraction and mathematical
(like) purity provides. In retrospect, every language that I used before
put constraints on the ease with which I could construct and manipulate
abstractions.
Oh, and it's a lot faster than Python, which was one of the the hooks
that got me in in the first place.
Cheers,
--
Andrew
Pascal J. Bourguignon
> From my own perspective, as a newcomer to lisp, the biggest issue was
> learning the new vocabulary: *everything* is called something different
> from what it is in most other "popular" languages.
Just a little nit pick here: it's the reverse. The other languages
called things differently from lisp. Lisp was here second (first was
fortran).
> Maybe we need a text along the lines of "lisp for programmers from the
> Fortran/Algol school", rather than texts that teach it ab initio, as is
> usually the case.
It is called "Practical Common Lisp" http://www.gigamonkeys.com/book
--
__Pascal Bourguignon__
Kaz Kylheku
> Andrew Reilly <andrew-...@areilly.bpc-users.org> writes:
>> From my own perspective, as a newcomer to lisp, the biggest issue was
>> learning the new vocabulary: *everything* is called something different
>> from what it is in most other "popular" languages.
>
> Just a little nit pick here: it's the reverse. The other languages
> called things differently from lisp. Lisp was here second (first was
> fortran).
But was it? How wrong would it be to claim that Lisp was designed on paper
first, whereas Fortran was hacked in the computer room? :)
Rob Warnock
+---------------
| r...@rpw3.org (Rob Warnock) wrote:
| > Hah! You have just made the very point so many people have been trying >
| > You *CANNOT* learn a language well enough to evaluate it without actually
| > programming at least a handful of *significant* (not toy) tasks in it,
| > any more than you can learn to play Bach without ever touching a keyboard.
|
| Um ... that's what I said, isn't it.
Yes, that's what you said. Saying isn't doing. Time to DO!
Let's see some code...
Nicolas Neuss
> But was it? How wrong would it be to claim that Lisp was designed on
> paper first, whereas Fortran was hacked in the computer room? :)
Especially, if you take into account that the foundations of Lisp (lambda
calculus) were developed theoretically in the 1930s, it is far older than
Fortran:-)
Nicolas
Kaz Kylheku
And Fortran actually stands for ``forlorn transsexual'', referring
to the fact that there was actually more than one woman on that team.
Nicolas Neuss
Kaz Kylheku <kkyl...@gmail.com> writes:
>>> But was it? How wrong would it be to claim that Lisp was designed on
>>> paper first, whereas Fortran was hacked in the computer room? :)
>>
>> Especially, if you take into account that the foundations of Lisp (lambda
>> calculus) were developed theoretically in the 1930s, it is far older than
>> Fortran:-)
>
> And Fortran actually stands for ``forlorn transsexual'', referring
> to the fact that there was actually more than one woman on that team.
OK, you win. Formulas are really very old.
Nicolas