f



Lisp vs. Common Lisp

I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
PCL.

One comment I find a lot when people talk about Lisp is that Lisp is
wonderful, but CL has a lot of problems (problems I cannot understand
due to my newbieness). Now, I don't want to learn the wrong Lisp.

What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
the particular dialect they used and fall in love with?

If this unidentified Lisp is so great, why don't they use it and avoid
all the pitfalls of CL?
0
Simon
6/12/2010 4:36:50 PM
comp.lang.lisp 16861 articles. 5 followers. Post Follow

35 Replies
1848 Views

Similar Articles

[PageSpeed] 42

On Sat, 12 Jun 2010 09:36:50 -0700, Simon wrote:

> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
> PCL.
> 
> One comment I find a lot when people talk about Lisp is that Lisp is
> wonderful, but CL has a lot of problems (problems I cannot understand

Could you perhaps give references?

> due to my newbieness). Now, I don't want to learn the wrong Lisp.

You will lose nothing by learning CL.  If you don't end up liking it,
it will be easy to switch.  Even if you get settled in one Lisp dialect,
it makes sense to explore others from time to time.

> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5, the
> particular dialect they used and fall in love with?

I guess it depends on the person making these claims.  Why don't you
ask them instead?  Or at least tell us who is making these statements.

BTW, nowadays Lisp1 is used for Lisps with a single namespace (eg 
Scheme), not for the first Lisp implementation.  So don't interpret it as 
a version number, early Lisp versions are not in practical use nowadays.

> If this unidentified Lisp is so great, why don't they use it and avoid
> all the pitfalls of CL?

Again, why don't you ask them?  Why should people on c.l.l speculate
about vague statements like this?  People like to bash other people's 
choices for no good reasons - don't be mislead by this.

People have their own preferences about Lisp dialects.  I started with
Scheme, and quickly switched to CL.  I can imagine people going the
other way, but since I don't share their preferences, I am not the
best person to speculate about their reasons.

Basically, you have three options:

1. Google for CL/Scheme/... comparisons.  There are plenty.

2. Loop up the zillion X vs Y threads in the archives.  Be warned that
some of these quickly degenerate to flamewars.

3. Pick the dialect you like best, and start coding.  Once you
understand the basic concepts, experiment with another one.

Personally, I would just go for the last option, and start learning CL
from Peter Seibel's Practical Common Lisp, available online.  But if you 
want to go for other dialects, you can ask on their forums about good 
books/intros/tutorials.

Cheers,

Tamas
0
Tamas
6/12/2010 5:03:35 PM
Simon wrote:
> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
> PCL.
> 
> One comment I find a lot when people talk about Lisp is that Lisp is
> wonderful, but CL has a lot of problems (problems I cannot understand
> due to my newbieness). Now, I don't want to learn the wrong Lisp.
> 
> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
> the particular dialect they used and fall in love with?
> 
> If this unidentified Lisp is so great, why don't they use it and avoid
> all the pitfalls of CL?


 From a still-partly-newbie:

There is no Lisp per se, nor "unidentified lisp". Lisp is a family of 
languages.

The most evident feature of CL is that it's a very big language. This 
means that it's either "bloated"/"unelegant" or 
"feature-rich"/"industrial strength", depending on the point of view.

Another thing: CL is a "lisp-2", meaning that there are separate 
namespaces for functions and values. Instead, Scheme is a "lisp-1". 
There are advantages and disadvantages, none of which should you care at 
the moment.

"Lisp 1" (without the hyphen) and "lisp 1.5", instead, refer to very 
early designs, of antiquarian interest only.

There is no wrong lisp to learn. All lisps are right. Stay with CL, it's 
fine.

gg
0
Giovanni
6/12/2010 5:11:03 PM
On 2010-06-12 17:36:50 +0100, Simon said:
> 
> One comment I find a lot when people talk about Lisp is that Lisp is
> wonderful, but CL has a lot of problems (problems I cannot understand
> due to my newbieness). Now, I don't want to learn the wrong Lisp.

I think what you are obsreving is that Lisp people like to moan, and 
complaining about the indequacies of various dialects & implementations 
is a very common way they do this.  The reasons for this are lost in 
time - however you'll fairly quickly realise that people are often 
complaining vigorously to avoid actually getting stuff done, often 
because they don't really have much idea what to do: obviously if you 
can persuade yourself that it's *Lisp* preventing you from writing the 
Great American Compiler, then you don't have to face the fact that, in 
fact, it's you.

> If this unidentified Lisp is so great, why don't they use it and avoid
> all the pitfalls of CL?

There are two very common patterns you'll see.  Firstly is the CL/other 
lisp-related-language thing, where adherents of the other sect spend a 
huge amount of time being rude about CL.  The other is "once upon a 
time, we had <implementation> which was perfect, but now it is gone, 
nothing will ever be that good again, the heroes have ridden into the 
west it is the end of an age mutter".  What they never say was that 
<implementation> was used by 6 people ever, was written in assembler on 
a machine which could address some tens of k and executed a few hundred 
thousand instructions a second, didn't have a working garbage 
collector, had only upper-case characters, used octal, had no string 
data type, no numbers greater than 48.6, and in fact on closeer 
investigation turns out never to have existed at all.

CL is just fine.

0
Tim
6/12/2010 5:29:45 PM
On Jun 13, 2:29=A0am, Tim Bradshaw <t...@tfeb.org> wrote:
> On 2010-06-12 17:36:50 +0100, Simon said:
>
>
>
> > One comment I find a lot when people talk about Lisp is that Lisp is
> > wonderful, but CL has a lot of problems (problems I cannot understand
> > due to my newbieness). Now, I don't want to learn the wrong Lisp.
>
> I think what you are obsreving is that Lisp people like to moan, and
> complaining about the indequacies of various dialects & implementations
> is a very common way they do this. =A0The reasons for this are lost in
> time - however you'll fairly quickly realise that people are often
> complaining vigorously to avoid actually getting stuff done, often
> because they don't really have much idea what to do: obviously if you
> can persuade yourself that it's *Lisp* preventing you from writing the
> Great American Compiler, then you don't have to face the fact that, in
> fact, it's you.
>
> > If this unidentified Lisp is so great, why don't they use it and avoid
> > all the pitfalls of CL?
>
> There are two very common patterns you'll see. =A0Firstly is the CL/other
> lisp-related-language thing, where adherents of the other sect spend a
> huge amount of time being rude about CL. =A0The other is "once upon a
> time, we had <implementation> which was perfect, but now it is gone,
> nothing will ever be that good again, the heroes have ridden into the
> west it is the end of an age mutter". =A0What they never say was that
> <implementation> was used by 6 people ever, was written in assembler on
> a machine which could address some tens of k and executed a few hundred
> thousand instructions a second, didn't have a working garbage
> collector, had only upper-case characters, used octal, had no string
> data type, no numbers greater than 48.6, and in fact on closeer
> investigation turns out never to have existed at all.
>
> CL is just fine.

Thank you all for your answers. I'll continue learning CL and then see
from there where to go next.

I don't remember all the comments I read about some-great-Lisp vs. CL,
but one easy to locate is Paul Graham's http://www.paulgraham.com/popular.h=
tml
.. I quote from section 4 Hackability:

=AB Historically, Lisp has been good at letting hackers have their way.
The political correctness of Common Lisp is an aberration. Early Lisps
let you get your hands on everything. =BB

=AB A really good language should be both clean and dirty: cleanly
designed, with a small core of well understood and highly orthogonal
operators, but dirty in the sense that it lets hackers have their way
with it. C is like this. So were the early Lisps. =BB

0
Simon
6/12/2010 6:06:19 PM
Simon <o.simon@gmail.com> wrote in news:a08412a9-16a6-4b11-ba4f-
fad745d4526f@g39g2000pri.googlegroups.com:

> One comment I find a lot when people talk about Lisp is that Lisp is
> wonderful, but CL has a lot of problems (problems I cannot understand
> due to my newbieness). Now, I don't want to learn the wrong Lisp.

The problems people perceive in CL are mostly caused by not learning it 
very well.  It's extremely powerful, but you have to understand a lot of 
abstract ideas to really understand it in depth and be able to make the 
best use of it.  The majority of the people on the planet, programmers 
and otherwise, are reluctant to learn anything, much less CL.  It's much 
easier to make excuses against CL than learn it.  That's close to the 
exact meaning of the metaphor "sour grapes".

Imagine a company with a million programmers, all willing and able to 
learn.  Would that company be well served by writing their own compilers 
etc. for whatever language they use?  Yes, because they have a million 
programmers, the cost of doing things in house to make those programmers 
more cost effective, is divided by a million.  By writing their own 
compilers they get more control and ability to quickly fix whatever 
problems they encounter in their compilers etc.

Now imagine that same company works to make their programming language 
more sophisticated, by adding new features to that language and their 
compiler for it.  Those new features can make those million programmers 
even more productive.  It's far better in a situation like that to spend 
more on the compiler than to have all the programmers work around its 
limitations.

CL is like that.  The compiler, etc., are far more costly to develop, but 
you get a lot more.  And if a million programmers use them, you come out 
way ahead.

But we don't need a million programmers, because CL has been under 
development for decades, and was launched in a time when it got major 
funding from government.  So we effectively get most of the compilers 
etc. as if they were free, or as if we could divide the cost among a 
million programmers.

When someone invents a new programming language now, from scratch, they 
don't make it anywhere near as sophisticated as CL.  It would take too 
much time and effort.  So CL is really our only chance to be able to use 
such powerful and sophisticated programming tools.

So some people love CL and some people hate it.  They see the same thing 
from different points of view.  Some say "whoa, treasure beyond my 
wildest dreams", and others say "whoa, what a mess, let's start over from 
scratch and invent something cleaner."

Those who start over from scratch to invent something cleaner but equally 
powerful, spend years at it, sometimes their whole lives, and usually end 
up making their own mess, much worse than CL, and less powerful.
0
Eric
6/12/2010 6:45:21 PM
On Sat, 12 Jun 2010 11:06:19 -0700, Simon wrote:

> I don't remember all the comments I read about some-great-Lisp vs. CL,
> but one easy to locate is Paul Graham's
> http://www.paulgraham.com/popular.html . I quote from section 4
> Hackability:
> 
> « Historically, Lisp has been good at letting hackers have their way.
> The political correctness of Common Lisp is an aberration. Early Lisps
> let you get your hands on everything. »
> 
> « A really good language should be both clean and dirty: cleanly
> designed, with a small core of well understood and highly orthogonal
> operators, but dirty in the sense that it lets hackers have their way
> with it. C is like this. So were the early Lisps. »

I think that you can safely ignore the above statements.  They are
very vague and ideological.  "Political correctness"?  What does he
even mean?  I only wish that he used "abomination" instead of
"aberration".  The former sounds so much more theological.

PG wrote two books on CL, so he is certainly very knowledgeable about
the language.  But lately, he started designing his own dialect,
called Arc.  Arc has a lot of "principles" like the above, but I don't
think that many people consider it very innovative.  Last time I
checked, I got the impression that one can implement the whole things
as a thin library layered on CL/Scheme.  I fail to see what the fuss
is about, and why this necessitates a new language.  But apparently, it 
is enough to make CL evil now :-)

Best,

Tamas
0
Tamas
6/12/2010 6:51:41 PM
Giovanni Gigante <giov@cidoc.iuav.it> writes:

> Simon wrote:
>> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
>> PCL.
>>
>> One comment I find a lot when people talk about Lisp is that Lisp is
>> wonderful, but CL has a lot of problems (problems I cannot understand
>> due to my newbieness). Now, I don't want to learn the wrong Lisp.
>>
>> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
>> the particular dialect they used and fall in love with?
>>
>> If this unidentified Lisp is so great, why don't they use it and avoid
>> all the pitfalls of CL?
>
>
> From a still-partly-newbie:
>
> There is no Lisp per se, nor "unidentified lisp". Lisp is a family of
> languages.
>
> The most evident feature of CL is that it's a very big language. This
> means that it's either "bloated"/"unelegant" or
> "feature-rich"/"industrial strength", depending on the point of view.

This is wrong.

In 1984-1986, when Common Lisp has been standardized, the standard
document was big, compared to other programming languages of that
time.  But if you compared apples-to-apples, and oranges-to-oranges,
Common Lisp is actually as small a language as any other. 

The difference, is that at that time, the specifications of Scheme,
Pascal, or C or any similar languages took only about 50 pages,
because they specified only the core of the language,  while the
Common Lisp standard included the standard library.

If you add the specifications of the SRFIs (for scheme), of any set of
'standard' library for Pascal or C (eg POSIX.1-2001), you will soon
get document sizes much bigger than the ANSI Common Lisp standard
document.


And nowadays, you would have to include all the network, graphic, GUI,
web, xml, database access and whatever other "essential" library in
your standard, then the CL language starts to looks like a microb of a
language compared to monsters such as perl (including CPAN), Ruby
(including Gems), python (including whatever they have) and even
Haskell (including his cabale stuff which is so big they have to
specifically address the problem of "too many libraries").



Programming languages are all small, on the same order of magnitude.

What's big, and what's takes ten years to master, is their ecosystems,
their libraries (whether they're documented in a "standard document"
or are just de-facto "standards"), and their cultures.



> Another thing: CL is a "lisp-2", meaning that there are separate
> namespaces for functions and values. Instead, Scheme is a
> "lisp-1". There are advantages and disadvantages, none of which should
> you care at the moment.
>
> "Lisp 1" (without the hyphen) and "lisp 1.5", instead, refer to very
> early designs, of antiquarian interest only.

Actually, that would be "LISP I" and "LISP 1.5".  At that time, men
were men, women were women, it was LISP, and no confusion with a lisp
was possible.


> There is no wrong lisp to learn. All lisps are right. Stay with CL,
> it's fine.
>
> gg

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb
6/12/2010 7:35:37 PM
On 12/06/2010 18:36, Simon wrote:
> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
> PCL.
>
> One comment I find a lot when people talk about Lisp is that Lisp is
> wonderful, but CL has a lot of problems (problems I cannot understand
> due to my newbieness). Now, I don't want to learn the wrong Lisp.
>
> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
> the particular dialect they used and fall in love with?
>
> If this unidentified Lisp is so great, why don't they use it and avoid
> all the pitfalls of CL?

The claim that Common Lisp has a lot of pitfalls is highly exaggerated. 
What is actually the case is that Lispers either accidentally used one 
particular dialect, and then may have difficulties moving to some of the 
other ones, or they have studied several different dialects, and chose 
one or more of them as their preferred dialects, and can give reasons 
for their choice, which are sometimes good, and sometimes not so good. 
Languages are never designed in a vacuum, and unless they are just very 
minimal academic exercises, have to make compromises and trade offs in 
order to resolve different, sometimes conflicting goals. Different users 
have different preferences with regard to such goals, and so they also 
have different preferences with regard to which dialect with a certain 
set of trade offs they prefer.

The most commonly used dialects are Scheme and Common Lisp (and, 
depending on your perspective, Emacs Lisp). In recent years, Clojure 
also gained some popularity, but whether it will become one of the 
long-lasting Lisp dialects remains to be seen (I am skeptical). As far 
as I can tell, the applicability of Emacs Lisp is limited, so you are 
basically confronted with choosing between Scheme, Common Lisp and 
Clojure, of which I would describe Scheme and Common Lisp as being the 
most archetypal dialects. My strong recommendation is to take a look at 
both of these, since they make very different trade offs and have some 
fundamentally different design decisions, and see which of them 
resonates best with your style of programming. You should then spend 
some time with that Lisp dialect, to get some proficiency in it. After 
some time, you will better understand certain aspects of that dialect, 
which will then help you to better understand the other dialects as 
well, once you decide to take a second look at them. By then, you will 
probably be able to make a better decision which dialect you will mostly 
use in the long run.

Lisp 1.5 is an ancient dialect for which you will hardly find any 
implementations anymore. The term "Lisp 1" probably doesn't mean 
anything, at least not the way you seem to use it. (There exist the term 
"Lisp-1", but that's a technical term that doesn't refer to a Lisp 
dialect, but to something completely different.)

Even if you find implementations of Interlisp or other similar Lisp 
dialects, they are mostly interesting for historians. For practical 
purposes, the above mentioned Lisp dialects are the most important ones.


Pascal

-- 
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
0
Pascal
6/12/2010 7:47:45 PM
Simon <o.simon@gmail.com> writes:

> On Jun 13, 2:29�am, Tim Bradshaw <t...@tfeb.org> wrote:
>> On 2010-06-12 17:36:50 +0100, Simon said:
>>
>>
>>
>> > One comment I find a lot when people talk about Lisp is that Lisp is
>> > wonderful, but CL has a lot of problems (problems I cannot understand
>> > due to my newbieness). Now, I don't want to learn the wrong Lisp.
>>
>> I think what you are obsreving is that Lisp people like to moan, and
>> complaining about the indequacies of various dialects & implementations
>> is a very common way they do this. �The reasons for this are lost in
>> time - however you'll fairly quickly realise that people are often
>> complaining vigorously to avoid actually getting stuff done, often
>> because they don't really have much idea what to do: obviously if you
>> can persuade yourself that it's *Lisp* preventing you from writing the
>> Great American Compiler, then you don't have to face the fact that, in
>> fact, it's you.
>>
>> > If this unidentified Lisp is so great, why don't they use it and avoid
>> > all the pitfalls of CL?
>>
>> There are two very common patterns you'll see. �Firstly is the CL/other
>> lisp-related-language thing, where adherents of the other sect spend a
>> huge amount of time being rude about CL. �The other is "once upon a
>> time, we had <implementation> which was perfect, but now it is gone,
>> nothing will ever be that good again, the heroes have ridden into the
>> west it is the end of an age mutter". �What they never say was that
>> <implementation> was used by 6 people ever, was written in assembler on
>> a machine which could address some tens of k and executed a few hundred
>> thousand instructions a second, didn't have a working garbage
>> collector, had only upper-case characters, used octal, had no string
>> data type, no numbers greater than 48.6, and in fact on closeer
>> investigation turns out never to have existed at all.
>>
>> CL is just fine.
>
> Thank you all for your answers. I'll continue learning CL and then see
> from there where to go next.
>
> I don't remember all the comments I read about some-great-Lisp vs. CL,
> but one easy to locate is Paul Graham's http://www.paulgraham.com/popular.html
> . I quote from section 4 Hackability:
>
> � Historically, Lisp has been good at letting hackers have their way.
> The political correctness of Common Lisp is an aberration. Early Lisps
> let you get your hands on everything. �


You must also remember that the years 1980 where the years when
software was enslaved by proprietary software producers like Microsoft
(but the movement was initiated by the US government prohibing IBM to
bundle its software with its hardware, and thus susciting the
development of proprietary software.

In this context, access to the sources of a Common Lisp
implementation was unthinkable.

On the other hand lisp systems developed in the years 1970 gave source
access to the whole system, and you could modify any function at
run-time, even something deep in the "kernel".  Well, with a lot of
care, of course.

On the other hand, it's true that the CL standard specifies things in
a way that specifically allows the implementations to take shortcuts
in order to provide easily an efficient implementation.  This makes it
indeed possible to develop an implementation of CL in which it is not
possible to modify an internal function without breaking the system.

That said, there is always the possibility in lisp to implement your
"changes" in the guise of a metalinguistic abstracion (ie implementing
your lisp over the current lisp) on one hand, and on the other, most
implementations let you modify things in the CL package (at your risks
and perils), and some even offer compilation time options to make it
even easier to do so (eg sbcl  :sb-fluid feature).

Moreover, nowadays, whatever the problem you may have with a program,
you can get the sources and modify it, so if anything is not of your
liking in a Common Lisp implementation (or any other programming
language or program), wget, emacs, and five minutes is all you need.

So today you can effectively get your hands on everything, and this
criticism is not in order anymore, if it was ever.



> � A really good language should be both clean and dirty: cleanly
> designed, with a small core of well understood and highly orthogonal
> operators, but dirty in the sense that it lets hackers have their way
> with it. C is like this. So were the early Lisps. �


-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb (7869)
6/12/2010 7:49:11 PM
On 12 Giu, 20:06, Simon <o.si...@gmail.com> wrote:
> <paulgraham>
> =AB Historically, Lisp has been good at letting hackers have their way.
> The political correctness of Common Lisp is an aberration. Early Lisps
> let you get your hands on everything. =BB
>
> =AB A really good language should be both clean and dirty: cleanly
> designed, with a small core of well understood and highly orthogonal
> operators, but dirty in the sense that it lets hackers have their way
> with it. C is like this. So were the early Lisps. =BB

His (PG) preferred Lisp dialect is Scheme.
But Scheme is only a "scheme" (that is, all Scheme implementations
need to add some library to make it a practical language).

PG does not use Scheme for his projects either. He uses an
implementation with "batteries included".
And Common Lisp is simply a Lisp with a base library already
included...

--
0
ok
6/12/2010 7:53:10 PM
I have no idea what he means by "political correctness" when applied
to Common Lisp.  It lets you get your hands on everything just as much
as any early Lisp.

-- Dan

0
Dan
6/12/2010 8:30:06 PM
In article <87vd9orqly.fsf@kuiper.lan.informatimago.com>,
 pjb@informatimago.com (Pascal J. Bourguignon) wrote:

> Giovanni Gigante <giov@cidoc.iuav.it> writes:
> 
> > Simon wrote:
> >> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
> >> PCL.
> >>
> >> One comment I find a lot when people talk about Lisp is that Lisp is
> >> wonderful, but CL has a lot of problems (problems I cannot understand
> >> due to my newbieness). Now, I don't want to learn the wrong Lisp.
> >>
> >> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
> >> the particular dialect they used and fall in love with?
> >>
> >> If this unidentified Lisp is so great, why don't they use it and avoid
> >> all the pitfalls of CL?
> >
> >
> > From a still-partly-newbie:
> >
> > There is no Lisp per se, nor "unidentified lisp". Lisp is a family of
> > languages.
> >
> > The most evident feature of CL is that it's a very big language. This
> > means that it's either "bloated"/"unelegant" or
> > "feature-rich"/"industrial strength", depending on the point of view.
> 
> This is wrong.
> 
> In 1984-1986, when Common Lisp has been standardized, the standard
> document was big, compared to other programming languages of that
> time.  But if you compared apples-to-apples, and oranges-to-oranges,
> Common Lisp is actually as small a language as any other. 

CL was not standardized in 1984-1986. The language was developed
from 1981 to 1984 in its first version. The book CLtL1 (1984)
documented it, but it was not a standard in the sense
that it was published by ANSI (or IEEE), which it was not.
The language was actually not that big  (if one looks at CLtL1
today) and CLtL1 was a nice book.

The 'standard' then was developed later, from 1986 on by ANSI X3J13.

....

-- 
http://lispm.dyndns.org/
0
Rainer
6/12/2010 9:31:52 PM
Eric S wrote:
> Simon <o.simon@gmail.com> wrote in news:a08412a9-16a6-4b11-ba4f-
> fad745d4526f@g39g2000pri.googlegroups.com:
> 
>> One comment I find a lot when people talk about Lisp is that Lisp is
>> wonderful, but CL has a lot of problems (problems I cannot understand
>> due to my newbieness). Now, I don't want to learn the wrong Lisp.
> 
> The problems people perceive in CL are mostly caused by not learning it 
> very well.  It's extremely powerful, but you have to understand a lot of 
> abstract ideas to really understand it in depth and be able to make the 
> best use of it. 

Nonsense. Dripping hot putrid nonsense. CL is interactive, friendly, and 
utterly predictable. aka approachable, aka easy. You just need to build 
an extra bookshelf to hold the index.

kt


-- 
http://www.stuckonalgebra.com
"The best Algebra tutorial program I have seen... in a class by itself." 
Macworld
0
Kenneth
6/12/2010 9:57:07 PM
They mean the abstract Lisp, the one for which no
implementation exists and thus has no problems.  Its
an utopian psychological projection.  Beautiful as a
flawless crystal.  Its the future

http://www.paulgraham.com/hundred.html

or

http://www.dreamsongs.com/Feyerabend/Feyerabend.html

Wade
0
6/12/2010 10:51:39 PM
> Programming languages are all small, on the same order of magnitude.


Well, yes, if one takes a look at the whole java for example, suddenly 
CL appears of subatomic size.
But I still think that the idea I was reporting has some truth, in the 
sense that, apparently, CL was never designed with the "small and 
elegant" mindset (while scheme appears to be).
Am I wrong?

Maybe there is an universal law anyway, than any succesful "small and 
elegant" project inevitably tends to become "feature rich" in the course 
of time, until it collapses, and the cycle restarts.

g
0
Giovanni
6/13/2010 10:23:07 AM
On Sun, 13 Jun 2010 12:23:07 +0200, Giovanni Gigante wrote:

>> Programming languages are all small, on the same order of magnitude.
> 
> 
> Well, yes, if one takes a look at the whole java for example, suddenly
> CL appears of subatomic size.
> But I still think that the idea I was reporting has some truth, in the
> sense that, apparently, CL was never designed with the "small and
> elegant" mindset (while scheme appears to be). Am I wrong?

CL appears to have been designed to fit together nicely.  

"Smallness" is a red herring.  People who design "small" languages try
to eliminate features they consider "redundant", and keep only
"orthogonal" ones.  The problem with this approach is that in
practice, the criteria for redundancy is usually mathematical, not
practical.  Creating good library functions is a slow, evolutionary
process, not an exercise in mathematics.

> Maybe there is an universal law anyway, than any succesful "small and
> elegant" project inevitably tends to become "feature rich" in the course
> of time, until it collapses, and the cycle restarts.

I think that small and (ostensibly) elegant languages either
disappear, or get non-standard extensions, which may be unified at
some point into a single standard one if the particular language
community is lucky.  If not, then semi-standard libraries will coexist
for a long time.

I enjoyed reading Patterns of Software by Richard P. Gabriel on this
topic.

Tamas
0
Tamas
6/13/2010 10:57:35 AM
On 13/06/2010 12:23, Giovanni Gigante wrote:
>
>> Programming languages are all small, on the same order of magnitude.
>
>
> Well, yes, if one takes a look at the whole java for example, suddenly
> CL appears of subatomic size.
> But I still think that the idea I was reporting has some truth, in the
> sense that, apparently, CL was never designed with the "small and
> elegant" mindset (while scheme appears to be).
> Am I wrong?

The original goals for creating Common Lisp are listed here: 
http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node6.html#SECTION00510000000000000000

The original goals for creating Scheme are listed here: 
http://repository.readscheme.org/ftp/papers/ai-lab-pubs/AIM-349.pdf and 
here: http://people.csail.mit.edu/jaffer/r3rs_1.html#SEC1

> Maybe there is an universal law anyway, than any succesful "small and
> elegant" project inevitably tends to become "feature rich" in the course
> of time, until it collapses, and the cycle restarts.

The discipline of computer science in its current form is about 50-60 
years old. That's far too early to claim any kind of universality of 
laws in that realm. I think we have to wait a couple of centuries for 
making any final judgments...


Pascal

-- 
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
0
pc56 (3929)
6/13/2010 1:19:19 PM
> I think we have to wait a couple of centuries for 
> making any final judgments...


Interestingly, Lisp programmers seem to like such long views [1].
(Like diamonds, Lisp is forever, and difficult to sell too).

By the way, if Moore's law holds, in such a period of time we'll have 
more bits than atoms in the universe, in which case "final judgement" 
will perhaps take a more literal sense. After all, the farsighted 
designers of Perl (whose wisdom is evident to all) like to title their 
documents "apocalypses".


[1] http://www.paulgraham.com/hundred.html
0
Giovanni
6/13/2010 3:03:23 PM
On 13/06/2010 17:03, Giovanni Gigante wrote:
>
>> I think we have to wait a couple of centuries for making any final
>> judgments...
>
>
> Interestingly, Lisp programmers seem to like such long views [1].
> (Like diamonds, Lisp is forever, and difficult to sell too).

Sure, but that doesn't change the fact that we're all just guessing... ;)


Pascal

> By the way, if Moore's law holds, in such a period of time we'll have
> more bits than atoms in the universe, in which case "final judgement"
> will perhaps take a more literal sense. After all, the farsighted
> designers of Perl (whose wisdom is evident to all) like to title their
> documents "apocalypses".
>
>
> [1] http://www.paulgraham.com/hundred.html


-- 
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
0
Pascal
6/13/2010 3:44:41 PM
Giovanni Gigante <giov@cidoc.iuav.it> writes:

> [1] http://www.paulgraham.com/hundred.html

IIRC, I had read that article some years ago.  I have reread it now, but
feel quite disappointed.  For example, I don't think anyone will worry
at all about type declarations in 100 years, because a SSC (if not even
AI) won't need those anymore.  And since such technology is available to
some degree today (and was in 2003, see Stalin Scheme or some JIT
compilers), I'm astonished that Paul Graham is so little visionary.

Furthermore: the ultimate language wrt simplicity and mathematical
beauty is already known since the 1930s and is Lambda Calculus augmented
with syntax transformations.  Everything else is a DSL:-)

Nicolas
0
Nicolas
6/13/2010 5:40:55 PM
On 12 Giu, 16:36, Simon <o.si...@gmail.com> wrote:
> One comment I find a lot when people talk about Lisp is that Lisp is
> wonderful, but CL has a lot of problems (problems I cannot understand
> due to my newbieness). Now, I don't want to learn the wrong Lisp.

Common Lisp has not been designed for teaching Lisp. It has been
designed to provide a shared development platform among several
several Lisp dialects which were used at that time. You should expect
a lot of compromises have gone into its design. I think the CL core
language is quite clean, since a lot of CL developers seem to prefer
it to other current Lisp dialects. However, it seems that some
libraries are obsolete or have proved not effective, or superseded.
For further details, check this thread:
http://groups.google.com/group/comp.lang.lisp/browse_frm/thread/2316d0f5fb475f19/97bb2f944956cf61?lnk=gst&q=elena#97bb2f944956cf61

Cheers



>
> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
> the particular dialect they used and fall in love with?
>
> If this unidentified Lisp is so great, why don't they use it and avoid
> all the pitfalls of CL?

0
Elena
6/14/2010 11:32:16 AM
> The most commonly used dialects are Scheme and Common Lisp (and,
> depending on your perspective, Emacs Lisp)

Pascal, your contributions here (and elsewhere) are always
appreciated.  Have you any comments about the viability of ISLisp?

Zanks,
Brian C.
0
BMC
6/14/2010 3:49:20 PM
Rainer Joswig <joswig@lisp.de> writes:

> In article <87vd9orqly.fsf@kuiper.lan.informatimago.com>,
>  pjb@informatimago.com (Pascal J. Bourguignon) wrote:
>
>> Giovanni Gigante <giov@cidoc.iuav.it> writes:
>> 
>> > Simon wrote:
>> >> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
>> >> PCL.
>> >>
>> >> One comment I find a lot when people talk about Lisp is that Lisp is
>> >> wonderful, but CL has a lot of problems (problems I cannot understand
>> >> due to my newbieness). Now, I don't want to learn the wrong Lisp.
>> >>
>> >> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
>> >> the particular dialect they used and fall in love with?
>> >>
>> >> If this unidentified Lisp is so great, why don't they use it and avoid
>> >> all the pitfalls of CL?
>> >
>> >
>> > From a still-partly-newbie:
>> >
>> > There is no Lisp per se, nor "unidentified lisp". Lisp is a family of
>> > languages.
>> >
>> > The most evident feature of CL is that it's a very big language. This
>> > means that it's either "bloated"/"unelegant" or
>> > "feature-rich"/"industrial strength", depending on the point of view.
>> 
>> This is wrong.
>> 
>> In 1984-1986, when Common Lisp has been standardized, the standard
>> document was big, compared to other programming languages of that
>> time.  But if you compared apples-to-apples, and oranges-to-oranges,
>> Common Lisp is actually as small a language as any other. 
>
> CL was not standardized in 1984-1986. The language was developed
> from 1981 to 1984 in its first version. The book CLtL1 (1984)
> documented it, but it was not a standard in the sense
> that it was published by ANSI (or IEEE), which it was not.
> The language was actually not that big  (if one looks at CLtL1
> today) and CLtL1 was a nice book.
>
> The 'standard' then was developed later, from 1986 on by ANSI X3J13.

Thank you, I need to revise my late history of lisp.
-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb
6/14/2010 5:53:02 PM
Giovanni Gigante <giov@cidoc.iuav.it> writes:

>> Programming languages are all small, on the same order of magnitude.
>
>
> Well, yes, if one takes a look at the whole java for example, suddenly
> CL appears of subatomic size.
> But I still think that the idea I was reporting has some truth, in the
> sense that, apparently, CL was never designed with the "small and
> elegant" mindset (while scheme appears to be).
> Am I wrong?

Who can know what was in the mind of the Great Designers?

But for me,  grep "Special Operator" clhs.txt >  small-and-elegant.txt
Smaller and eleganter than Schemer ever!


> Maybe there is an universal law anyway, than any succesful "small and
> elegant" project inevitably tends to become "feature rich" in the
> course of time, until it collapses, and the cycle restarts.

Well, CL hasn't collapsed yet.

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb
6/14/2010 5:56:16 PM
Pascal Costanza <pc@p-cos.net> writes:

> On 13/06/2010 12:23, Giovanni Gigante wrote:
>>
>>> Programming languages are all small, on the same order of magnitude.
>>
>>
>> Well, yes, if one takes a look at the whole java for example, suddenly
>> CL appears of subatomic size.
>> But I still think that the idea I was reporting has some truth, in the
>> sense that, apparently, CL was never designed with the "small and
>> elegant" mindset (while scheme appears to be).
>> Am I wrong?
>
> The original goals for creating Common Lisp are listed here:
> http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node6.html#SECTION00510000000000000000

I think it's well worth quoting it in whole here, since it should
resolve a lot of "philosophical" question we often get on cll about
CL.


    ------------------------------------------------------------------------
    1.1. Purpose

    Common Lisp is intended to meet these goals:

    Commonality

        Common Lisp originated in an attempt to focus the work of several
        implementation groups, each of which was constructing successor
        implementations of MacLisp for different computers. These
        implementations had begun to diverge because of the differences in
        the implementation environments: microcoded personal computers
        (Zetalisp, Spice Lisp), commercial timeshared computers (NIL-the
        ``New Implementation of Lisp''), and supercomputers (S-1
        Lisp). While the differences among the several implementation
        environments of necessity will continue to force certain
        incompatibilities among the implementations, Common Lisp serves as
        a common dialect to which each implementation makes any necessary
        extensions.

    Portability

        Common Lisp intentionally excludes features that cannot be
        implemented easily on a broad class of machines. On the one hand,
        features that are difficult or expensive to implement on hardware
        without special microcode are avoided or provided in a more
        abstract and efficiently implementable form. (Examples of this are
        the invisible forwarding pointers and locatives of Zetalisp. Some
        of the problems that they solve are addressed in different ways in
        Common Lisp.) On the other hand, features that are useful only on
        certain ``ordinary'' or ``commercial'' processors are avoided or
        made optional. (An example of this is the type declaration
        facility, which is useful in some implementations and completely
        ignored in others. Type declarations are completely optional and
        for correct programs affect only efficiency, not semantics.)
        Common Lisp is designed to make it easy to write programs that
        depend as little as possible on machine-specific characteristics,
        such as word length, while allowing some variety of implementation
        techniques.

    Consistency

        Most Lisp implementations are internally inconsistent in that by
        default the interpreter and compiler may assign different
        semantics to correct programs. This semantic difference stems
        primarily from the fact that the interpreter assumes all variables
        to be dynamically scoped, whereas the compiler assumes all
        variables to be local unless explicitly directed otherwise. This
        difference has been the usual practice in Lisp for the sake of
        convenience and efficiency but can lead to very subtle bugs. The
        definition of Common Lisp avoids such anomalies by explicitly
        requiring the interpreter and compiler to impose identical
        semantics on correct programs so far as possible.

    Expressiveness

        Common Lisp culls what experience has shown to be the most useful
        and understandable constructs from not only MacLisp but also
        Interlisp, other Lisp dialects, and other programming
        languages. Constructs judged to be awkward or less useful have
        been excluded. (An example is the store construct of MacLisp.)

    Compatibility

        Unless there is a good reason to the contrary, Common Lisp strives
        to be compatible with Lisp Machine Lisp, MacLisp, and Interlisp,
        roughly in that order.

    Efficiency

        Common Lisp has a number of features designed to facilitate the
        production of high-quality compiled code in those implementations
        whose developers care to invest effort in an optimizing
        compiler. One implementation of Common Lisp, namely S-1 Lisp,
        already has a compiler that produces code for numerical
        computations that is competitive in execution speed to that
        produced by a Fortran compiler. The S-1 Lisp compiler extends
        the work done in MacLisp to produce extremely efficient numerical
        code.

    Power

        Common Lisp is a descendant of MacLisp, which has traditionally
        placed emphasis on providing system-building tools. Such tools may
        in turn be used to build the user-level packages such as Interlisp
        provides; these packages are not, however, part of the Common Lisp
        core specification. It is expected such packages will be built on
        top of the Common Lisp core.

    Stability

        It is intended that Common Lisp will change only slowly and with
        due deliberation. The various dialects that are supersets of
        Common Lisp may serve as laboratories within which to test
        language extensions, but such extensions will be added to Common
        Lisp only after careful examination and experimentation.

    The goals of Common Lisp are thus very close to those of Standard Lisp
    and Portable Standard Lisp. Common Lisp differs from Standard Lisp
    primarily in incorporating more features, including a richer and more
    complicated set of data types and more complex control structures.

    This book is intended to be a language specification rather than an
    implementation specification (although implementation notes are
    scattered throughout the text). It defines a set of standard language
    concepts and constructs that may be used for communication of data
    structures and algorithms in the Common Lisp dialect. This set of
    concepts and constructs is sometimes referred to as the ``core Common
    Lisp language'' because it contains conceptually necessary or
    important features. It is not necessarily implementationally
    minimal. While many features could be defined in terms of others by
    writing Lisp code, and indeed may be implemented that way, it was felt
    that these features should be conceptually primitive so that there
    might be agreement among all users as to their usage. (For example,
    bignums and rational numbers could be implemented as Lisp code given
    operations on fixnums. However, it is important to the conceptual
    integrity of the language that they be regarded by the user as
    primitive, and they are useful enough to warrant a standard
    definition.)

    For the most part, this book defines a programming language, not a
    programming environment. A few interfaces are defined for invoking
    such standard programming tools as a compiler, an editor, a program
    trace facility, and a debugger, but very little is said about their
    nature or operation. It is expected that one or more extensive
    programming environments will be built using Common Lisp as a
    foundation, and will be documented separately.

    There are now many implementations of Common Lisp, some programmed by
    research groups in universities and some by companies that sell them
    commercially, and a number of useful programming environments have
    indeed grown up around these implementations. What is more, all the
    goals stated above have been achieved, most notably that of
    portability. Moving large bodies of Lisp code from one computer to
    another is now routine.
    ------------------------------------------------------------------------



-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb (7869)
6/14/2010 6:16:03 PM
-BMC- <BConnoy@morrisonhershfield.com> writes:

>> The most commonly used dialects are Scheme and Common Lisp (and,
>> depending on your perspective, Emacs Lisp)
>
> Pascal, your contributions here (and elsewhere) are always
> appreciated.  Have you any comments about the viability of ISLisp?

There are less implementations (but more than one), and less users
(but more than one), but it's an International standard instead of
just an American one.  And it's close enough to CL, you could probably
write an implementation of ISLisp in CL in a week end if you ever
found an ISLisp program to run.

Technically, ISLisp is perfectly viable.

Pedagogically, since it's "smaller" than CL, and perhaps somewhat more
orthogonal, it may have its points.

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb
6/14/2010 6:24:35 PM
Dan Weinreb <dlw@alum.mit.edu> writes:

> I have no idea what he means by "political correctness" when applied
> to Common Lisp.  It lets you get your hands on everything just as much
> as any early Lisp.

Let's try it.


[1]> (defvar *old-read* (function cl:read))
*OLD-READ*
[2]> (defun read (&optional input-stream (eof-error-p t) (eof-value nil) (recursive-p nil))
       (let ((object (funcall *old-read*  input-stream eof-error-p eof-value recursive-p)))
         (print `(got ,object) *trace-output*)
         object))

** - Continuable Error
DEFUN/DEFMACRO(READ): #<PACKAGE COMMON-LISP> is locked
If you continue (by typing 'continue'): Ignore the lock and proceed
The following restarts are also available:
ABORT          :R1      Abort main loop
Break 1 [3]> continue
WARNING: DEFUN/DEFMACRO: redefining function READ in top-level, was defined in
         C
READ

;; So far so good, this implementation let us redefine READ.
;; But this is of no use:

[4]> (with-open-file (src "/tmp/test.lisp" :direction :output :if-does-not-exist :create :if-exists :supersede)
       (print `(defvar *test* '(a b c)) src)
       (print `(print (length *test*)) src))
(PRINT (LENGTH *TEST*))
[5]> (load "/tmp/test.lisp")
;; Loading file /tmp/test.lisp ...
3 
;; Loaded file /tmp/test.lisp
T
[6]> (read-from-string "(a b c)")
(A B C) ;
7
[7]> 


;; Since neither LOAD nor READ-FROM-STRING (amongst many other) will
;; use our definition.  This is because implementations are allowed to
;; open-code or inline any CL function.


;; However, you can indeed override functions in CL so that other CL
;; level code will use them:

[9]> (with-input-from-string (in "(a b c)")
       (read in))

(GOT (A B C)) 
(A B C)
[10]> 

;; So that you could override READ, but you would have to override
;; also all the CL functions that call it.  Which soon enough makes
;; you rewrite the whole CL implementation.  What is worse than
;; Greenspunning in Lisp?

;; (Well, IMO Greenspunning in Lisp is not so bad actually, there's a whole
;; chapter about it in SICP :-) )

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb
6/14/2010 6:34:32 PM
On 2010-06-14 19:34:32 +0100, Pascal J. Bourguignon said:

> ;; So that you could override READ, but you would have to override
> ;; also all the CL functions that call it.  Which soon enough makes
> ;; you rewrite the whole CL implementation.  What is worse than
> ;; Greenspunning in Lisp?

Don't redefine READ then.  Instead make a readtable in which everything 
invokes your own reader.

0
Tim
6/14/2010 6:47:37 PM
Tim Bradshaw <tfb@tfeb.org> writes:

> On 2010-06-14 19:34:32 +0100, Pascal J. Bourguignon said:
>
>> ;; So that you could override READ, but you would have to override
>> ;; also all the CL functions that call it.  Which soon enough makes
>> ;; you rewrite the whole CL implementation.  What is worse than
>> ;; Greenspunning in Lisp?
>
> Don't redefine READ then.  Instead make a readtable in which
> everything invokes your own reader.

Perhaps this wouldn't works so well when loading files that 
do (setf *read-table* *mine*)...

In any case, READ vs. LOAD was just an example.  
We could take * vs. EXPT, or RPLACA vs. (SETF CAR), etc.

Sure whether EXPT uses * or (SETF CAR) uses RPLACA is an
implementation detail, so you shouldn't count on it anyway.

But when you're modifing the implementation, you're expected to know
these implementation details anyways, and to do implementation
specific stuff, since basically, you're changing it.


In any case, this is not a 'feature' of the language, but a feature of
the implementations.  But you can always modify the source of the
implementation, just choose one that is written in Lisp ;-) 

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
0
pjb
6/15/2010 7:15:57 AM
On 14/06/2010 17:49, -BMC- wrote:
>
>> The most commonly used dialects are Scheme and Common Lisp (and,
>> depending on your perspective, Emacs Lisp)
>
> Pascal, your contributions here (and elsewhere) are always
> appreciated.  Have you any comments about the viability of ISLisp?

I think ISLisp is a very nice Lisp dialect. It's a very compact, mostly 
subset of Common Lisp, which would be ideal for teaching, for example. 
There is one implementation which is seemingly well maintained. 
Unfortunately, ISLisp doesn't play a big role.


Pascal

-- 
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
0
Pascal
6/15/2010 8:03:04 AM
On Jun 12, 10:11=A0am, Giovanni Gigante <g...@cidoc.iuav.it> wrote:

> Another thing: CL is a "lisp-2", meaning that there are separate
> namespaces for functions and values. Instead, Scheme is a "lisp-1".
> There are advantages and disadvantages, none of which should you care at
> the moment.
>
> "Lisp 1" (without the hyphen) and "lisp 1.5", instead, refer to very
> early designs, of antiquarian interest only.

I find this a good mnemonic to associate with the count of namespaces.

btw, early morning and the jew started making noise by banging the
garage door. he sends the kid. a few years ago first time i tried to
talk to him and he made a fake excuse to put blame on me or demanded
that i return his ball as soon as possible. he uses kids to hit the
metal garage door and it reverberates very loudly.

he lies to the police with fake excuses.

watch this video

http://www.youtube.com/watch?v=3DtOaXZ6b-FEg

=3D=3D=3D=3D=3D

The FAT per DIEM FBI bustards use our TAX PAYER MONEY and INCOMPETENCE
is UNACCEPTABLE.

=3D=3D=3D=3D=3D

http://www.youtube.com/watch?v=3DlX18zUp6WPY

http://www.youtube.com/watch?v=3DXQapkVCx1HI

http://www.youtube.com/watch?v=3DtXJ-k-iOg0M

Hey Racist and INcompetent FBI Bustards, where is the ANTHRAX Mailer ?
Where are the 4 blackboxes ? Where are the Pentagon Videos ? Why did
you release the 5 dancing Israelis compromising the whole 911
investigation ? If the Dubai Police can catch Mossad Murderers and put
the videos and Iranian Police can why cant you put the Pentagon
Videos ? If Iran police can put the AMERICAN TERRORIST, Riggi and
puting on INTERNATIONAL MEDIA a day after catching him without
TORTURE, why cant you put the INNOCENT patsies on the MEDIA. Why did
you have to LIE about Dr Afiya Siddiqui and torture that Innocent
little mother of 3 and smashing the skull of her one child ?

http://www.youtube.com/watch?v=3DDhMcii8smxk
http://www.youtube.com/watch?v=3D0SZ2lxDJmdg

There are CRIMINAL cases against CIA CRIMINAL Bustards in Italian
courts.

FBI bustards paid a penalty of $5.8 million to Steven Hatfill, but
only because he was a white. They got away with MURDER of thousands of
Non-whites in all parts of the world.

Daily 911 news : http://911blogger.com

http://www.youtube.com/watch?v=3DtRfhUezbKLw

http://www.youtube.com/watch?v=3Dx7kGZ3XPEm4

http://www.youtube.com/watch?v=3DlX18zUp6WPY

Conclusion : FBI bustards are RACIST and INcompetent. They could
neither catch the ANTHRAX or 911 YANK/Jew criminals nor could they
cover them up - whichever was their actual goal or task.

SLASH the SALARIES of FBI/CIA/NSA etc BUSTARDS into half all across
tbe board, esp the whites/jew on the top.

FBI Bustards failed to Catch BERNARD MADOFF even after that RACIST and
UNPATRIOTIC Act
FBI bustards failed to prevent ROMAN POLANSKY from absconding to
europe and rapes.
FBI bustards failed to prevent OKLAHOMA

0
nanothermite911fbibu
6/15/2010 4:49:08 PM
On Jun 15, 9:49=A0am, nanothermite911fbibustards
<nanothermite911fbibusta...@gmail.com> wrote:
> On Jun 12, 10:11=A0am, Giovanni Gigante <g...@cidoc.iuav.it> wrote:
>
> > Another thing: CL is a "lisp-2", meaning that there are separate
> > namespaces for functions and values. Instead, Scheme is a "lisp-1".
> > There are advantages and disadvantages, none of which should you care a=
t
> > the moment.
>
> > "Lisp 1" (without the hyphen) and "lisp 1.5", instead, refer to very
> > early designs, of antiquarian interest only.
>
> I find this a good mnemonic to associate with the count of namespaces.
>
> btw, early morning and the jew started making noise by banging the
> garage door. he sends the kid. a few years ago first time i tried to
> talk to him and he made a fake excuse to put blame on me or demanded
> that i return his ball as soon as possible [immediately is the correct wo=
rd ... as it I am his bonded slave]. he uses kids to hit the
> metal garage door and it reverberates very loudly.
>
> he lies to the police with fake excuses.
>
> watch this video
>
> http://www.youtube.com/watch?v=3DtOaXZ6b-FEg
>
> =3D=3D=3D=3D=3D
>
> The FAT per DIEM FBI bustards use our TAX PAYER MONEY and INCOMPETENCE
> is UNACCEPTABLE.
>
> =3D=3D=3D=3D=3D
>
> http://www.youtube.com/watch?v=3DlX18zUp6WPY
>
> http://www.youtube.com/watch?v=3DXQapkVCx1HI
>
> http://www.youtube.com/watch?v=3DtXJ-k-iOg0M
>
> Hey Racist and INcompetent FBI Bustards, where is the ANTHRAX Mailer ?
> Where are the 4 blackboxes ? Where are the Pentagon Videos ? Why did
> you release the 5 dancing Israelis compromising the whole 911
> investigation ? If the Dubai Police can catch Mossad Murderers and put
> the videos and Iranian Police can why cant you put the Pentagon
> Videos ? If Iran police can put the AMERICAN TERRORIST, Riggi and
> puting on INTERNATIONAL MEDIA a day after catching him without
> TORTURE, why cant you put the INNOCENT patsies on the MEDIA. Why did
> you have to LIE about Dr Afiya Siddiqui and torture that Innocent
> little mother of 3 and smashing the skull of her one child ?
>
> http://www.youtube.com/watch?v=3DDhMcii8smxkhttp://www.youtube.com/watch?=
v=3D0SZ2lxDJmdg
>
> There are CRIMINAL cases against CIA CRIMINAL Bustards in Italian
> courts.
>
> FBI bustards paid a penalty of $5.8 million to Steven Hatfill, but
> only because he was a white. They got away with MURDER of thousands of
> Non-whites in all parts of the world.
>
> Daily 911 news :http://911blogger.com
>
> http://www.youtube.com/watch?v=3DtRfhUezbKLw
>
> http://www.youtube.com/watch?v=3Dx7kGZ3XPEm4
>
> http://www.youtube.com/watch?v=3DlX18zUp6WPY
>
> Conclusion : FBI bustards are RACIST and INcompetent. They could
> neither catch the ANTHRAX or 911 YANK/Jew criminals nor could they
> cover them up - whichever was their actual goal or task.
>
> SLASH the SALARIES of FBI/CIA/NSA etc BUSTARDS into half all across
> tbe board, esp the whites/jew on the top.
>
> FBI Bustards failed to Catch BERNARD MADOFF even after that RACIST and
> UNPATRIOTIC Act
> FBI bustards failed to prevent ROMAN POLANSKY from absconding to
> europe and rapes.
> FBI bustards failed to prevent OKLAHOMA

0
nanothermite911fbibu
6/15/2010 4:56:11 PM
On 2010-06-13, Pascal Costanza <pc@p-cos.net> wrote:
>
> The discipline of computer science in its current form is about 50-60 
> years old. That's far too early to claim any kind of universality of 
> laws in that realm. I think we have to wait a couple of centuries for 
> making any final judgments...
>
I can't wait that long.
0
Curt
7/4/2010 3:39:27 PM
On 04/07/2010 17:39, Curt wrote:
> On 2010-06-13, Pascal Costanza<pc@p-cos.net>  wrote:
>>
>> The discipline of computer science in its current form is about 50-60
>> years old. That's far too early to claim any kind of universality of
>> laws in that realm. I think we have to wait a couple of centuries for
>> making any final judgments...
>>
> I can't wait that long.

Sure. So in the meantime, you have to make guesses, like everybody else.


Pascal

-- 
My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/
0
Pascal
7/4/2010 6:21:10 PM
Simon wrote:
> I'm deeply interested in Lisp. I'm learning it through Peter Seibel's
> PCL.
> 
> One comment I find a lot when people talk about Lisp is that Lisp is
> wonderful, but CL has a lot of problems (problems I cannot understand
> due to my newbieness). Now, I don't want to learn the wrong Lisp.

It's quite fashionable, when X is the leader, to say X is not so good. 
Also, when CL came out some folks were worried about the size, but I use 
it all (except Series) so it is hard to say it is too big.

I use CL for heavy-duty industrial work and am not having any problems.

> 
> What do people mean by Lisp in this context? Is it Lisp 1, Lisp 1.5,
> the particular dialect they used and fall in love with?
> 
> If this unidentified Lisp is so great, why don't they use it and avoid
> all the pitfalls of CL?

A lot of people use Scheme, but you are right: there must not be all the 
pitfalls some folks talk about.

kt


-- 
http://www.stuckonalgebra.com
"The best Algebra tutorial program I have seen... in a class by itself." 
Macworld
0
Kenneth
7/4/2010 8:16:57 PM
Reply: