Hacker News new | comments | show | ask | jobs | submit login
Lisp: a cult I almost joined (2005) (fluff.info)
52 points by gnosis 2398 days ago | hide | past | web | 53 comments | favorite



Lisp(and specifically common lisp) is one of the top languages people who don't know it like to criticize. That wouldn't be a bad thing if the criticism was any good. Every time i see a blog post about some "problem" with lisp the chances that it has something valuable to say are low. And calling a language community a cult is beyond offensive.


I want to both upvote you (`` the chances that it has something valuable to say are low'') and downvote (``is beyond offensive'') at the same time.

See, his arguments about Lisp community being a cult stand. Yours are purely emotional.

Now we could agree that there is a very good reason to be cultic about Lisp -- it is the best thing since the sliced bread etc. etc. and people should just use it -- but that's another matter.

In a way, he pre-empted your reaction with ``If such jokes reliably meet with stifling social disapproval, it's a cult.'' ;-)


I absolutely love Lisp, but I'm not in the least bit offended at someone describing some aspects of the culture as cultish.

But the thing is.. the very same thing could be said of most other language enthusiasts.

Look at all the endless hype from Python and Ruby fans (especially when they compare their favorite language to Perl).

Or look at some OCaml or Haskell fanboys and their attitude that static typing is The True Way and only ignorant savages would prefer a dynamically typed language.

And this doesn't even touch on the vi vs Emacs holy wars.

There's plenty of fanboyishness, exclusivity, and and chastisement of outsiders in many computer fields. And I dare say it's not really limited to computers either. I'm not sure if "cultish" is really the most appropriate term, but I feel no offense at it.

The whole discussion reminds me of these images:

http://www.deimeke.net/dirk/blog/uploads/G7WyP.gif

http://www.rubyinside.com/holiday-fun-how-programming-langua...


don't get me wrong, i like lisp a lot. but i think lisp has a bad image because many lispers (not all) are nitpickers. lisper think they are cool, but they are not. they don't let anything new in their language. they stick to s-expressions like they are the holy grail. they stick to the funny function names as if they were given by god. they are the most conservative language community (maybe apart from COBOL). look at all the disregard they had for arc. this could have been a beginning to dust off the fossil language and remove all the warts. but they did not like it. instead lisp is still the language that it was 50 years ago. <\rant>


You seem to misunderstand lisp programmers greatly, allow me to attempt to exlain:

they don't let anything new in their language.

Common Lisp is a standard, changing it requires tremendous resources, and provide little actual value, if you have some language extension you want added to the language, put it in a library, it will be much cheaper and much more useful that way.

they stick to s-expressions like they are the holy grail. We stick to s-expressions because they provide tremendous value. They are just more useful than traditional syntax.

they stick to the funny function names as if they were given by god. Common lisp has over a thousand symbols, and only a handful of them i would consider funny, and you are complaining about them? And you accuse us of nitpicking?

The rest of your rant is more of the same bullshit. How can you say you like lisp, and then continue to talk uninformed ignorant bullshit?


> instead lisp is still the language that it was 50 years ago.

I beg you to differ. The original, McCarthy Lisp was a succinct, powerful, flexible, dynamic language based on a small set of axioms.

Through times, a lot has been thrown out for sake of performance (which was understood to require compilation). Um, well, in case of Lisp, it means a lot of cruft has been added (some say, bolted onto) -- the simplicity etc.etc. was lost. Those days functions aren't even lists anymore, and scoping is lexical!

With a few notable exceptions. Which are either hold-outs, or back-to-the-roots/back-to-what-worked-better efforts.

Arc is closer to the original Lisp. Also, is more pleasing to use. Not a coincidence.


People keep saying that but i don't get it. Can you give me an example of the cruft you are talking about? Its one of those other myths i keep hearing about our cult.

p.s. Arc is more pleasing to use to you, I would certainly not choose it over common lisp or clojure, but maybe over scheme.


The existence of Clojure begs to differ.


yes the first step in the right direction. now give us (maybe optional) infix notation and get rid of the parenthesis (also optional). this could gain some momentum in the mainstream (but then lisp (or its successor (clojure++)) would no longer be the elitist language oh my!)


Simple syntax isn't about elitism. It's not like some evil Lisper, decades ago, figured ``I know! let's make simple syntax so almost nobody can understand or write it!''

The simple syntax of Lisp has only one purpose: easy programmatic manipulation (reading, writing, transformation). I.e., less boilerplate. Let me spell that out for you: EASIER MANIPULATION, LESS BOILERPLATE. Elitist much?

There isn't Yet Another Parser Toolkit Of The Week in the Lisp world, there isn't Yet Another Lexer Utility Of The Month in the Lisp world.

Seriously, writing a bunch of parentheses isn't much harder than writing intricate, complex C-like (C++, Java etc.) syntax structures. How the heck did simplicity became synonym of elitism in the subject of Lisp syntax?


Meh. So basically you're asking for "not Lisp"? There are plenty of languages which fill that role already.

See: many modern languages which have a functional influence but more syntax (Scala, Ruby, Groovy, etc., etc.)


thank you both for proving my point.


> now give us (maybe optional) infix notation and get rid of the parenthesis (also optional)

Ruby.

And it's not elitist - it's just not your taste.


See Dylan.


You can't spell "culture" without "cult" ;)


Taking yourself too seriously and being in a cult are two very different things. I agree that _some_ lisp people(even me at times) do in fact take lisp a tad too seriously, but i can't see how that makes you into a dangerous religious nut.

P.S. Im starting my own lisp cult, called the cult of the mythical lisp cult, our goal will be to find the holly grail of programming language flame wars: evidence of the mythical lisp cult. See, a joke about lisp, and its recursive too :D


> And calling a language community a cult is beyond offensive.

If we look closely, Lisp criticism is a kind of a cult too.

- Criticizing Lisp among them brings social validation

- They make lots of jokes about Lisp, but none about Lisp criticism

- Praising Lisp brings social exclusion

Therefore, Lisp critics are part of a cult. Like many others, they dislike what they don't understand.


Agreed. A rule of thumb I find useful: Any criticism of Lisp which opens with a joke about parentheses is quite likely to be flimsy and ill-informed.


"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."

This is bullshit. Python can also modify it's own code at runtime and yet it's one of the most package-complete languages. But it has a single defining implementation, so if you write your package, then every Python user will be able to use it.

Have a look at Clojure and the rate it's gaining new libraries. Lisp features don't seem to hinder that. A single implementation (and what follows - non-fragmented community) helps it greatly.


I suspect you're misunderstanding the logic of his point. He's saying that fancy feature X (runtime-modifiable everything) doesn't help with necessary feature Y (simple package management), and not that X prevents Y.

Clojure and certain Scheme implementations prove that X and Y are compatible, but most CLs have atrocious package management when compared with Python, Ruby or even Java. Lisp's extreme flexibility doesn't remedy that at all.


> Lisp's extreme flexibility doesn't remedy that at all.

Why would it? I'm not sure I understand the argument.

And also, just for an example: In my experience, Clojure's package management beats Rubygems for purposes of a project. You specify your dependencies and their versions (including the Clojure language itself) and a script updates them from the whatever repos you specify. It's taken the Ruby ecosystem some time to come up with RVM and Bundler which accomplish the same things. These kinds of things (package management) are available for Lisp languages today.

Of course CL only recently got http://www.quicklisp.org/ which seems to make some strides in this area.


Lisp can modify its own syntax at runtime, Python most definitely cannot.


because lisp does not have any syntax


Of course it does - it has a very simple syntax built around S-expressions and even that is extensible through reader macros.


Why is this downvoted? This is a fair thing to say. Lisp is basically an exposed Abstract Syntax Tree. Most languages get compiled down to something resembling a lisp before machine code. You could fairly refer to this as "syntaxless". It is just expressions in a tree format, not arbitrarily designed syntax for logic that must be stripped of its grammar for the machine to parse.


It's downvoted because it's false.

Try omitting parenthesis around your Lisp expression. Or try forgetting to balance your parenthesis.

Common Lisp has #: and : and :: and ` vs ' and #+ and #. and a whole slew of others.


Yes, obviously. There is no language that does not have a grammar. It's a requirement of all languages.

The point is, lisps have sometimes been referred to as "syntaxless" historically, for the reason that the grammar is that of the AST, not an arbitrarily designed grammar.

Ie. machine's grammar vs language designer's grammar.

You are right in saying it is not entirely correct to refer to them as syntaxless from a purely technical, linguistic point of view. But by throwing out his point as "technically incorrect", you are missing an important point about lisps.

Also, mentioning tokens that are used in Common Lisp doesn't quite compare to the verbose, heavily syntactical grammar of say, C++. Let me know the next time your lisp implementation throws you something called a "syntax error". You can't even get code to compile when you miss a parenthesis, which takes about three seconds to locate, tops.


you can write macros that handle that. in lisp everything can be code (or data). that is its greatest strength and its greatest weakness at the same time.


It sounds like he's criticizing Lisp for being prone to monkey patching, which would be a very poor understanding of metaprogramming in Lisp. From what I've seen Lisp ends up being perfectly clear about what is being called in what context. Clojure is especially clear with its namespace feature.


"it's own code " is always and only an abbreviation for "it is own code" which was not intended.


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.

Neil Armstrong did not convert to Islam; that's a fabrication.

Cite: Wikipedia makes no mention of this, and Google search reveals many people claiming it's a commonly-believed fabrication.


Wow, it's interesting how they haven't given up on Cat Stevens over the years. I guess they don't realize that the average youth these days doesn't even know Cat Stevens, let alone give a crap about him.


Come on, there are lots of self-deprecating Lisp jokes, my favourite being:

An elite hacker broke into a government system and found the code of a secret NASA project. He tried to download it, but the sysadmins noticed the intrusion and eventually cut the hacker off. He only managed to get the last 40 kB of the source file and unfortunately, because the project was written in Lisp, it contained nothing but closing parens.


Last time I heard it, the first half of the program was corrupted and all that was left was the second half, consisting entirely of closing parentheses.

Another version is that the file was stolen by a malicious hacker and help for ransom. As a proof he had the file, he sent the last part of the file. When one of the programmers saw only ")"s he knew the file was authentic.


Reminds me of the german professor, whose lectures would consist of 40 minutes of nested clauses, then a 20 minute list of verbs.


That makes no sense. Who downloads files from the end up?!


He had to download it into a linked list so it was only natural to download it from right to left.


Elite hackers from jokes?


Suspension of disbelief ruined!


Read the comment by Dan Weinreb. It is much more insightful than the article itself.


It's good, but the list of "success stories" that he links is not very impressive (scheduling software for NASA is by far the coolest stuff). Python has http://www.python.org/about/success/; Ruby has e.g. (early) Twitter and Metasploit; PHP has e.g. Facebook and a crushing market share; C has a zillion stories starting with the free Unixes. Yes, these languages have their issues. No, scheduling software does not beat Unix.


I'm glad Weinreb brought up extensibility. Almost every good idea from Lisp has been recognized and widely adopted over the last fifty years, but its remaining claim to uniqueness and power is letting you make effortless changes to syntax and evaluation. You haven't constructively critiqued Lisp if you don't address that head on.

As for "whatever you're reading this with [...] was written in a variant of C", well, yeah, that's why it's crap that blows up randomly. This is a problem that the industry is very slowly nerving itself to solve.


It's also almost longer =)


The article is based on an entirely false assumption about the nature of lisp culture:

“So, I can’t find any self-poking jokes about lisp. Self-deprecating Unix jokes, no problem. Jokes about frigging text editors, hilarious. But lisp has nothing but theological proselytizing.”

Richard Gabriel’s “The Rise of ‘Worse is Better,’”[1] while written from the perspective of a lisp lover, informs the “Why is lisp a failure?” question. Mark Tarver’s “The Bipolar Lisp Programmer”[2] is another essay the ruminates on the failures of lisp. And of course there’s the recently-posted-on-HN “How I lost my faith”[3].

I’m struck by how personally lispers take the weaknesses of lisp. In part because I feel the same way, which isn’t surprising given that I'm a lisper—bicycles saved my body, Scheme saved my soul—and have a problem with taking failure very personally.

In conclusion, I don’t think the author knows what he’s talking about.

[1]: http://www.jwz.org/doc/worse-is-better.html

[2]: http://www.lambdassociates.org/blog/bipolar.htm

[3]: http://groups.google.com/group/comp.lang.lisp/msg/6f75cfb5a2...


As a member of this cult with absolutely no sense of humor, I would like to mention that we drink very delicious Kool-Aid, and we are allowed to wear two different colors of sneakers. And after the comet we will join as a spaceship lands, I have been promised a cushy job at our destination. (secret-lisp-cult-message <COMPILED-LEXICAL-OBJECT PUBLIC-KEY>)


Very strange that he describes the MIT approach as "good" and the New Jersey approach as "not good enough" -- I have always understood them as "good" and "good enough". As in: why didn't we succeed? Because good enough was good enough.

Based on this misconception he draws the conclusion that the Lisp folks think the C/Unix approach is "evil", which is just silly. Maybe this is why he thinks it's a cult.


Surely this proves Lisp is a cult: http://pics.livejournal.com/codedot/pic/0002t3b1


gnosis: could you please break the usual `no editorializing the title' rule for once?

I believe it's interesting and informative and deserves more than a cursory pass, but without `Lisp' in the title, it's hard to spot.


I considered adding Lisp in to the title, but wasn't quite sure how to phrase it.

  "A Lisp cult I almost joined" ?
  "A cult I almost joined [Lisp]" ?
Also, there's something to be said for keeping the title as is, as it's a bit more mysterious.. and may pique the reader's interest to find out what the cult is. Putting "Lisp" in the title kind of spoils the surprise.


"A cult I almotht joined."


Lisp: a cult I almost joined (2005)


Alright. I like this phrasing. It is less mysterious.. but at least those interested in Lisp can find it.

You know, I was just thinking.. this is yet another reason for HN to allow tags. As with tags the title could remain untouched and we'd still be able to categorize it as a Lisp-themed article, and even that it came from 2005.


Uh oh, he's onto us with that part about the desire to make things easy. We'd better post a bunch more essays about how Lisp is a language for geniuses only. He hasn't caught on about macros yet, but its only a matter of time before he starts looking at his own code and thinking beyond the limits of what functions can do to help you not repeat yourself. And then the jig is up.




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | DMCA | Apply to YC | Contact

Search: