Steel Bank Common Lisp Version 1.0.38 released | Hacker News Reader

Steel Bank Common Lisp Version 1.0.38 released

sourceforge.net

47 pointsjgg20 comments

You've linked to the sourceforge project page, a better link is probably the web page at:

http://sbcl.sourceforge.net/

Or http://sbcl.sourceforge.net/news.html if you were highlighting the latest release.

Is there any point learning SBCL or CMUCL today for actually writing applications using Lisp, or is Clojure a better choice?

Basically, I want to learn lisp, but also write some apps in it. I keep hearing that people use lisp for prototyping and then rewrite in some other language.

SBCL is definitely worth learning and is fine for writing applications. Should you choose it over Clojure? Tougher question. There's a lot, lot, lot of good books and documentation about CL but Clojure has popularity and momentum. No matter which you choose, I don't think you can go wrong.

Will one's learning carry over easily from one lisp to another (one CL to another), and onto Clojure ?

That's a good question, actually. The answer is: Yes and no. Scheme, Emacs Lisp, Common Lisp and Clojure are all different, certainly. For example, when you look at programming texts, you realize that there really is a "Scheme" way of doing things and a "Common Lisp" way of doing things, which aren't always the same. That being said, if you learn one dialect, that will probably make learning another much easier. If you're new to the Lisp thing, I'd learn Scheme.

It depends on the apps you want to write, as well as what you already know. (For example, if you know your way around Javadocs and Java classpaths, Clojure rises as a possibility.)

I suggest skimming through a few pages of Planet Clojure and Planet Lisp, to get a sense of the apps people are writing. As a rough rule of thumb, if one excites you much more, that could be the better choice.

If you end up going with CL, you'll likely have a better time asking newbie questions on LispForum (or mailing lists like the LispWorks one), rather than on Usenet. And there are alternatives to SBCL and CMUCL, such as ECL and LispWorks: http://common-lisp.net/~dlw/LispSurvey.html

As for prototyping-then-rewriting, I think there are a few situations:

1) nontechnical reasons (such as, the maintainers can't be expected to maintain a Lisp app)

2) because the Lisp implementation is missing some convenient functionality, and it isn't easy to call an existing one in another language

3) the Lisp doesn't interoperate well with a given technical ecosystem

I think the probability of rewriting is less with Clojure, due to its Java interop, long-term goals of interop with other platforms (like .NET), and the increasing number of teams using it.

Replying to both posts above. Thx.

I am not interested in webapps. I usually do command line stuff, or libraries, and i've done some libraries in ncurses. Basically a terminal freak. Currently ruby, but 5-6 years of Java before that. No functional language exp.

Are there not several versions of Scheme, too. Any suggestions for what to start with.

Is scheme/lisp/clojure the correct language to use for terminal/command-line apps or ncurses stuff ?

Does anyone offhand know if there is ncurses support for these languages ?

>No functional language exp.

Common Lisp, at least, isn't really a purely functional language. It supports multiple paradigms. Scheme and Clojure are a little more "functional" than CL, but they too are not pure. I wouldn't worry about this yet.

>Are there not several versions of Scheme, too. Any suggestions for what to start with.

I replied above. (-:

>Is scheme/lisp/clojure the correct language to use for terminal/command-line apps or ncurses stuff ?

I don't see why not.

>Does anyone offhand know if there is ncurses support for these languages ?

It looks like there is a package for Common Lisp for doing ncurses stuff. There's a thread on the PLT mailing list that indicates there's no support for ncurses in PLT Scheme, but other implementations might have it. A search in Clojure's libraries didn't reveal anything, but I may be looking in the wrong place (it seems like they would have one).

I would probably lean towards Clojure, because of your Java experience, its library advantages, active community and the usefulness of other JVM communities. However, a tradeoff to keep in mind is that currently it often has unhelpful exception error messages.

Googling for "ncurses java" provided better results than "ncurses clojure". It is useful to exploit Java's libraries, only wrapping them in Clojure when there is something to be gained. (Like writing a macro mini-language to automate away tedious parts of a library you use.)

I find that when using a new program (in this case, a programming language), it helps to quickly test that it basically supports the features I'll want. So if I had your requirements, I might check early on whether I liked one of the ncurses libraries.

I just did look at planet lisp but got quite lost ;-) I did find http://www.unmutual.info/startingwithcl.html to be helpful and a page on Stack http://stackoverflow.com/questions/108201/common-lisp-or-sch...

I've been learning common lisp for a while now. I know clojure, and i thought it would be beneficial to learn common lisp so I'll be able to learn from all the existing code and read all the classic lisp books. I'm surprised at how good common lisp is, i think it's one of the most misunderstood languages, its not a pretty language, but its a good one. Its problems seem to be mostly cultural ones.

If you have no exposure to lisp or functional programming i would suggest scheme as a first lisp, after you feel comfortable with lisp syntax and functional programming you should learn both common lisp and clojure, in whatever order you like. At least thats what i did, seems to have worked out well for me. Learning either of those as a first lisp is possible though, you can just ignore my advice and start with whatever you like.

Which scheme. I am on OS X. Thanks.

I'd use PLT Scheme: http://www.plt-scheme.org/

Of notable interest, they're added the sb-concurrency module. The best part about lisp is how it can incorporate new programming ideas into the normal syntax.

Sigh. I'm pretty sure I could add lock free queues to C without changing the syntax.

    lockfree_enqueue(queue, whatnot);
    whatnot = lockfree_dequeue(queue);

Looks just like all the rest of my C code. The part of me that wants to learn lisp dies a little every time I read one of these "look how awesome lisp is" comments because I'm afraid I'll end up spouting such nonsense.

It's easy to add new things to Lisp and C when the interface looks mostly like function invocation. It's easier to extend Lisp with things that aren't a lot like function invocation, because C syntax and the C preprocessor don't work together as well as Lisp syntax and Lisp macros.

I wouldn't worry much about spouting nonsense when you learn new things unless you're prone to that already.

For those curious about the origin of the name, this is fork of CMU CL. CMU is a university located in Pittsburgh, a city with a history as a steel town.

More precisely, Carnegie and Mellon, after whom CMU is named, made their fortunes in steel and banking.

Carnegie was a steel baron. Melon was a banker. Hence Carnegie Mellon became "steel bank".

Other language implementations starting with SB were Stony Brook Pascal (back in the DOS days). It used to be one of the best Pascal implementations.

Reply on news.ycombinator.com