Dialects of Lisp

http://programmers.stackexchange.com/questions/55284/is-lisp-still-useful-in-todays-world-which-version-is-most-used/188048#188048

by mwillmott • 13 years ago

94 90 13 years ago

programmers.stackexchange.com

dschiptsov8• 13 years ago

The way is Scheme -> Common Lisp -> Arc.

Scheme comes first because it is more refined and there are excellent courses and books.

CS61A probably the best introductory course. After that it is good to watch original SICP lectures by the two magicians and read the book. Then it is necessary to take a look at what HtDP team is teaching.

After this there will be no trouble with Common Lisp. Classic books are these by pg and Norvig. CLtL is just a reference.

Then, with all the knowledge so far one could understand arc.arc and appreciate what have been done there.)

With this background you will understand what Clojure really is and why, or what is Haskell, and why there is nothing special in it.

btw, there is a brilliant course by Dan Grossman on coursera covering FP. He is very clever and consistent. After this you will smile at Haskell guys.)

Update:

I forgot Emacs Lisp. An Introduction to Programming in Emacs Lisp is an excellent book that covers all the basic principles and gives a perspective how to use lisp in a real-world project.)

programminggeek2• 13 years ago

When you say there is nothing special in it, do you mean Clojure or Haskell?

dschiptsov8• 13 years ago

The later.

nnq2• 13 years ago

Why do you think it would be bad to just start with Clojure as a "first Lisp"? (yeah, there's the JVM, but leiningen makes things bearable and lighttable is a one-click repl to "just start coding")

dschiptsov8• 13 years ago

Because, in my opinion, Clojure isn't a Lisp. It is Lisp-like language, or Java with parenthesis and immutable collections, if you wish. It violates few basic principles of Lisp - one common underlying list-structure for code and data (Clojure's code is a mix of different containers) It violates a general evaluation rule - one for every expression with a very few special forms, etc.

I cannot explain it in a few sentences, I have tried few times, but I'm sure that it is better to learn the classic Lisps first, so you could be able to appreciate their elegance and simplicity (a few selected ideas put together) and then you could compare it with what you have in Clojure.

It is also important to learn how Lisp programmers used to build almost everything they wish out of conses (except arrays and hash-tables, of course) how they reason about access patterns for list structures, learn simple and elegant classic functions, such as map, filter, reduce, etc in their natural environment.)

It short, compared with even CL Clojure is a mess.

mej10• 13 years ago

Can you expand on "or what is Haskell, and why there is nothing special in it" ?

Locke16897• 13 years ago

I have no idea what you're talking about. Grossman's course is barely covering an introduction to programming languages (literally, the course my sophomore year of college covering the same material was called "introduction to programming languages").

I guess you could say that there's nothing "special" about Haskell, but the same would be true of Arc. I think Racket is the real champion in Arc -- a truly flexible programming language laboratory.

kyllo• 13 years ago

Yeah, Grossman's course covers SML, Racket, and Ruby. Haskell is not even part of the course at all.

dschiptsov8• 13 years ago

His course covers the ideas behind so-called functional programming paradigm - high-order functions , environments, lexical scooping, closures and the standard idioms, including currying and lazyness. This course about concepts behind programming languages, not languages themselves.

nnq2• 13 years ago

* sidenote: CS61A is Python based from 2011 on

tikhonj3• 13 years ago

The idea that there is nothing special about Haskell, or that Haskell is all that closely related to lisp, is patently absurd. Haskell comes from a different, more mathematical background with a much more extensive underlying theory than lisp.

I actually came from the background you advocate--61A (which really was an awesome class) was my first CS course in college. (Unfortunately, they have since ruined it.) I certainly appreciate lisp and have actually used Racket in a practical setting. That said, I've found Haskell and OCaml to stand out both from purely pragmatic and theoretical considerations.

Haskell is the only moderately popular language that lets you control side-effects globally. That by itself is extremely special. This makes writing maintainable code easier and gives the compiler considerable freedom in optimizing code.

Haskell has an incredible but also surprisingly simple type system. You can't just ignore that. There is nothing in lisp--not even typed Racket--that even comes close to Haskell's type system.

Even aside from language qualities that make Haskell special--which I haven't even come close to covering--it also stands out because of its community. Not only is the community particularly nice and welcoming, it's also special in not being afraid of a bit of math. This doesn't mean you as a programmer have to know much math, but it does mean libraries tend to be simpler and more self-consistent because they rely on very well defined mathematical abstractions with simple algebraic rules. These abstractions also allow for significantly more general code.

Haskell comes from a different theoretical background and philosophy than lisp. It has different practical advantages and a very different philosophy. So claiming that it's nothing special and that you will understand all of it just coming from lisp is completely wrong.

Locke16897• 13 years ago

I agree with much of what you wrote there but you should remember that the single most distinguishing feature of Haskell (aside from its predecessor Miranda) is laziness. Almost everything unique you described about Haskell was not accidental, but necessary to build a wholly lazy language.

jhuni5• 13 years ago

I like having access to mathematical semantics, simple algebraic rules, and all the other things you mentioned but combining these features with a non-homoiconic syntax spoils the whole thing for me.

> Not only is the community particularly nice and welcoming, it's also special in not being afraid of a bit of math.

The Lisp community has never been afraid of math. John McCarthy had a PHD in mathematics and the earliest computer algebra systems were developed in Lisp. The Macysma computer algebra system (now developed as Maxima) predates Haskell by decades.

> Haskell has an incredible but also surprisingly simple type system. You can't just ignore that. There is nothing in lisp--not even typed Racket--that even comes close to Haskell's type system.

The most important thing for me is having the ability to describe cardinality (especially in terms of machine bits such as 2^8, 2^16, etc) and enumerations (like the ASCII character encoding). What aspect of Haskells type system is that Lisps need to "come close to"?

dschiptsov8• 13 years ago

As far as I know, Haskell is just a ML-family language. It is a dialect of ML, we could day.

The decision of its designers to create so-called pure-functional language is nothing but a fancy term and it deceived lots of people. Machine code it produces isn't pure or somehow different. And, of course, I can do the same functional programming in, say, Lisp. Or ML.

Laziness is also not a silver bullet, you could have lazy evaluation in Scheme or even CL on demand if you wish.

So, Haskell is nothing special because it just another ML-family language, over-hyped and over-sold.

brudgers4• 13 years ago

If I were to bet, I'd place my money on Clojure as the 100 year language. It is as unbound by hardware in regard to cross platform development as any other likely candidate, it has good access to libraries meeting contemporary expectations, and is likely to continue to have access to new libraries written to meet future expectations - all due to its interaction with the JVM (and .NET).

Of course I am adopting PG's premise that the 100 year language is a LISP while ignoring his premise that it is not a bit kludged up by practical considerations (i.e. the ugliness of its dependence on the JVM).

(/edit) Clojure also has an evangelist in Rich Hickey whom people seem to respect independently of Clojure.

crististm• 13 years ago

Not bounded by hw but still bounded by its VM implementation.

robdor• 13 years ago

With Clojure being available for the jvm, the clr through ClojureCLR and javascript through ClojureScript I don't believe that this will be much of an issue.

pmelendez• 13 years ago

I wouldn't put my money on the JVM platform. It's funny but Clojure's bigest advantage is also its biggest disadvantage.

brudgers4• 13 years ago

Given its adoption by enterprise, the JVM at worst has a COBOL future. At best, it's future is worse-is-better.

http://www.dreamsongs.com/WorseIsBetter.html

pavelludiq2• 13 years ago

Common Lisp is 29 years old(if we count from the publication of CLTL1) or 19 years old(if we count from the publication of the ANSI standard), clojure is 5-6 years old. Scheme is even older. I love clojure, but it has some mighty big shoes to fill, CL was build for longevity from the beginning. Also, both scheme and CL run on the JVM. CL also survived the death of many operating systems, architectures and platforms in those 29 years, clojure is yet to survive one.

brudgers4• 13 years ago

To me, Common Lisp appears to suffer from bad timing. It was designed on the cusp of paradigm shifts from timesharing to networking; from text interfaces to graphic interfaces; and from computers being rare to being ubiquitous. Hitting it's peak in popular consciousness in the midst of the Black Friday and S&L recession didn't help either.

My view is premised upon the idea that a major deficit of Common Lisp is a poor access to contemporary independent user interfaces. The solutions that exist are not competitive with the leverage Clojure enjoys from JVM (and .NET).

mark_l_watson4• 13 years ago

Well, Rich used to use Common Lisp (I know because I used to use his very neat LispWorks to Java bridge stuff).

Clojure really does hit the sweet spot combining a concise agile language with good practical decisions, similar I think to some of the decisions that went into the design of Scala (like a generalized seq API for lots of data structures).

Except for some personal serious side projects, I am now retired, and I chose Clojure over other good possibilities (e.g., Common Lisp, Racket, Gambit-C, Scala, Smalltalk, or Ruby) because it is a practical language and still lots fun to code in.

Now that I don't have to worry about staying up to speed on all of the languages my customers used to like using, I find that just using a single language really saves me a lot of time. Some advice for people still working: perhaps choosing a single practical and extensible language like Scala or Clojure is a good strategy; I used to like being a polyglot programmer but that requires a lot of overhead!

asynchrony4• 13 years ago

Clojure is so closely tied to the JVM that it's hard to imagine it being the "100 year language" unless the JVM turns out to be the "100 year platform".

ldh• 13 years ago

The original Clojure implementation was built on the JVM, but it also targets the CLR and JavaScript. I don't think it's irrevocably tied to the JVM.

billsix• 13 years ago

>It is as unbound by hardware in regard to cross platform development as any other likely candidate

Gambit c runs on more hardware

ema• 13 years ago

Clojure is currently my favorite language, partly for the pragmatic choices it made, but these pragmatic choices will limit its continued use.

Hygienic macros often prevent one from shooting oneself into the foot, but they prevent also some truly elegant code. Having lists and vectors with a common interface is cool, but that the semantics of conj is different for both is annoying. Easy java interop is worth a lot, but it prevents call/cc.

It's probable that i will gladly use Clojure for the next 10, maybe even 20 years, but it won't be the programming language my grandchildren will ask me to shut up about.

Tyr42• 13 years ago

I am curious, what do you think hygienic macros break? I'm a fan of Racket, and I haven't yet found anything that it's macros can't do.

asynchrony4• 13 years ago

Hygienic macros prevent accidental symbol capture. They don't prevent intentional symbol capture. You may be thinking of the limitations of pattern based macros, but many Scheme systems provide hygienic procedural macros.

jrajav• 13 years ago

This answer references Chicken Scheme, which compiles to C - I'm curious, is there any work on a Scheme that compiles to LLVM? (A brief search didn't reveal anything that's been updated in the last 4-5 years.)

fosap2• 13 years ago

you can compile the c code to llvm IR, but why would you do that? LLVM is not a very good VM it's not platform agnostic, some stuff like the the pointer size are set a compile time, c seems to be a better platform agnostic assembler.

chc4• 13 years ago

It's not really a VM. It's more like a tool set for writing compilers.

chc4• 13 years ago

Pretty much all the major Schemes predate LLVM, and modifying a compiler to use LLVM instead of its existing tools is not necessarily trivial and not necessarily worth it.

bitwize• 13 years ago

Gambit is getting backends that include x86 and JavaScript Real Soon Now. There has been LLVM work, but I don't think it progressed very far.

mark_l_watson4• 13 years ago

+1 for mentioning Gambit-C. I don't use Gambit-C anymore, but I used to use it a fair amount for writing small utility programs. Gambit-C can be used to build very small and efficient executables. Gambit-C doesn't have the huge library that Racket or Chicken have but it is great for building small command line utilities, etc.

Locke16897• 13 years ago

I'm not familiar with a lot of other dialects, but the information on Racket is terrible. I wouldn't trust any of the other responses.

Racket is not an R6RS scheme, it's... Racket. R6RS is an available language/library in Racket, but it's not what you usually use[1].

Racket has also always been a language laboratory, not just a scheme. I'd also wager that it's the most popular scheme used today, maybe even the most popular lisp.

[1] The Racket primary language is specified with #lang Racket, R6RS is specified with #lang r6rs. R5RS is specified with #lang r5rs.

fosap2• 13 years ago

I wonder if Arc is finished or dead. I like it it seems the ecosystem is missing.

leke• 13 years ago

No mention of NewLisp?

mahmud• 13 years ago

NewLisp is to Lisp what ramen noodles is to Italian cuisine.

mghan• 13 years ago

Urban Dictionary about Ramen Noodles: "Quite possibly one of the most all time best foods ever to be found in the United States of America."

derleth• 13 years ago

Why don't people do things like this for Dialects of Algol? Is it because most of them got new names, like Java, C, and so on?

groovy2shoes• 13 years ago

I was actually thinking about this same question earlier. There are dialects of Lisp and dialects of BASIC, but most other languages are not considered dialects of anything similar. How different do two programming languages have to be before they're no longer considered dialects?

It seems like Scheme and Common Lisp, for instance, have more differences than Java and C# have from each other. Why wouldn't C# be considered a Java dialect? Visual Basic is very different from BASICA, yet they are both considered BASIC dialects. Why shouldn't Pascal and Ada be considered ALGOL dialects?

The line-drawing process seems completely arbitrary.

det23x• 13 years ago

Because natural language's type hierarchy is not that sound as we programmers would like it to be.

jfb• 13 years ago

"The line-drawing process seems completely arbitrary."

The real world cannot be exhaustively described with a single taxonomy.

orthecreedence• 13 years ago

I've seen Common Lisp start to make a great comeback in the past few years. I started programming in it seriously about a year and half ago, and since then the packaging system (quicklisp) and libraries for it are maturing very rapidly. A lot of people are making useful libraries for practical purposes.

A lot of people say the language's timing was off. I couldn't agree more. However, it's starting to get a second chance. There are several open-source implementations that compile to machine code and/or support threading/networking/etc. Deployment is essentially free. For every feature that an implementation has that's not in the standard, there's a library that creates a standard, cross-implementation interface for it (for instance threading and the "bordeaux-threads" library).

The language is screaming fast, extremely expressive and powerful (insert mandatory macro hype here), and becoming "standardized" all over again via its libraries. I use it (Clozure CL) in production and haven't ever had an issue.

rayiner• 13 years ago

> The language is screaming fast

I don't disagree, but that's an interesting change in the CW.

jdale272• 13 years ago

(CW == conventional wisdom?)

There are probably a few reasons for that. Many more programmers these days probably get their start with "scripting" languages like Python, Ruby, Perl, PHP, and JavaScript. Compared to these other dynamic, high-level languages, you probably could call Common Lisp "screaming fast". (Of course, I'm aware that there is very active implementation work going on for several of those languages that is probably doing a good deal to close the gap.) On average, though, CL is probably in the same ballpark as Java, and can sometimes be made as fast as C or C++ with a lot of effort.

Also, note that Common Lisp is very much a many-implementation language (in contrast to languages like the ones above that, for most of their history, were defined by their single implementation), and different implementations make difference performance trade-offs. For much of recent history, the very high performance CL implementations have been somewhat out of reach of the typical student, hobbyist, or other weekend hacker that probably makes up most of the Lisp community. Commercial CLs are quite expensive, and high-performance free CLs like CMUCL have historically not been too friendly to beginners. When I came to Lisp, it seemed much easier to get started with CLISP (an extremely portable bytecode-compiled implementation) than with CMUCL. More recently, SBCL (an offshoot of CMUCL) and Clozure CL have made a lot of progress towards providing a go-to open source CL implementation with very good performance.

Dialects of Lisp

Related Stories