News for hackers. Stuff that matters.
Re:How Python is killing Lisp by megaduck on Saturday December 12, 2009 @08:55PM (#992239)
Disclaimer: I'm still a total lisp newbie, take all of this with a grain of salt.

As I see it, the biggest hurdle to learning LISP isn't the syntax per se. Lisp's syntax is so simple, it's easily learned in a matter of minutes. The whole language basically boils down to lists and dotted pairs, and lists can be boiled down to dotted pairs if you squint at them the right way.

The real obstacle for newcomers is that you have to completely rewire your brain. The vast majority of us were taught programming with BASIC, C, Java, or something similar. With those languages, programming is like following a recipe. Do step a, then do step b, etc. Moreover, imperative languages use a familiar "verb" and "noun" paradigm. That's natural and intuitive to most of us.

With lisp, everything gets turned on its head. Everything happens at once. Code is data. There's no syntactic sugar because there's no syntax. You have to completely relearn how to look at computers and programming, and start over as a child. It's incredibly rewarding once you start having those "aha!" moments, but there is a decent-sized conceptual hurdle for people that are used to procedural programming languages.

It seems that the majority of the lisp community suffers from the curse of knowledge. For experienced lisp people, lisp is so natural and intuitive that it's hard to understand why other people have such trouble with it. The OP is correct, lisp could really use more resources to bridge the gap between lispers and the outside world.

Re:How Python is killing Lisp by viraptor on Saturday December 12, 2009 @09:09PM (#992257)
I see it a bit differently. I had to learn enough lisp to port some small application I needed to python. The result is basically this:

I don't have any problem learning the syntax - I didn't have anything against ml-s, haskell and others either, even though I started with pascal. But what do I gain by using lisp seriously? I can do easy prototyping in python; safe, functional code in haskell; serious multiprocessing in erlang; fast tight-loops in c; nice oo in either python, c# or java, etc. etc. Why exactly should I spend more time with lisp? What does it help me achieve? Python right now is basically lisp + community from what I can see. Sytax doesn't even matter that much.

If I need to rewire my brain to feel natural with a language that doesn't give me any new possibilities... then what's the point? I need those wires to understand haskell, sorry ;) I just need some balance - I can change the way I write my code, but tell me what do I get in exchange... and then tell me how is it better than doing the same in any other language.

Re:How Python is killing Lisp by geocar on Saturday December 12, 2009 @09:27PM (#992276)
> I can do easy prototyping in python; safe, functional code in haskell; serious multiprocessing in erlang; fast tight-loops in c; nice oo in either python, c# or java, etc. etc. Why exactly should I spend more time with lisp?

Because I can do easy prototyping in lisp; safe, functional code in lisp; serious multiprocessing in lisp; fast tight-loops in c; nice oo in either lisp, lisp or lisp.

If you find a problem that needs a new paradigm, you either need a new language, or you need lisp.

> Python right now is basically lisp + community from what I can see.

Python is a great language. It supports a lot of the most useful and powerful paradigms that lispers use, so many lispers like it and use it.

But python is not "basically lisp", simply because it lacks the property I mentioned earlier.

Re:How Python is killing Lisp by viraptor on Saturday December 12, 2009 @09:54PM (#992310)
By "safe" I meant "static type-safe" - sorry for the confusion. And no - can't do that in lisp.

What do you mean by serious multiprocessing in lisp? Does it have a distributed database included? Or a node registration and message passing framework? Or a process control framework? Can it run my 10000 processes? Does it have portable networking and thread implementation where nothing ever blocks... Or did you mean that I can have for example the sbcl threading http://www.sbcl.org/manual/Threading.html and can build all of that on my own? I could do the same in c... but I won't - erlang is better for that.

I'd also argue with "nice oo in lisp"... for some values of "nice" :) For big projects I want a code browser / ide. I want types in my OO. I want the code to be structured in a way that makes the methods belong to classes. I don't want old-style message passing OO (not saying that it's bad... it's just not what is used these days in big projects). I want new-style enterprise-level OO with interfaces and self-commenting code where you write what you want to do, because every single person in your 100-person team has to understand it without any comments when you're not around.

So everything that's left imho is easy prototyping. We can shoehorn every paradigm into any language - sure. But then you get something that can do everything and isn't good for anything in particular. If I learned lisp before python, I'd probably say the same thing about python... it's just not worth the additional attention, because they're both easy-prototyping languages, where you can promote the code into production when your first design is "good enough".

Re:How Python is killing Lisp by geocar on Saturday December 12, 2009 @10:46PM (#992362)
> We can shoehorn every paradigm into any language - sure. But then you get something that can do everything and isn't good for anything in particular

That doesn't necessarily follow, but it might very well be true.

In addition to features, languages need speakers. Java is rarely regarded for its feature set, but it is certainly a "good" language in that it is good at something.

The rest of your comment is largely drivel, compounded by the fact you simply don't know lisp well enough to think in lisp, and consequently have a meaningful conversation about what that means. Nevertheless, you somehow got the impression that I thought you should switch to lisp, and I sincerely apologize for that; I never meant that at all- only to express how knowing lisp is valuable.

However, there was one thing in particular:

> I don't want old-style message passing OO

Most lisp programmers prefer CLOS-style OO which uses generic functions, and not message passing.

Re:How Python is killing Lisp by viraptor on Saturday December 12, 2009 @11:31PM (#992407)
Feel free to correct me - I hope to learn something new if you say exactly why you think my points are incorrect. Especially - why would you choose lisp over a specialised solution - static type safety, multiprocessing, oo being the main areas discussed. I don't claim to be an expert in lisp, as I mentioned before. What I wrote is based more on what I see, rather than what I work with every day and I appreciate other views even if don't agree :)
Re:How Python is killing Lisp by geocar on Sunday December 13, 2009 @12:57AM (#992476)
> Feel free to correct me - I hope to learn something new if you say exactly why you think my points are incorrect

They aren't necessarily incorrect, they're just meaningless: I don't start a program and say what this program needs is static type safety, multiprocessing and object oriented designs. I start at a much higher level than that: What should the program ultimately do?

A number of years ago, I made survey kiosks that ran on OpenMCL on G3 macs. They had to ask some prearranged questions, with some potential branching and "please specify" type answers, and they could give different questions based on previous answers. On the way, a number of interesting things happened:

1. The original plan was to use xulrunner and aserve on top of an X server (no WM). xulrunner was simply too slow, so with only two weeks left it was ripped out and replaced with checkboxes, buttons, images, "textareas" and radio buttons on SDL. All of the generic functions which used to emit html, now tracked dynamic variables for a "cursor" and made a drawlist.

2. The survey stations updated their code using multicast pings. Basically they had a directory of source files, and a version tag that would automatically be pushed to any nearby station. When I decided I needed a database, I simply stored the answers in that directory, using the mac address of the ethernet device as the file "name", and the contents simply as lisp forms. The result was that all the answers collected by a machine were shared with every other nearby station. On two occasions a machine died in the field, but no questions were lost. They also shared their source code similarly, so I could push out updates very easily.

3. I was out of the state at a wedding on their first deployment, and there was a problem: One of the machines was acting really funky. Using two cell phones, emacs and slime, I was able to connect into the machine remotely and repair it on the live system. Once it was repaired, I saved the file and it automatically copied all over the campus.

4. One of the major focuses was media awareness. The user was asked to enter in all of the advertisements they were aware of. This was completely freeform, but we needed to collect the results, correct misspellings, cluster them, and make graphs in real time as the event proceeded. These reports were used in justification to the event promoters.

5. At our second install, they had no ethernet deployment. Instead they promised someone could walk a USB key between the machines. A udev rule to detect insert copied all the database files from that synchronization directory to the usb stick, and a trigger replaced any local files if they were newer.

From prototype to delivery was about two months, and we used multiprocessing, a distributed system, and object oriented programming.

Could it have been done in Python? Sure, but had I used python I probably would've used one of the web frameworks, and once I decided I needed to draw the screen myself, things would've gotten pretty messy.

Could it have been done in Erlang? Sure (I can use the process dictionary for dynamic variables), but when I build the database synchronization system using Erlang primitives, I lose the ability to add the easy USB support.

Could it have been done in Haskell? Absolutely, but only if I got it right the first time: I wouldn't have been able to update the code while I was at a wedding.

Ultimately, had I a clear idea of what was needed before I started, any one of those languages could've been made to work, and they all have lots of library code I could've lifted, which is your point.

However my point is that I didn't have a clear idea what was needed, and replacing the libraries would've required either a significant shift in complexity, or a paradigm that the "best" language simply didn't have.

I don't always use lisp, because the practical access to libraries and efforts is important, however there are times where not having access to libraries and efforts is more important: When I don't know what a program will need, locking myself into a module or a framework is the last thing I want to do.

Re:How Python is killing Lisp by PieSquared on Saturday December 12, 2009 @10:07PM (#992319)
Someone correct me if I'm wrong, but I think Common Lisp provides the ability to declare types of variables, and do type-checking on it. This allows you to make CL type-safe if you want to. It also allows a major speed up.

The real problem I see with Lisp is that it lacks a vibrant community like Ruby and Python has, and is in some cases quite ugly. (Why, why use names like 'progn'? Why not the shorter, clearer 'do'? etc.) Clojure addresses that, but I get the feeling that Clojure is just an addon to Java and that you must use the Java lib in order to use Clojure; the integration between them seems to be to be a bit ugly, if easy to use.

However, due to the size of the JVM base, Clojure is very good for production code - but strikes me as lacking the hack-hack quality you can get with CL. And only has one implementation. Aurgh! If only they didn't standardize CL. (Except, then it wouldn't exist at all right now, I bet.)

Re:How Python is killing Lisp by Locke1689 on Saturday December 12, 2009 @10:19PM (#992334)
Lisp does not, at the moment, have any truly practical implementation of multiprocessing. It also doesn't gather any of the lazy benefits of Haskell. It is worthless for prototyping as its modules haven't been up to date in 20 years.

Edit: Gruseom is right, I was very critical without providing any support. Lisp is still very useful in certain cases. The instances which I find trouble with it are detailed in my second response.

Re:How Python is killing Lisp by gruseom on Saturday December 12, 2009 @10:55PM (#992373)
Lisp does not, at the moment, have any truly practical implementation of multiprocessing.

That would explain why there aren't any Lisp web servers.

It is worthless for prototyping as its modules haven't been up to date in 20 years.

Tell that to the people who are using it. Oh wait, I'm one of them. What you're saying here is such a crock that I have to wonder what your purpose is.

Re:How Python is killing Lisp by Locke1689 on Saturday December 12, 2009 @11:24PM (#992398)
Fair, I was overly critical. For me, I find that it is far easier to find modules for Python than for Lisp. For example, the other day I was looking for a module to read and write ID3 tags. The only thing I could find for lisp was http://www.google.com/search?hl=en&client=safari&rls..., which is buggy and incomplete. It didn't take very long to find a suitable Python module.

As to multithreading, first since when is a web server the be-all-end-all of multiprocessing? Hell, you don't even need multithreading to do a webserver, just use Unix processes. My issue with Lisp is that there is no standard for multi-threaded Lisp; the ANSI spec doesn't consider threading at all. The Lisp community seems to be increasingly fractured over the years, which is too bad because I'm not insulting Lisp because I hate it -- it has just become too difficult to use as my generic do-everything language.

Re:How Python is killing Lisp by gruseom on Sunday December 13, 2009 @02:43AM (#992531)
Sorry for impugning your motivations. I lumped your comment in with the anti-CL canards that people keep repeating.

Your ID3 tag library is a good example of the kind of thing one doesn't find much of in the CL world.

On multithreading, though, I think you're off base. Modern CLs all support it, it works great, end of story. That it's not in the standard is a red herring; you simply look up what you need in the documentation for your Lisp instead of in the Hyperspec. Big deal. If you want to run on more than one Lisp, it's trivial:

  (defun spawn (name fn)
    #+ccl  (ccl:process-run-function name fn)
    #+lispworks (mp:process-run-function name nil fn)
    #+sbcl (sb-thread:make-thread fn :name name))
I wouldn't use CL as a do-everything language either, but it's typically a superb place to be if you're trying to do anything complex.
Re:How Python is killing Lisp by wglb on Sunday December 13, 2009 @09:14AM (#992738)
To respond to a specific point, Practical Common Lisp has a complete implementation of a program to read MP3 and build an online index from the information there. It is a thing of beauty.
Re:How Python is killing Lisp by anamax on Saturday December 12, 2009 @09:19PM (#992272)
Lisp macros make it possible to DSLs that make sense.

The syntax also helps with code generation.