Expert opinions of Common Lisp

Here's what the EXPERTS say about Commune Lisp:

"an unwieldy, overweight beast"
"intellectual overload"
"did kill Lisp"
"A monstrosity"
"killed Lisp"
"sucks"
"an aberration"
"incomprehensible"
"a nightmare"
"no future"
"a significantly ugly language"
"hacks"
"unfortunate"
"bad"

In context:

Brooks and Gabriel 1984, "A Critique of Common Lisp":

Every decision of the committee can be locally rationalized
as the right thing. We believe that the sum of these
decisions, however, has produced something greater than its
parts; an unwieldy, overweight beast, with significant costs
(especially on other than micro-codable personal Lisp
engines) in compiler size and speed, in runtime performance,
in programmer overhead needed to produce efficient programs,
and in intellectual overload for a programmer wishing to be
a proficient COMMON LISP programmer.

-----

Bernard Lang:

Common Lisp did kill Lisp. Period. (just languages take a
long time dying ...) It is to Lisp what C++ is to C.  A
monstrosity that totally ignores the basics of language
design, simplicity and orthogonality to begin with.

-----

Gilles Kahn:

To this day I have not forgotten that Common Lisp killed
Lisp, and forced us to abandon a perfectly good system,
LeLisp.

-----

Paul Graham, May 2001:

A hacker's language is terse and hackable. Common Lisp is not.

The good news is, it's not Lisp that sucks, but Common Lisp.

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. A real hacker's language will always have a
slightly raffish character.

Organic growth seems to yield better technology and richer
founders than the big bang method. If you look at the
dominant technologies today, you'll find that most of them
grew organically. This pattern doesn't only apply to
companies. You see it in sponsored research too. Multics and
Common Lisp were big-bang projects, and Unix and MacLisp
were organic growth projects.

-----

Jeffrey M. Jacobs:

Common LISP is the PL/I of Lisps.  Too big and too
incomprehensible, with no examination of the real world of
software engineering.

...  The CL effort resembles a bunch of spoiled children,
each insisting "include my feature or I'll pull out, and
then we'll all go down the tubes".  Everybody had vested
interests, both financial and emotional.

CL is a nightmare; it has effectively killed LISP
development in this country.  It is not commercially viable
and has virtually no future outside of the traditional
academic/defense/research arena.

-----

Dick Gabriel:

Common Lisp is a significantly ugly language.  If Guy and I
had been locked in a room, you can bet it wouldn't have
turned out like that.

-----

Paul Graham:

Do you really think people in 1000 years want to be
constrained by hacks that got put into the foundations of
Common Lisp because a lot of code at Symbolics depended on
it in 1988?

-----

Daniel Weinreb, 24 Feb 2003:

Having separate "value cells" and "function cells" (to use
the "street language" way of saying it) was one of the most
unfortuanate issues. We did not want to break pre-existing
programs that had a global variable named "foo" and a global
function named "foo" that were distinct.  We at Symbolics
were forced to insist on this, in the face of everyone's
knowing that it was not what we would have done absent
compatibility constraints. It's hard for me to remember all
the specific things like this, but if we had had fewer
compatibility issues, I think it would have come out looking
more like Scheme in general.

-----

Daniel Weinreb, 28 Feb 2003:

Lisp2 means that all kinds of language primitives have to
exist in two versions, or be parameterizable as to whether
they are talking about the value cell or function cell. It
makes the language bigger, and that's bad in and of itself.

-----

Guy L. Steele, Jr., July 1989:

I think we may usefully compare the approximate number of pages
in the defining standard or draft standard for several
programming languages:

  Common Lisp   1000 or more
  COBOL          810
  ATLAS          790
  Fortran 77     430
  PL/I           420
  BASIC          360
  ADA            340
  Fortran 8x     300
  C              220
  Pascal         120
  DIBOL           90
  Scheme          50

Back to /ruby/ , waxman

We all know that Graham said all of that to promote his new Arc Lisp.

You can say bad things about CL, but they wont make your fucking Scheme a good language.


Macro in CL DSL

m:aif cond then else -> if it:$cond $then $else

Macro in CL

(defmacro aif (cond then else)
  `(let ((it ,cond))
     (if it ,then ,else)))

"Macro" in Scheme/Racket.

#lang racket
(require racket/stxparam)
 
(define-syntax-parameter it (lambda (stx) (raise-syntax-error 'anaphora "missed context" stx)))
 
(define-syntax-rule (aif cond then else)
  (let ([temp cond])
    (syntax-parameterize ([it (make-rename-transformer #`temp)])
                         (if temp then else))))

CL DSL

find x [@xs m:@x @ys] -> m

Scheme/Racket

#lang racket
(require syntax/parse)
(define-syntax (find stx)
  (syntax-case stx ()
    [(_ (patt ...) expr) #`(begin (define-splicing-syntax-class my-class
                              (pattern (~seq patt ...)))
                            (syntax-parse expr
                                          [(a (... ...) q:my-class b (... ...)) #`q]
                                          [_ #f]))]))
 
(find (W o r l d) #`(H e l l o   W o r l d))

>>4-5
fuck you faggot

>>4
trolling with a retarded version of a worthless macro
You again, *sigh*

>>6>>7
But I love anaphoric macros and pattern matching out-of-box!

You, people, were just brainwashed with SICP crap about hygiene.

>>8
You, people, were just brainwashed with SICP crap about hygiene.
(-︢  ̱-︡   )

>>8
1. SICP doesn't cover macros at all, let alone hygiene.
2. I gave you a working version of defmacro last time, so quit bitching
3. syntax-parse and the syntax parameters stuff aren't "Scheme", they are Racket.
4. As I said last time, if you don't care about hygiene, fine, but don't pretend that your macros are anything better than Cs.

1. They why do you hate defmacro?
2. If you try to use defmacro with Scheme, other'll label you "troll" and ban from Scheme community.
3. I don't know neither Scheme, nor Racket.
4. Can you implement a `for` loop with C macros?

ITT: Gay tensions.

>>11
I don't hate defmacro any more than I hate people who think dynamic scope is a good idea; I'm deeply disappointed.

Dynamic scope is a good idea.

>>13
Dynamic scope has it's use. But I'm using lexical scope, when I need local vars and/or OOP-like functionality.

>>14
Newlisp user spotted.

>>15
Allow me to rephrase, dynamic scope by default, and pervasively is a bad idea.

>>17
But there is nothing bad with defmacro by default.

BTW, I don't thing C/C++ is bad, because you can get a segfault. C/C++ is bad, because you've no way to create system without segfault. You can't add garbage collector to C/C++, neither you can add dynamic typing.

>>18
Of course you don't think that, you've already stated that you think hygiene is a worthless concept. I, on the other hand, am interested in writing macros that can't leak their implementation details.

>>20
So, it's a matter of discipline. If you love army and drilling, then Scheme and Haskell are for you. If you more of a free thinker, then CL is the best Lisp.

>>21
If you love army and drilling
Hardly. It's very easy to break hygiene, it just needs to be a conscious decision.

what's the difference between racket and scheme ?

>>23
Scheme is for autists, racket for hipsters.

>>23
Racket is arguably a superset of Scheme, but common Racket programming style uses enough extensions that they no longer feel that it is intellectually honest to call it Scheme.

I AM THE MOST FUCKING NGGER MATURE!!
YOU MUST GOOD WITH COMPUTER!!
DO YOU HEAR THAT SOUND?
IT IS THE SOUND OF A WILD NGGER MATURE, CHARGING YOUR ANUS.
YOU MUST INTERNET LIKE YOU MAY NEVER INTERNET AGAIN!!

YOU CANNOT KILL ME. I HAVE 29 COMPUTER INTERNETS AND YOU CAN NIGGER DICK SHITS!

HEIL NIGGERS.
HEIL BLACK AFRIKA.
NIG HEIL BLACK HITLER!!

>>22
easy to break hygiene,
see >>4

I prefer absence of confirmations to clicking 10 times "Ok" button, even if I enter "rm -rf /". I'm fuckin' programmer, so I'm know what I'm doing.

>>23
Racket has static typing and lazy/call-by-name evaluation, like in Haskell.

>>24
They're both for CS-students interested in theory. I won't recommend them to people wanting to do cool video game or a useful utility.

People actually *like* ``hygienic'' macros?

>>27
You completely misunderstand the purpose of hygiene. What happens when I use your macro, and oh look it shadows half a dozen common variable names that I'm using. Hygiene is like throwing useful exceptions, it is a service to other programmers.

Here's a simple task for the CLispers, write a useful implementation of swap! without using gensyms. Then tell me that hygiene is useless.

>>32

m:swap a b -> &t:a -> a=:b -> b=:&t

>>33
I'm assuming that t is the temporary variable name?
ok, say I want to swap two variables t and a, will this fail in your system?

>>34
`&` means "m:" (shorthand for macro) should treat `t` as gensymed var. Of course, I can call gensym automatically, when macro is really compliated. But in most cases `&` suffices.

>I can call gensym manually
seflf fix

>>35
should treat `t` as gensymed var
What's that, an auto gensym, I thought hygiene was useless.

Hygiene won't make your code shorter.

>>37
You are arguing with a braindead fanatic and quite possibly a troll. This will lead nowhere.

>>39
Nope. His arguments just aren't strong enough. But if he shows us, that hygiene helps rewriting 100 lines code snippet into 10 lines one, I'll gladly agree that hygiene is cool.