
Lisp: A Cult I Almost Joined (2005) - rlander
http://www.fluff.info/blog/arch/00000127.htm
======
tumba
_> For the non-programmers among you, here's the executive summary of how to
program: 1. Surf the Net for packages by other people that do what you need to
get done. 2. Repeat step one until you've gathered everything you need. 3.
Write a program that calls the modules you've collected. This is a great
method, because step three is potentially very brief, provided there are
enough modules out there._

This is true of some programming, but not all. If I need to do some quick data
munging, or build a CRUD application, lisp may not provide any benefits over
another language in which I am equally skilled. But if I am programming in a
complicated domain or doing exploratory work, I would rather be using lisp
than any other language.

~~~
TeMPOraL
Exactly. Plus, someone needs to write those packages from point 1, and
point-3-style programming is boring.

------
bmh100
The point the author brings up about the lack of Lisp modules in 2005 is an
interesting one and reminds me of the article "Why Perl Didn't Win", posted
within the last few days. Browsing clojars.org, a Clojure repository, reveals
that there are 11,435 libraries at the time of my writing. That is a great
improvement, vastly exceeding the author's positive example of Python's 249
modules at the time. PyPI, a Python repository, currently lists 54,060, so
clearly Python is still much more popular than Clojure. Yet, the 11K Clojure
libraries seems to be a direct contradiction to his statement: "And lisp
modules? Well, every part of the code can modify every other part. You can
write a whole new grammar if you're so inclined. None of this helps with the
goal of downloading a random package and easily calling whatever you want from
it with minimal hassle. There's just a fundamental conflict between easy
modularity on the one hand, which requires lots of restrictions and boring
standard forms, and fluid modifiability on the other." The Clojure community
has made great strides in promoting the adoption of a Lisp among programmers
and enterprises.

~~~
austinz
I think it also helps that, in practice, there seems to be a common philosophy
(at least among the Clojurists I've talked to) that macros should be used only
when absolutely necessary. Because of this, the sort of unrestrained,
ubiquitous code rewriting that the author mentions is rare.

~~~
bmh100
Yes, and a lot of that can also be traced back to the built-in macros that
Clojure provides and encourages. Macros like apply, ->, ->>, partial, memoize,
and even . just make it so much rarer that a developer needs to write a macro
outside of DSL development. It's wonderful.

~~~
bmh100
Could someone who downvoted this post please offer feedback? I do not
understand why this comment did not contribute to the discussion.

~~~
tim333
I didn't downvote but as someone who uses Python and doesn't know Clojure,
phrases like "Macros like apply, ->, ->>, partial, memoize, and even . just
make it so much rarer that a developer needs to write a macro" make me glad I
don't have to muck about with that stuff.(?)

------
fchollet
_> When I was in Morocco, several different people told me that Neil Armstrong
converted to Islam after seeing the Earth, and that Cat Stevens converted. At
first, this was OK, but soon, after the third person or so mentioned this
pair, I got to wondering, maybe they're the only ones._

In case anybody else wondered about this: Neil's Armstrong purported
conversion is a hoax that has its origins in an Indonesian pop song from the
80s (Indonesia is a major muslim country). [1]

[1]
[https://en.wikipedia.org/wiki/Neil_Armstrong](https://en.wikipedia.org/wiki/Neil_Armstrong)

------
sz4kerto
Cached version:
[http://webcache.googleusercontent.com/search?q=cache:YnwCUmQ...](http://webcache.googleusercontent.com/search?q=cache:YnwCUmQd2L0J:fluff.info/blog/arch/00000127.htm&strip=1)

------
TeMPOraL
> _If, on appropriate occasions, the members tell, enjoy, trade, and /or
> devise transgressively funny jokes about their denomination, it's a church._

> _If such jokes reliably meet with stifling social disapproval, it 's a
> cult._

An interesting definition I totally disagree with. It's the social disapproval
that turned any of us into geeks, and guess what - I personally like it that
way. Society approves mostly things that are pointless or boring anyway. An
example: why do you think HN guidelines advocate against posting mainstream
news?

~~~
dizzystar
If it's any comfort, the Clojurists I've been around have no problems telling
jokes about the language or lisp in general. I guess they (we) enjoy openly
acknowledging the perceived church / cult and gladly pick on the notion
because the whole language-superiority debate is silly.

~~~
coding4all
I find that most Clojurist have mastered at least one or two languages before
learning Clojure, so that might be the reason.

------
soup10
I tried out Lisp sometime around 2009 or so and immediately realized it was a
toy language. Interesting for it's unique approach to structuring code, but
ultimately designed for a certain kind of mathematical elegance over practical
functionality. It grew especially popular with ai researchers, because they
were searching for beautiful answers to the messy problem of intelligence, and
didn't think performance was as critical as ideas. And it grew fans here and
there for certain low-performance applications because it was one of the first
languages with productivity enhancing features like garbage collection.

Lisp may have been "mind blowing" before untyped scripting languages were a
dime a dozen, but these days the only thing mind-blowing about it is that
people still use it when there are much better alternatives.

~~~
dragonwriter
> I tried out Lisp sometime around 2009 or so and immediately realized it was
> a toy language.

There are definitely toy languages in the Lisp family (after all, there's
quite a lot of lisps), but it pretty ridiculous to call Lisp a toy language.

> Interesting for it's unique approach to structuring code, but ultimately
> designed for a certain kind of mathematical elegance over practical
> functionality.

Most that I've read on the history of Lisp seems to show more of a preference
for pragmatism than theoretical elegance.

> It grew especially popular with ai researchers, because they were searching
> for beautiful answers to the messy problem of intelligence

It grew especially popular with AI researchers because it was designed
specifically to address needs in AI research.

> And it grew fans here and there for certain low-performance applications
> because it was one of the first languages with productivity enhancing
> features like garbage collection.

Lisps breadth and depth of production use has been considerably more than
"here and there" and "certain low-performance applications".

> Lisp may have been "mind blowing" before untyped scripting languages were a
> dime a dozen

Being an untyped scripting language isn't the thing that is generally
considered "mind blowing" about lisp, its the flexibility that comes from the
combination of its minimal syntax, the macro system, and its homoiconic nature
making code and data isomorphic.

~~~
soup10
Yea, I guess it's inflammatory to call any language that people use
seriously(even if only for research), a toy. Sorry about that.

One disagreement I have is Lisp is definitely not designed for high
performance. Any competent C programmer would find the suggestion laughable.
There's a write up for Orbitz somewhere that details many of the problems they
had with basic stuff.

Second, less syntax just means messier code. Parentheses everywhere doesn't
make a language good. Just harder to read. The "macro system" which refers to
the ability to perform arbitrary functions on arbitrary data, is not unique to
lisp. And in general, usually obfuscates code and makes debugging harder.

Code is data and data is code everywhere(it's all just bits and bytes after
all). I would classify "its homoiconic nature making code and data isomorphic"
to mean there's less syntax. Everything that you can do with macro's and
Lisps's homogeneous syntax is achievable with similar constructs in other
languages. The fact that the syntax is "homiconic and data isomorphic" is
elegant, but in practice just confusing imo. Programming languages where data
and functions are delineated by design have clearer structure and
organization. Additionally they allow the compiler or interpreter to optimize
by design. In the rare case it's useful to have a function become a data
argument, there are usually accommodations in the language to do so.

These are just my opinions though man. You keep on using whatever programming
language makes you happy.

~~~
lokedhs
While a Common Lisp program is generally slower than a well optimised C
program, I don't think it's fair to argue that it deserves a special place
among "slow" languages. In some cases, Lisp code is even faster than C code:
[http://benchmarksgame.alioth.debian.org/u32/compare.php?lang...](http://benchmarksgame.alioth.debian.org/u32/compare.php?lang=sbcl&lang2=gcc)

~~~
soup10
This really isn't worth discussing since nobody seriously considers LISP an
easily optimizable language. Did you know a minor change to improve cache-hits
on an inner loop can double the speed of an algorithm? That's just the tip of
the iceberg. You need to be close to the metal to optimize and LISP does not
provide for that. It's only fast relative to dog slow languages that were
programmed on far newer hardware and could get away with it.

~~~
lispm
Typically, optimized Lisp code is around 50% slower than C. This is only
available on mainstream processors. Specialized and very fast hardware usually
lacks Lisp implementations - with a few exceptions.

Which puts it into similar regions as Java, Go or D.

Unoptimized Lisp code can be a lot slower, but it then supports a bunch of
interesting dynamic behavior.

The main approach of better performing Lisp systems is to provide a wide
variety of programming styles and a lot of flexibility, while being at the
same time fast enough, so that not much software needs to be written in C or
assembler. For example in a large CAD system it is possible to write much of
the code in Lisp - in a space where such an application has to compete with
systems written in C and especially C++. Depending on the quality of the Lisp
implementation, the C/C++ part gets larger or smaller.

For example one of PTC's Creo CAD systems is written mostly in Lisp - a bit
more than 6 million lines of Lisp code was reported a few years back.

------
coding4all
I wouldn't call it a cult. I find a lot of people who write CL / SBCL don't
care much for Clojure. That was a few years ago though, so maybe this has
changed?

------
mod
Older discussion:
[https://news.ycombinator.com/item?id=2367746](https://news.ycombinator.com/item?id=2367746)

