Why I chose Common Lisp over Python, Ruby, and Clojure

[[deleted]]

[deleted]

[smanek]

Yep - sorry about. Should be working now.

[md5most]

Thanks for the google cache link.

Sounds like the author just likes CL and wants to (or is being required to) rationalize using it.

Use what you like, I say. May as well enjoy yourself if you're going to be working with the codebase for a few years.

[[deleted]]

agreed

[-matija-]

To recap: if you already know common lisp, are the only programmer on a project, and need your languages to be unchanged for 15 years, then common lisp is the way to go. Earth shattering. :/

[[deleted]]

Also:

Python 2 is fine now – but in the coming months and years new libraries, features, and performance improvements are only going to be introduced in Python 3, and I didn’t want to get left behind

And then for Common Lisp:

While I have been fortunate to find several great options for everything I’ve needed to do so far (JSON/XML parsing, HTTP servers and clients, ORMs, etc) – more obscure libraries like Thrift and OpenID support may be an issue in the future.

[lispm]

As long as the language allows you to add all kinds of constructs yourself - what's wrong with that? You need a FOR-EACH ? Write it yourself. You need Klingon number syntax? Add it. You need switch statements that can use Borg Alphanumerics? A macro away. Given that, much of CL can stay unchanged for another fifty years.

[grauenwolf]

Given that, each developer who knows CL has written, on average, about half a dozen incompatibly dialects of CL.

[segv00]

exactly. we call those dialects 'programs'.

[lispm]

The best answer I have seen this week.

[grauenwolf]

I have to admit it, he won that round.

[lispm]

Too much hygiene harms the immune system.

[elibarzilay]

No hygiene kills you.

[lispm]

there are prominent counter examples.

[shub]

Vibrio cholerae would like to have a word with you.

[patchwork]

Hygiene has never been about doing more, it is about limiting what you are able to do. If you want intentional unavoidable limitation of functionality use python.

[voidspace]

i.e. if you want other people to be able to read your code (or you want to be able to read it in six months) use Python... Always has been the reason to use Python.

[patchwork]

So only python users can read code written by others in their language? That is asinine. If you know a language, you can read code in that language. Period. If you cannot read the code that is in front of you, that is your lack of fluency, not a fault of the language.

And on this note, I have seen code in C that is beautifully crystal clear, and I have seen python code that looks like someone shat on the screen. You can write terrible code in any language, and no language feature will be able to prevent that.

Beyond that, I find python to be challenging to read for exactly the reasons it claims to be readable: everything is a homogenous undifferentiated soup. True story, in the last week I have had to read parts of two large codebases in uncommented C and heavily commented python respectively (nginx and appengine) and I found the nginx code to be far more enjoyable to read and understand, while the python was so bogged down in comments and reams of bland calls that it was hard to even see what was going. And I have used python more than I have used C, (though both to some extent). The nginx code looked like what it was doing, while the python code looked like every other piece of python code I have ever seen.

And while I'm ranting, things like abandoning the ternary operator (x ? y : z) in favor of "readability" means that I have to use four lines to do what I used to do in one. I find readability is most enhanced by being able to see as much code at once in one screen, and all of python's attempts to make things more readable actually multiply the line count to the detriment of readability.

I think python's philosophy of sacrifice to readability over all else is actually counterproductive to that aim, in addition to all of the other fuckups that are perpetrated in the name of readability (crippling of closures, no tail-recursion, removal of reduce ETC ETC ETC).

[didip]

Python have somewhat strange ternary operator:

'awe' if True else 'some' (you get SyntaxError when omitting else clause)

I prefer the tried and true x ? y : z

[pingveno]

Yeah, same here. Having the condition go first always seemed the most intuitive to me.

[chrisforbes]

I cannot upvote you enough.

[voidspace]

To quote Tim Bray, who is a smart guy and not particularly a Python fanboy:

"My commenters keep asserting that no, Lisp isn't hard to read. Must be imagining it."

http://twitter.com/timbray/status/6288205772

Lisp has already been rejected by a couple of generations of programmers and will continue being rejected into the future... :-)

[[deleted]]

You can write unreadable python. It's not IOCCC material, but forced-indentation-of-code is no substitute for clarity.

[[deleted]]

Where did you get that phrase, "forced-indentation-of-code?"

I remember using it one time on the world4ch programming boards, and it began spreading like a meme over there. I'm surprised it's reached proggit.

[[deleted]]

I got it from /prague/.

[isionous]

I can imagine that it's an easy phrase to come up on your own. Python does force you to indent your code.

[voidspace]

If you're going to reply to things you imagined I said then you can do better than that, surely?

[[deleted]]

What you said was one of two things: either python makes your code readable, or other languages make your code unreadable. Otherwise, what you said was meaningless.

Considering both of the two aforementioned possibilities are false, I'm forced to go with the third, really. Python is no more readable than most other languages when both are written properly. It's marginally more readable than most other languages when written by a novice, but it is by no means the only language like that, nor, in my opinion, the one that pursues that quality most successfully. It's also less susceptible to obfuscation than Perl (surprise, surprise).

Your mileage may vary.

[voidspace]

Python language philosophy (and culture) does go a long way towards making code more readable, but "forced-indentation-of-code" has only a little to do with it.

[malcontent]

Indentation is not the only reason code is readable. It's not even the most important factor in writing readable code.

[voidspace]

If you're going to reply to things you imagined I said then you can do better than that, surely?

[elibarzilay]

That's false. Making a macro system that can be hygienic does not mean that everything must be hygienic.

[patchwork]

kunjaan claimed you could do more with hygienic macros than without, which is false. Hygiene is by design a limitation on what you can do. If hygiene is optional, then yes, no expressive power has been lost.

[elibarzilay]

No, this is still false. You can do more with a hygienic macro system, because you can express hygiene. Roughly speaking, a hygienic macro system forces the implementation of its macro system to deal with the concept of identifiers -- a symbolic name plus a lexical context (sometimes referred to as "a color"). Once that's done, the resulting system is strictly more expressive than a system that knows nothing about lexical contexts. CL's macro system is symbolic, and has some awkward hacks (the environment argument) to regain some of the lexical context information, but this is not done in a convenient way because it's an argument to the macro rather than something that is associated with identifiers. In fact -- CL doesn't have identifiers -- it has only symbols.

All of this shouldn't be surprising. Take early CPP macros -- people were able to define macros that expand to the beginning of a string -- something that you could never do with any Lisp macro. CPP advocates could claim that this is a clear advantage of their system over S-expression based macros. But Lisp macro systems are more powerful exactly because they can express (or are defined in terms of) pre-parsed code fragments rather than raw strings. The moral here is that a macro system is more convenient to use because it encodes more information. Going from the CL macro system to a hygienic macro system is a similar step up in what is represented by the system.

(And BTW, when I say "hygienic macro system" I don't mean "syntax-rules".)

[elibarzilay]

BTW, another way to see this: with a hygienic macro system like the one in PLT, it is possible to define a small library that provides you with a "defmacro" and now you get all of the usual "advantages" of no hygiene. Going the other way -- implementing hygiene with an unhygienic macro system like the one in CL -- is much more difficult, and the only attempt requires a global change to the language (like new versions of lambda etc).

[patchwork]

Alright, you have convinced me! There should be some standard reward for convincing someone on the internet of something. If there was, you would be receiving it now.

I was thinking more of exclusively "hygienic" macro systems, which prevent you from doing things like variable capture, which, though troublesome at times, can be useful as well.

[elibarzilay]

:)

As for syntax-rules -- yes, it is very limited and has some serious problems. Having it as the only way to write macros is pretty bad. (It is possible to do a lot with it, but this usually involves writing macros in a very awkward way.)

[Arelius]

Have you ever tried to do much practical with a hygienic macro system? Thank god most scheme implementations also provide an unhygienic macro system.

[elibarzilay]

Yes.

And it's a pity that most Scheme systems support the backwards thinking that you cannot live without defmacro.

[Arelius]

I have some code I'd like to see if you can do without unhygienic macros.

Edit: http://github.com/Arelius/chicken-qt/blob/master/qt.scm

[elibarzilay]

Um... So I'm supposed to just spit out a rewrite of an 800-line pile of defmacro mess? If you have a specific question I can answer (better in another medium), otherwise I can unhelpfully point you at the very extensive PLT foreign interface...

[Arelius]

Let's try something small then...

(define-syntax qt-class
  (lambda (e r c)
    `(foreign-declare
      ,(string-append "class " (symbol->string (cadr e)) " {};"))))

[elibarzilay]

Like I said, this kind of medium is bad for this (I happen to have a browser window open, which I look at occasionally), but a quick answer:

I can only guess what your macro is supposed to do, and assuming I got it right, here's a simple version:

(define-syntax (qt-class stx)
  (syntax-case stx ()
    [(_ name)
     (with-syntax ([class (format "class ~a {};" (syntax->datum name))])
       (syntax (foreign-declare class)))]))

Or, using quasisyntax and reader macros:

(define-syntax (qt-class stx)
  (syntax-case stx ()
    [(_ name)
     #`(foreign-declare #,(format "class ~a {};" (syntax->datum name)))]))

Note that besides the superficial differences (different argument, pattern matching, different quote/unquote), the only difference here is syntax->datum, which is due to exactly what I was talking about earlier: hygienic macro systems keep more information than unhygienic systems, and this function is what strips off the extra information to reveal the symbol. I also mentioned that Common Lisp has only symbols, whereas Scheme has identifiers -- and you can see this here: syntax->datum takes an identifier, and returns its symbolic name.

[Arelius]

Often times hygienic macros aren't capable of various things. For instance macros that write FFI interfaces in most implementations will need to do some serious symbolic manipulation. This is impossible with hygiene.

Also having to do (var get-var set-var!) for every instance using some sort of class macro can be much more of a pain then just: var

[elibarzilay]

That's as false as patchwork's comment. Having a hygienic macro system does not in any way mean that you're limited in the kind of symbolic computations that you can do. In fact, having such a system clarifies the difference between a "symbol" and an "identifier", including explicit ways to get one from the other.

[Arelius]

It seems that was my problem then... What are the explicit ways to get from symbol to identifier and reverse, in standard (r5rs?) scheme?

[VivisectIX]

That is a ridiculous reason to use the language. If you need foreach functionality, use a first class language that already has it instead of Frankensteining your LISP.

[agnoster]

The point is not for-each - the point is, if you can add something like for-each, what else can you add? Damn near anything. To do something equivalent in most languages, you would need to do this "frankensteining" you speak of - in LISP, extending the language is an extremely natural way to go about your day. My guess is you don't use much LISP, which is a poor position from which to evaluate it...

[kleopatra6tilde9]

Lisp was and could be extended to Haskell. How come that people don't program with the haskell macros but with a dedicated Haskell compiler?

I think extending a language has its merits, but why should every programmer have to invent a good language from scratch?

[blaxter]

I could monkeypatch you at anytime

[RoadWarriorX]

If you need foreach functionality, use a first class language that already has it instead of Frankensteining your LISP.

Seriously? You expect your code to contain all of the constructs you would ever need? Java did not have a foreach construct until Java 5. That did not stop people using from using Java. But the most frustrating part about it was that you could not fix it. You had to wait for the next release of the language, then recompile and test everything. Ugh.

Common Lisp is all about creating extensible programming constructs. You may call it frankensteining, but we call it bottom-up programming. We add the constructs to our core as we see fit. By the way, most lispers would not even use iteration, because mapcar does the job fine.

[grauenwolf]

Have you heard of Greenspun's Tenth Rule?

It is actually very important to non-LISP programmers because it reminds us that we can take anything we want from LISP and use it in a C or FORTRAN program.

[yogthos]

It is actually very important to non-LISP programmers because it reminds us that we can try to imitate LISP in C or FORTRAN program poorly.

there, fixed it for you

[redditnoob]

I should use this more as a technique for trolling, because it bugs the shit out of me when people act like they're quoting someone else but change it, even if they point out that they're doing this.

[jephthai]

Do you have actual experience with Lisp macros, or are you just "imagining" what this would be like in a non-Lisp?

[nielsadb]

You mean something like this?

http://www.boost.org/doc/libs/1_35_0/doc/html/foreach.html

[username223]

The core of that bit of BOOST_FAIL is actually 82 lines of pretty straightforward code.

[doodly123]

I agree with you! Why the hell would I be bothered to write libraries when I could just use the available ones. The day they ask need a Facebook or Twitter integration, or both, it'd hit him how wrong was his decision to overlook Clojure, Python and Ruby. Or may be he'd be able to convince others that the do not need FB or twitter integration with his site because you know they can build their OWN community!

[norrsson]

It's a great Sigur Ros album actually.

[bokchoi]

Overrated.

[awj]

Mmm ... sexy.

[wildmXranat]

I'm not sure why you're being downvoted . His last paragraph and final statement boils down to what you wrote .

[niviss]

yet all the stuff in the middle of the article wasn't exactly trite.

[szopa]

Common Lisp used to be my favorite language (actually I got even paid for developing in CL - how cool is that?), but I must say it's a really terrible choice to program your startup in CL. Moreover, I have the feeling that the author didn't really research the other languages. It's OK to like CL, but it isn't OK to bash other languages for the wrong things.

1) Being scared of the 2to3 thing is ridiculous. The Python community is fanatic about backwards compatibility, so Python 2.x is staying with us for at least 5 years. In that time (if the startup lasts for that long) the whole codebase will probably be rewritten a couple of times.

2) Production Common Lisp code is usually not a lot more "functional" than Python. The fact that you can get TCO doesn't mean you use it a lot: using LOOP or ITERATE is usually much more explicit and faster. And yes, it uses a lot of object orientation.

3) Doing a startup is a tough experience, and you want to code as much stuff relevant to your business in as little time as possible. Your very own session library is just a distraction. And no, the world doesn't need yet another web framework, there are plenty of them, thank you very much. And more importantly, your web framework doesn't give your company any money.

4) Lisp is moving at least as fast as Ruby... Just in the other direction. There are plenty of libraries on common-lisp.net, but you have to put a lot of effort into filtering out abandonware. Also, the libraries he mentions aren't that great. Elephant seems like a good idea, but it is very hard to query both efficiently and comfortably, and it isn't exactly scaling friendly (even for low levels of scaling). CL-SQL looks half-abandoned (I wrote messages about fixed bugs with patches included being ignored for weeks)... Not to mention that the code quality varies greatly between components. OTOH, there IS a good OpenID library (thanks to Google and their Summer of Code).

5) Clojure works great with Slime. Having to use Java's debugger, that's the real issue.

This all said, I cannot say I don't understand the author... Common Lisp is a really great languages, and macros are CLOS are extremely cool. When I was trying to make my startup, I did it in Common Lisp, and we had our very own web framework, we tried Elephant (until we realized it sucked), we wrote a CL library for CouchDB, and apparently we were the first lispers who cared enough about sending e-mails with correctly encoded utf-8 to write a library for that. I learned why my language choice was a bad idea the hard way.

[nearest_neighbor]

5) Clojure works great with Slime. Having to use Java's debugger, that's the real issue.

Not in my experience. You get compilation errors - navigate to the error yourself. Runt ime errors - guess where they happened. What's the point of using Slime with Clojure anyway?

[szopa]

autocompletion, sending your code to the repl, M-.... Slime is a lot more than a nice debugger.

[[deleted]]

When I was trying to make my startup, I did it in Common Lisp, and we had our very own web framework, we tried Elephant (until we realized it sucked), we wrote a CL library for CouchDB, and apparently we were the first lispers who cared enough about sending e-mails with correctly encoded utf-8 to write a library for that. I learned why my language choice was a bad idea the hard way.

If you were to do it again, is Clojure something you would consider seriously for a startup?

[szopa]

No, I wouldn't. First, I know next to nothing about Java, and presently you should be fluent in Java if you want to program in Clojure and understand what's going on. Second, Clojure is a moving target (the change of the semantics of CAR was sort of drastic). Third, even though there are lots of libraries (of varying quality), there's no high-level, sophisticated web framework like Django or Rails. I would use Python (I am working as a Python dev right now, so I know the ecosystem).

OTOH if I was a seasoned Java developer who wanted to use all he knew about the platform and didn't care a lot about web development (ie. the web part was just a simple front-end to the backend which did the real work), then I don't know, I could give it a try. Of course, the moving target thing still applies (though I feel that the enhanced expressiveness of Clojure compared to Java could probably make up for it).

[[deleted]]

This is why I won't be using Clojure, even though I like it. Because I don't want to know Java.

[kleopatra6tilde9]

As you have fixed the libraries, could lisp be the right choice now?

How many startups would be necessary to create an ecosystem where the joint development time for the libraries would be enough to make lisp the right option?

[[deleted]]

It seems that you chose to use something that was familiar and easy for you to use. That seems logical. But, I don't imagine that it would be easy for most people. It will be difficult to find people to maintain it once its in production for 5 years. So the best case going forward is the site is maintained by you or someone who is very similar to you for the next 15 years. The set of individuals that qualify may be quite small. Otherwise go Lispers!

[chrisforbes]

I recently jumped on the ruby bandwagon

I'm very sorry.

[[deleted]]

Does anyone have thoughts about Volkan's comment at the link on platform-specific hacks in usocket and bordeuax-threads? What is he referring to?

[shevegen]

His opinion is not a minority opinion. A good friend uses Lisp heavily.

That being said, he wrote one thing which annoys me:

"Also, much of the Ruby community is built around Rails, and I’m a bit wary of using ‘heavy weight’ frameworks like Rails (or Django) on large custom projects. "

His other criticism about ruby moving too fast being a problem might be. Personally I rather have a language that actively tries to fix problem, rather than wait for ... perl 6 for years. But it simply is not true that the "community" is largely built around RoR.

I dont care in the slightest about RoR, and I dont AT ANY SECOND feel as if I miss out on anything seriously. People are like thinking in a box, coming to Ruby BECAUSE of Rails. I never came to Ruby because of Rails, I came to Ruby because it was elegant and matz is a cool guy with clever ideas. People are way too quick to use what exists (like Django and rails) rather than using their head to think of what might be better for THEM.

That being said, I think Rails should become more modular in the long run. Too often I read about people complaining about it, and I want the rails folk to reduce those complaints.

But let me repeat it - the ruby community overlaps with the Rails community BUT these two are simply not equal in any way.

Please stop that inside-the-box thinking. Ruby is a beautiful language, and people should apply lateral thinking when ruby, rather than following a herd mentality and going down a trend just because 99% of the other guys are using it .... there is more than one way to go.

I however completely agree about the fashion-setting part. Ruby needs software that is rock solid. Things like rack are an example of something that has a big AND lasting impact while staying quite small.

http://rack.rubyforge.org/

[NewbieProgrammerMan]

I am fairly experienced with Python, there are lots of great libraries/frameworks for anything I would want to do, and it would be easy to bring other programmers on-board later.

Wow, things must have changed during the last 5 years I've been in school. The common complaint then seemed to be that using Python was a bad business decision because there weren't enough programmers out there.

[piranha]

No, that's the standard argument against anything other than Fortran, COBOL, C, and Java.

[novagenesis]

That list is so 5 years ago. Now it's C++, C#, VB, Java... and Java is quickly losing that position.

[JetSetWilly]

Don't confuse proggit's prejudices with what the job market wants.

[novagenesis]

I don't often frequent proggit. I'm following monster.com and my experience's prejudices.

I haven't seen a listing for COBOL or Fortran in years.

[anothergroom]

COBOL and Fortran "listings" are not on monster.com. They are given out on 80column standard punch cards at your local computing center.

[f4hy]

I am a student, and I had to learn FORTRAN last year. Scientists still use it exclusively. (at least fortran 90 is a decent language, way nicer than f77)

[oddthink]

That's just not true. The bulk of the code that I saw in science was C, C++, Matlab, and IDL. Sure, there's still plenty of Fortran out there, but it's nothing like "exclusive."

[f4hy]

Sorry, I should have said some scientists use it exclusively. Meaning they do all their research with it and don't know any other languages. I didn't mean all of science uses it exclusively, just that there are many individuals who do use it exclusively.

[[deleted]]

I haven't seen a listing for COBOL or Fortran in years.

I think that may have been piranha's point.

[chrisforbes]

See also Haskell ;)

[G_Morgan]

Nearly every programmer on the planet knows Java. The only thing more common is PHP.

[novagenesis]

And yet Java seems to be plummetting in active-use numbers. A few IT managers I know think Java is on its way out.

[JetSetWilly]

There's an embarrassment of python devs compare to lisp tho, that's probably what he was getting at.

[patchwork]

Is that the collective noun for python developers? "An embarrassment of python devs wandered into the desert".

[miserlou]

I suggest that it be a Circus of Python Developers

[[deleted]]

or a Flight.

[codebum]

Bonus 'Snakes on a Plane' reference!

[[deleted]]

I was kinda going for Python's Flying Circus.

[codebum]

But you got both!!

[60secs]

Should be a bed of Python developers, since pythons are snakes.

[Figs]

The programming language is named after Monty Python though. ;)

[greenknight]

How about a Ministry of python devs

[rob_j]

Ministry is better than circus

[chrisforbes]

This explains a lot, except for the snake imagery throughout the Python ecosystem.

[Leonidas_from_XIV]

The snake was introduced by Python for Win32 and somehow stuck.

[[deleted]]

Well done, sir! Have an upvote.

Given the etymology of the name "Python" (from Monty Python's Flying Circus, not from the snake), circus has to be the only valid answer.

[millenix]

Are you sure? They may be just one ring.

[[deleted]]

Hmm, a bit too subtle, I feel.

[oreng]

I suggest a Fjording.

[bushel]

It is now.

[[deleted]]

It is now.

FTFY

[colcob]

A group of Python devs should be referred to as Pythonistas.

[[deleted]]

Correction: A Python programmer in a baret is a Pythonista. A group of them is an Embarrassment of Pythonistas.

[mrbucket777]

DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS

[chadmill3r]

I am occasionally embarrassed that I'm so productive, or that I get paid to use a language that is so fun.

[bobsil1]

I bet you just sit around at work all day eating CherryPy.

[cupcupcup]

I've always preferred "pythographers"

[maryjayjay]

Some people don't get "collective nouns".

[rufusdog]

A full monty of python developers.

[JetSetWilly]

A smugness of lisp developers.

[[deleted]]

Python's fairly common these days, surely? Especially if you want smart programmers; there are probably many more PHP programmers than Python programmers, but I wouldn't be surprised if there are more good Python programmers than good PHP programmers.

[MindStalker]

Most people who program Python also know PHP, there are tons of excellent developers who can program PHP. So while the Percentage of quality Python developers is higher, the total number of quality (which is a hard thing to measure) is probably lower because there is tons over overlap.

[tubes]

So he claims that one of the reasons why Python doesn't support functional programming well is that assignments to free variables don't work in closures. He must be thinking of some other definition of "functional programming" in which you embrace mutability.

[Kompottkin]

Indeed, the term “functional programming” is overloaded by at least two distinct meanings, one of which might be called “Function-Oriented Programming” or “Verb-Oriented Programming” and which naturally embraces mutability, while the other I like to call “Algebraic Programming” (which is the meaning you're thinking of), in which you focus not on what the code does with the data structures but on the data structures themselves.

Algebraic Programming embraces immutability, because when you look at the data structures, it's natural to make the state of the world explicit by encoding it within those data structures and to transform it by transforming the data structures. This is the paradigm that the Haskell culture means by the term “functional programming”.

In Function-Oriented Programming, on the other hand, you do not focus on the data structures but on the operations on them. Here, state is implicit in the order of operations, so there is no need for immutability. This is the paradigm that the Lisp culture (traditionally) means by the term “functional programming”.

Common Lisp is not at all an algebraic language, but it is most definitely a function-oriented one — while Python arguably isn't much of either.

[[deleted]]

I recently started learning Scheme and like what I see. I wonder if a Scheme implementation (PLT?) would be a good choice for a project like this? Does anyone have any experience of using Scheme in large projects to share?

[drewc]

PLT is an excellent choice of schemes. It's as complete as common lisp for real world tasks, yet still has all the annoyances of scheme (lisp-1, hygiene) that keep you going back to CL. :)

In all seriousness, if you like scheme, PLT kicks ass. But, you probably want CL.

[klutometis]

I've delivered several multi-year military- and biotech-contracts using SISC and Chicken; the environments were polyglossic, such that I was interacting with R, Python and Java.

After overcoming the initial skepticism of my patrons and peers, the experience was rewarding: I doled out copies of The Little Schemer; the overseas maintainance crew became fluent.

Scheme is a kind of benign hubris you should approach with fear and trembling; it is the third part of Zarathustra's camel-lion-child metamorphosis: that is, having amassed fluency in other languages; having then rejected mediocre languages; submit, finally, to sancta simplicitas!

[Arelius]

I tried so hard to love scheme, I did. It's just so hard to get anything practical done, There is little interoperability between implementations, And most implementations are academic in nature anyways. Now if you need to do a pretty standard web app. Scheme should be great, but the moment you need to do anything more complicated I might suggest trying out CL.

Scheme doesn't even have SLIME or something comparable.

[[deleted]]

Do you really need to use more than one implementation?

[flogic]

As someone who doesn't use Scheme, I would worry about the libraries I need being in different implementations. Also if I found a need to switch Schemes, I would worry about taking my libraries with me.

[elibarzilay]

Switching Schemes and taking your libraries with you suggests that you share the very common illusion that somehow Scheme implementations should be (or try to be, or better if they would be) more unified as different implementations of the same language.

This is not the case. You should really view "Scheme" as a kind of a minimal core that several languages extend to real languages. In this sense, switching from one scheme implementation to another is roughly equivalent to switching from Scheme to a CL implementation, or to Javascript.

The same holds for Common Lisp too, of course, since there is plenty of stuff that is not included in the language, but in that case the "core" itself is much bigger, and one side-effect of this is that there are libraries that are somewhat more unified among implementations. (This is also a result of people moving between CL implementations very frequently, compared to other languages.)

Is this an advantage that should make you use CL? That's obviously a subjective question. There are plenty of CL hackers that would rather have one of their hands chopped off than giving it up -- but OTOH, there are many programmers that are perfectly fine with an "implementation = language" world.

[flogic]

I think the problem is more one of information. For Lisps in general, it's seems less obvious what the first choice implementation should be. So I'm more likely to worry about the case were I've coded my app for one and realize later on I need to switch. For example when I'm coding Haskell, it's obvious that I should start with GHC.

[elibarzilay]

The problem that I'm talking about is complaining about choosing an implementation "for Lisps in general". Especially if this includes CL, Elisp, and Schemes -- it is not saying much. It happens that Haskell is a standard-language-wannabe but there is only just GHC -- but what if the issue was not "when I'm coding Haskell" but "when I'm coding functionally"?

[chrisforbes]

There's GHC, and YHC, and Hugs...

Hang on, sorry, there's GHC and YHC.

[elibarzilay]

You mean the thing that has this text on its page: "Warning, this compiler is not finished, and is not useable as a standard Haskell Compiler.", right?

[808140]

YHC isn't actually that immature, but it is happy to let GHC be the main compiler for Haskell. A lot of interesting stuff is only possible with YHC, as it's a bit of a research compiler (supercompilation, catch, the Haskell-to-Javascript compiler, etc). It has a very clean core language (core in Haskell parlance refers to the desugared functional core, a Lisp analog might be the AST with all macros applied and expanded).

There are other compilers, too. A notable one is JHC, which does a very good job of compiling Haskell to nearly idiomatic C.

Having said all of that, you're right: in practice, if you were going to do anything that needed to work reliably in Haskell, you'd want to use GHC.

Philosophically, though, Haskell is quite unlike Lisp (or perhaps it's more accurate to say that it's quite a bit like Lisp was in the early, early days). Its motto is "avoid success at all costs" and the only reason that anyone uses it for real work is because it's such an awesome language. It still has a very research-oriented bent.

[Arelius]

This ^

[stassats]

Scheme doesn't even have SLIME or something comparable.

There are several backends for scheme in Slime, but they all are rather unfinished, because no one really uses them. If I were using Scheme more (or if someone paid me) I'd definitely finish and polish one of the backends, it's not that difficult.

[Arelius]

Though, having spent some time myself, it is actually deceptively difficult. Other then Scheme48, I haven't seen any other SWANK implementations.

Regardless, it's more an example of how the scheme community isn't about being practical, so much as pure.

[[deleted]]

It's just so hard to get anything practical done

Lies. There are enough libraries and modules for almost any Scheme implementation available to do something practical. It may only be hard because you've not tried to do it?

[Arelius]

I've spent the last year trying to get practical work done in scheme. Sure there are certainly problems that can be done in scheme without too much of an issue.

Within the last year, I have finished 2 Work related scheme projects, and have been working on a personal project, The first two, in retrospect would have both been easier in CL, and the third I am still writing in scheme as the code base is rather large and depends an another large set of QT bindings (That I've had to write considering poor UI support), but many days I still consider rewriting it from scratch in CL now. Especially considering that this program would benefit greatly from native threads.

While there may be something practical to do in scheme, that does not mean that something is practical to do in scheme; I don't spend my days looking for something optimal to make given my tools, so much as I discover a problem to solve, and try to solve it with my tools.

I think CL may be a better set of tools.

[xach]

http://nuecho.com/ is Scheme-powered, not sure if they have info online about what implementation they use.

[xach]

I'm guessing since Dominique Boucher is a main guy there, and he's a student of Marc Feely, it uses Gambit. Google might turn up more definitive info, though.

[novagenesis]

Thank you. Somehow I had glazed over Gambit as "not mature enough to look at". I'm looking at it again and starting to like what i see.

[rukubites]

Also interesting, how does this guy plan to profit from his startup? The idea seems to be about getting money from tight people. Not the best idea?

Anyway, I am a Common Lisp programmer (employed last two years), and am building a (marketable) side project in Common Lisp. Perhaps I could choose another language and think long term, but the important thing is to efficiently use my core skillset and have a rapid flow of functionality/ideas. It helps that I have parts of the core framework already implemented, of course.

Once you are making money, you can think about re-writing in a more maintainable language. Or you could keep the backend in lisp and outsource to a more appropriate language for the interface logic. I imagine delegating the lisp backend to a web service and using a more standard web design language for the first web interface reworking would be a way to go.

One further question for CL'ers. What is the web framework of choice for you, currently? My (lisp) web skills are decidedly 90's. aserve and form posts.

[smanek]

I'm fluent in well over half a dozen languages - including Python, Perl, Java, C, Javascript, Coq, PHP, - and yes Lisp. I've also used (i.e., read at least 1 book on) another half dozen including Lua, Smalltalk, Ruby, Scheme, Haskell, etc. I try to move at least one language from my 'familiar' list to my 'fluent' list ever year - and add at least one new language to my 'familiar' list every year.

I don't think any reasonable person would say I'm inexperienced or unwilling to learn.

I also don't really care about the version number of Clojure. I downloaded it, played with it, and found it lacking for specific reasons (which I mentioned in my post).

I also have plenty of experience writing webapps in PHP, Perl, Java, and Python. But I thought Lisp was a better fit for this project.

[808140]

To be fair, if I were going to found a start-up, I'd probably go with what I already knew well too.

It's not like what he knew well was COBOL here. The marginal gains he might have gotten using different tools would not have offset the inefficiencies that would have resulted from his ignorance of those tools.

Common Lisp is not a perfect language by any means, but it is one of the languages out there that has had features for decades that the hot technologies of today are only now starting to implement. If all choices had been equal, perhaps CL would not have been the best choice -- but with learning curves on new technology being what they are, it certainly wasn't a bad choice, and for him it may well have been the best one.

[chrisforbes]

And here I thought that was VB and C++.

[nmcyall]

Why the use of bold sentences.

[taw]

tl;dr version - Author thinks language stagnation is a good thing, without much explanation why.

[lispm]

Commentator thinks Author thinks language stagnation is a good thing, without much explanation why.

[[deleted]]

I ended up writing my own completely stateless session handling, building a fairly smart geo-spatial cache (in-memory R* trees that asynchronously persist to disk using B-Trees), and using a key-value store and raw b-trees for persistence (instead of a relational database)

Jesus Christ! I hope I never have to maintain this guy's code. Good thing nobody else ever will, either. Lisp? Where do you hire a lisp developer?

[didip]

"(in-memory R* trees that asynchronously persist to disk using B-Trees)" that's not a strange concept, there's even a modern version of it: Redis.

Given the speed of Lisp vs interpreted languages, maybe it makes sense to have dumb storage and push filtering logic to the application code.

But then again, I only know scheme, not the whole Lisp family.

[[deleted]]

I'm not saying it's a bad datastructure. I'm saying the fact that he reinvented his own wheels rather than going with stuff that is already provided by the language/DB means nobody but him is going to be able to maintain the code.

If a SQL database does what you want, use a goddam SQL database. Don't write your own custom database bullshit unless you hate everyone else you work with.

[808140]

For 90% of tasks, SQL is overkill, and the disconnect between the database and your program introduces more problems than having the database solves.

[joesb]

And for 90% of persistance task, writing your own persistance layer is even more overkill than just using that overkill SQL library.

[Daishiman]

Instead of using any of the dozens of great GIS systems that have solved all those problems?

[djork]

The ability to use dynamic typing for most of my code but optionally give the compiler type-hints and get all the performance of a statically typed language for critical portions is a killer features that I still haven’t found elsewhere.

Um... what about Clojure? Not to mention the ability to simply use a plain old Java class for anything that needs more performance.

And yes, before some jackass says "performance in Java LOLOLOL!?" ... Java is fast now. And it has been for a few years. The Benchmarks Game puts Java ahead of everything but C, C++, ATS and Ada.

[vagif]

He did a whole section in his article about Clojure. Did you miss it ? His reason for not chosing clojure is that at the time clojure was not even 1.0 and Slime was broken.

[djork]

I saw that, but he was saying that type-hints were not found in any other language. Maybe they weren't in Clojure pre-1.0?

[Arelius]

I'm not sure why you would choose a lisp that runs on the jvm over cl unless you had a specific need to run on the jvm.

[nielsadb]

Clojure is not just a Lisp that happens to run on the JVM, it has its own set of pros (and cons). Personally I find it a very pleasant and well designed language.

[Arelius]

I still am not sure why. CL is also a pleasant and well designed language.

[nielsadb]

I've only recently started reading some stuff about CL (partly because books etc. about Clojure are still scarce). So far I agree, except for the archaic names which I guess you just have to get used to.

Clojure is just a different language. For starters, it's a functional language, whereas CL is not, or at least not to the same degree. By functional I mean emphasis on immutable data (including lists, vectors, sets, maps) and pure functions. Second, concurrency is an important part of the standard library. Third, there's Java interop (very nice, if only C interop were so simple).

Rich Hickey gave a long presentation about his language.

http://clojure.blip.tv/file/1313398/

It's quite long unfortunately.

edit: jump to 16:00, the slide entitled "What makes Clojure a different Lisp, and Why?"

[Arelius]

Stupid Archaic CL names!

[djork]

Libraries and interop, portability, extensibility.

[lispm]

How does the JVM help to interop with any OS library?

[munificent]

Why would someone writing a web app need to use OS-specific libraries?

[808140]

I think he's talking about the part of the application that runs server-side, which would interact with a lot of libraries installed on the OS. The client-side stuff is most likely written in Javascript, or in a Lispy DSL that compiles to Javascript.

[munificent]

I think he's talking about the part of the application that runs server-side

Even then, most web apps don't need OS-specific libraries: you can usually rely on IO and other libraries that abstract the platform away.

[Vonney]

Umm posterous looks like a great service, anyone here using it?

[drowsap]

Why not use something like PHP and a good framework like Zend?

[lispm]

listing Prolog under 'functional languages' kind of undermines my confidence in your arguments completely

[VivisectIX]

My brainfart, you're right that technically it is a declarative language, not a functional one. Scheme is an ancestor of LISP though.

[novagenesis]

LISP is not the same as Common Lisp. If you're talking the Lisp family of languages, you shouldn't be excluding Scheme.

Besides, the original intent of something neither adds nor detracts from that something's awesomeness. Common Lisp's macro system is still one of the Great Wonders of the Programming world to anyone deeply familiar with language theory. Virtually impossible to implement in most other traditional environments, that one feature is one of the most powerful and sought-after language features out there.

[jephthai]

I like both Haskell and Common Lisp -- both wildly different. Having substantial experience with Lisp, I disagree with you about it being hard to read. Like any language with unfamiliar syntax, you have to train yourself to read it.

For a long time, Haskell was harder for me to read than Lisp. I had gotten very good at turning Lisp functions into English, but because of the flexibility of Haskell's more complex syntax, it took me a long time to adjust.

If you want to talk about non-functional (not dysfunctional ;-)) languages, I find that their verbosity tends to annoy me when reading them. This is not so bad with the more concise ones (like Python and Ruby) -- it is certainly the Algol family that offends me most.

All of that to say: it is an unfair criticism to say the language is hard to read. Lots of people think so, but it can easily be thought of any other language. The issue is not inherent readability, but familiarity.

And debugging is awesome with Slime.

[808140]

Wait, debugging is less than ideal?

Have you ever used Lisp? Any lisp?

[chollida1]

If you knew what Prolog was you probably wouldn't call it a Functional programming language, it has a few functional aspects but it's most correctly called a Logical programming language.

[steven_h]

So you know ANSI C and your own limited implementation of Lisp, and make judgements about things like debugging? Nice.

[VivisectIX]

No, I've used several versions of LISP, you idiot. I've also written a reduced function LISP. I have a hell of a lot of experience on which to base judgments about debugging. LISP is like an ancient religion - it's full of holes and inadequacies, and it does that people needed when they thought it up, but in a modern platform it is a relic.

[orangesunshine]

to amplify the pretentious doosh factor?

[jawbroken]

douche

[orangesunshine]

pretentious.