
Lisp is Not an Acceptable Lisp (2006) - helwr
http://steve-yegge.blogspot.com/2006/04/lisp-is-not-acceptable-lisp.html
======
aufreak3
_My prediction: someone will get tired of waiting, and they'll Torvalds Arc
into obsolescence before it's ever released_

It certainly looks like Arc has been "Rich Hickeyed" judging by the recent
announcement of funding for Clojure. Think about that for a moment - a
commercial organization is actually funding development of a _new_ lisp!

~~~
WilliamLP
Has Paul Graham ever addressed in writing the disconnect between the amount of
hype Arc got before it was released versus nearly instantly vanishing almost
completely from public mind-share?

------
Zak
_At the risk of predicting future fashion trends, which is rarely a good idea,
I'll venture that objects are going to continue to be trendy for at least a
few more decades._

This article is four years old, but since the prediction spans decades, I
think it's fair to pick on it a little.

The OOP trend seems to be waning. The languages people are getting excited
about lately seem to be de-emphasizing OOP and providing other mechanisms for
some of the useful attributes of OOP.

Haskell and Clojure don't have OOP as most people know them, but Clojure's
multimethods and Haskell's typeclasses replace OO polymorphism to a large
degree. Scala and F# have OOP, but using it is optional.

Ten years ago, a new language intended for practical work and lacking OO
wouldn't be taken seriously. That has changed, and the change seems to be
accelerating.

~~~
WilliamLP
I don't actually see a trend in the last 2-3 years of people getting more
excited about Haskell, Clojure, Scala, and F#. Two years ago, people on forums
like this one were _extremely_ excited about these languages. Outside of the
forum scene, and into the industry, I see a lot more eye-rolling and knowing
"here we go again" stares than excitement about these.

I don't think we should lose sight of the fact that extreme enthusiasm about
functional programming and Lisp taking over as the dominant paradigm in
programming is almost as old as programming itself.

~~~
dkarl
Not to mention that Scala is explicitly OO, F# is based on Objective Caml, and
Clojure owes a lot of its success to the libraries provided by a huge,
thriving OO community. OOP is not waning unless you define OOP as the design
pathologies imposed by bad OO languages.

------
mahmud
For every coding Lisper, there are 99 opinionated non-Lispers waxing poetic
over its glory, or barking polemic over its demise.

~~~
quadhome
Odd ratio. I hazard it's inverted for the Javas and C/C++s of the world.

------
prog
When I started to learn Lisp, the "Which Lisp?" problem was the first thing to
hit me. Same with Scheme. I eventually went with CLISP and PLT (Racket).

Issues like hygiene didn't really bother me too much. As long as you are aware
of it its not an issue.

While I really like the power of Lisp/Scheme (especially macros), I find that
for most programming task Python or Ruby are good enough. There was an
interesting post along similar lines 'Why Ruby is an acceptable Lisp'[1].

One thing I am really interested is in seeing how Perl 6 works out. It
supports Lisp style macros (by making the parser available to the programmer)
while using conventional syntax. While I am a Python fanboy myself I would
seriously consider Perl 6 once there is a CPython grade implementation
available.

[1] [http://www.randomhacks.net/articles/2005/12/03/why-ruby-
is-a...](http://www.randomhacks.net/articles/2005/12/03/why-ruby-is-an-
acceptable-lisp)

------
brlewis
About "which Lisp": I think most people recommend PLT Racket for newbies. I
do, even though I use Kawa Scheme daily.

About macros: If I recall correctly, Scheme got hygenic macros in 1991 with
R5RS. If I recall incorrectly it was earlier, definitely not later.

Many Scheme implementations clone CL's defmacro, which is non-hygienic unless
you're careful, but is useful. There's also syntax-case, which is hygienic by
default, but let's you break hygiene explicitly.

Macros should be used only when functions won't do, and not because of tool
support. Macros act at compile time, not run time, so they aren't run-time
objects that can be used flexibly the way functions can.

~~~
nickik
How is it to work with kawa. I only no that it exists not more. Some question:
1\. Can you use it professionally? 2\. Whats the benefit over clojure? 3\.
Does it live close to java and is it still lispy to work with java (clojure
does well there I think) 4\. How fast is it?

~~~
brlewis
1\. Yes 2\. Scheme is a better-established standard. Nice macro system. 3\.
Easy Java integration and totally lispy...not 100% Schemey because you can't
do continuation capture. 4\. It's way faster than PHP4. I haven't benchmarked
it in years, because performance hasn't been an issue.

------
Confusion
Previous discussion of this article and the article that inspired it.

<http://news.ycombinator.com/item?id=825746>

<http://news.ycombinator.com/item?id=416589>

------
jacquesm
I wonder if Steve has updated his views on this since he wrote this (2006) in
light of the emergence of clojure.

~~~
ananthrk
His come-back blogpost ends thus:

 _I used to have lot of open, long-standing concerns about the future of
programming and productivity, but my sabbatical last year finally brought me
some clojure._

Take what you will from that :)

~~~
jacquesm
Thanks! Link to where that came from:

<http://steve-yegge.blogspot.com/2010/07/blogger-finger.html>

------
seis6
In a real world of webs applications and jobs for the net, macros are a dream
for another universe. Php people don't dream, they step by step are making
what macros can't do: expanding their universe. Joomla! they say.

~~~
nickik
no the just really GROW the language. Some new features somewhere else that
they don't understand just trick it somehow in there. convert it to string and
back or just stuff everything in some global variable or something. If it
breaks you can just make a ugly fix on it with the next version.

------
tkahn6
Can anyone explain why Steve thinks Haskell is 'doing it wrong' when it comes
to type systems?

~~~
chc
My inference from the times I can remember him mentioning it: Basically, Steve
likes dynamic typing. He feels that arbitrary language-enforced constraints
just get in the way. Haskell is the most strongly statically typed language in
existence, so obviously it's not his cup of tea.

If you read his most recent rant, you can see that although it's technically
about visibility modifiers, it can read as a condemnation of compiler-enforced
constraints in general.

