11

Now I'm generally in Java/C# (love both of them, can't really say I'm dedicated to one).
And I've recently been discussing the differences between F# and C# with a friend, when he surprised me saying: "So.. F# sounds a lot like lisp, but with way less 'Swiss-army knife' feel to it."
Now, I was partly ashamed of saying this but I have no idea what lisp was.
After some searching, I saw that lisp is very interesting, but got stumped by the multiple dialects and running environments.

Here is what I know: I know of 3 dialects:

  • Common Lisp (I have the Practical Common Lisp book in my bookmarks.
  • Scheme (a more "theoretical" version of CL)
  • Clojure. Seems to be a version of CL that runs on JVM.

The basic idea of lisp seems to be about using code as data.

What I want to know:

  • What is the running environment for different dialects? How do they work/get installed (by this I mean is it a runtime like Java Virtual Machine, or if it requires something else, or if it's supported generally by the OS (as in compiled)). And how to get them (if something is to be gotten)
  • What is the better dialect to learn (I want the dialect not to be a "learning language" but one you can fully use afterwards without regret of not learning some other one, for example one should first learn C++ before trying out Visual C++, if you know what I mean)
  • What are the main advantages of lisp in general (I've seen many pages about that saying it's faster in development and execution, but they were all pretty vague about the details)
  • Can it be generally used for general purpose, or is it concentrated on AI? (By this I mean if, for example, one could make a full console app with it, and then implement OpenGL just as easily and make a game. Learning a language specialized on something precise is worthwhile, but not at the moment for me)

I would also be very happy about any additional details you guys can give me! (Links are appreciated too! E-Books and whatnot.)

Edit: all of the answers here were very useful. As such, I gave them all a +1 to rep, but chose the more concrete one as best. Thank you all.

Improve this question
4
  • 4
    This is not really the place to request a tutorial, but you seem to have lucked out in finding three people who are willing to do so. Also, note that Clojure is not Common Lisp. If you want CL on JVM, use ABCL. Commented Mar 6, 2012 at 6:36
  • 3
    Also, note that while Lisp is very interesting, and somewhat functional (depending on the dialect), just because two languages are functional, it does not mean they are that similar. F# is based on Caml. Commented Mar 6, 2012 at 6:45
  • Yes I saw that quite quickly, as written, that was the reference of my friend that got me started altogether. And ty for the note (tutorial), I'm new here and didn't see it interfering with the guidelines of asking questions. Commented Mar 6, 2012 at 13:10
  • 1
    @Shingetsu: see stackoverflow.com/faq#dontask. If you have a practical programming problem, ask here. If you have a general question about what is better, a or b, then this is the wrong site. Commented Mar 7, 2012 at 6:31

4 Answers 4

Reset to default
14

I also learnt Java and C# intensively before coming to Lisp so hopefully can share some useful perspectives.

Firstly, all Lisps are great and you should definitely consider learning one. There's a famous quote by Eric Raymond:

"Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot."

Reasons that Lisps are particularly interesting and powerful are:

  • Homoiconicity - in Lisp "code is data" - the language itself is written in Lisp data structures. In itself this is interesting, but where it gets really powerful is when you start using this for code generation and advanced macros. Some believe that this features is a key reason why Lisp can help you be more productive than anyone else (short Paul Graham essay)
  • Interactice development at the REPL - a few other languages also have this, but it is particularly idiomatic and deep-rooted in Lisp culture. It's remarkably productive and liberating to develop while altering a live running program. Recent examples that caught my eye include music hacking with overtone and editing a live game simulation.
  • Dynamic typing - opinion is more divide on whether this is an advantage or not (I'm personally neutral) but many people thing that dynamically typed langauges give you a productivity advantage, at least in terms of building things quickly. YMMV.

My personal recommendation for a Lisp to learn nowadays would be Clojure. Clojure has a few distinct advantages that make it stand out:

  • Modern language design - Clojure "refines" Lisp in a number of ways. For example, Clojure adds some new syntax for vectors [] and hashmaps {} in addition to lists (). Purists may disapprove, but I personally believe these find of innovations make the language much nicer to use and read.
  • Functional first and foremost - all the Lisps are good as functional languages, however Clojure takes it much further. All the standard library is written in terms of pure functions. All data structures are immutable. Mutable state is strictly limited. Lazy sequences (including infinite sequences) are supported. In some senses it feels a bit more like Haskell than the other Lisps.
  • Concurrency - Clojure has a unique approach to managing concurrency, supported by a very good STM implementation. Worth watching this excellent video for a much deeper explanation.
  • Runs on the JVM - whatever you think of Java, the JVM is a great platform with extremely good GC, JIT compilation, cross platform portability etc. This can be a barrier to entry for some, but anyone used to Java or C# should quickly feel at home.
  • Library ecosystem - since Clojure runs on the JVM, it can use Java libraries extremely easily. Calling a Java API from Clojure is trivial - it's just like any other function call with a syntax of (.methodName someObject arg1 arg2). With the availability of the huge Java library ecosystem (mostly open source) Clojure basically leapfrogs all the "niche" languages in terms of practical usefulness

In terms of applications, Clojure is designed to be a fully general purpose langauge so can be used in any field - certainly not limited to AI. I know of people using it in startups, using it for big data processing, even writing games.

Finally on the performance point: you are basically always going to pay a slight performance penalty for using higher level language constructs. However Clojure in my experience is "close enough" to Java or C# that you won't notice the difference for general purpose development. It helps that Clojure is always compiled and that you can use optional type hints to get the performance benefits of static typing.

The flawed benchmarks (as of early 2012) put Clojure within a factor of 2-3 of the speed of statically typed languages like Java, Scala and C#, a little bit behind Common Lisp and a little bit ahead of Scheme (Racket).

Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

I think I'll learn scheme basics, just to see what the general syntax is and turn to clojure. Thanks!
Sure thing and no problems. You'll find Scheme / Clojure pretty similar, probably about the same difference as Java / C#.
btw, I found a good Clojure IDE (eclipse -> counterclockwise,that I got to run with the 1.3 version), but are there any similar to it for Common Lisp? The project for the eclipse plugin was last updated in 2007...
Counterclockwise is great for Clojure if you like IDEs and also want good Java tool integration - it's what I personally use. I think most Common Lisp people and quite a few Clojure people prefer emacs though! See also: stackoverflow.com/questions/2492834/…
11

Lisp, as you've discovered, is not one language; it's a family of languages that have certain features in common.

There are two primary dialects of Lisp: Common Lisp and Scheme. Each of those two dialects has many implementations, each with their own features. However, both Common Lisp and Scheme are standardized, and the standards define a certain baseline of features which you can expect any implementation to have.

Scheme is a minimalistic language with a very small standard library. It is used primarily by students and theoreticians. Common Lisp has many more language features and a much larger standard library, including a powerful object system, and has been used in large production systems.

Clojure is another minor, more recent dialect. If you want to understand Lisp, you're better off first learning either Common Lisp or Scheme.

My recommendation is to learn Scheme first; it's a purer expression of the ideas that Lisp is made of, and will help you understand the essence of the language. In many ways, Lisp is completely different from Java and other imperative languages; however, what you learn from it will make you a better programmer in those languages. You can easily learn Common Lisp after you know Scheme.

The advantage of Lisp is, simply put, that it's more powerful than other languages. All Lisp code is Lisp data and can be manipulated as such; this allows you to do really cool things with metaprogramming that simply can't be done in other languages, because they don't give you direct access to the data structures that comprise your code. (The reason Lisp can do this and they can't is intimately related to its strange-looking syntax. Every compiler or interpreter, after reading the source code, must translate it into abstract syntax trees. Unlike other languages, Lisp's syntax is a direct representation of the ASTs that Lisp code is translated into, so you know what those trees look like and can manipulate them directly.) The most commonly used metaprogramming feature is macros; Lisp macros can literally translate a bit of source code into anything you can program. You can't do that with, say, C macros.

The "faster in development and execution" thing may have been a reference to one specific feature which most Lisp implementations provide: the read-eval-print loop. You can type an expression into a prompt and the interpreter will evaluate it and print the result. This is wonderful both for learning the language and for debugging or otherwise investigating code.

Lisp is dynamically typed (though statically typed flavors do exist). Most implementations of Lisp run on their own virtual machine; however, many can also be compiled to machine code. Clojure was written specifically to target the JVM; it can also target .NET and JavaScript.

Though originally created for AI research, Lisp is by no means exclusively for AI. The main reason why it's not more popular in mainstream production environments (apart from the self-perpetuating dominance of Java and C#) is library support. Common Lisp has many good libraries out there (Scheme less so), but it pales in comparison to the vast amount of library support available for Java or Python.

If you want to get started, I recommend downloading Racket, a highly popular implementation of Scheme. It has everything you need, including a simple-but-very-powerful IDE with a read-eval-print loop, right out of the box. Though originally developed as a teaching language, it comes with a very large standard library more characteristic of Common Lisp than of Scheme. As a result, it's seeing use in real production environments.

Improve this answer

4 Comments

Very complete answer on the theoretical part, but I will ask for a few clarifications: First of all, performance-wise, how is performance related to the runtime environment? (that is, which runtime is faster? for example (not necessarily true) like saying JVM is slower then .NET is). Also, you said that CL (Common Lisp, I take it) has a "powerful object system". I've grown quite attached to the concepts of a class (considering I main Java and C# I think it's understandable). Can you say more about those?
btw, isn't Read-Eval-Print something Python does too?
@Shingetsu As a general rule, compilation to native code is faster than any virtual machine. Beyond that, it's extremely difficult to make general statements about the relative performance of different runtime environments. You should probably be more concerned with language power than performance anyway; these days, few applications really need to squeeze every last drop of performance out of the machine. If you're writing such an application, you should write it in C.
@Shingetsu The Common Lisp Object System is class-based, like that of Java or C# (as opposed to, say, JavaScript). It supports all the features that Java's type system does (dynamic dispatch, inheritance, etc.). It also supports features that Java doesn't, such as multiple inheritance, metaclasses, generic methods (not the same as Java generics; this is, among other things, the ability to call different code based on the types of the arguments), and the ability to dynamically change the structure of classes at runtime.
4

Runtime Environments

Common Lisp and Scheme generally have their own unique runtime environments. There are some variants of Scheme (Chicken and Gambit) which can be translated to C and then linked with their environments so as to be able to be deployed as stand alone executable programs. Clojure runs in the JVM, and there is also a CLR port, but its not clear to me that the CLR port is current with the JVM. Clojure also has Clojurescript, which targets a Javascript runtime.

Which is Better to Learn First

I don't think that question has a good answer. Its up to you. Although if you have experience with the JVM, Clojure might be a bit smoother to start with.

What is Better about Lisp

That's a question liable to start a flame war. I don't have much lisp experience. I started learning Clojure a few months ago in earnest, have looked at Common Lisp and Scheme on and off over the years.

What I like is their dynamic natures. You need to change a function at runtime while your program is running? No problem! Like any power tool, you have to be careful not to chop your bits off when using this.

The power and expressiveness is addicting too. I am able to do some things with little effort that I know I could not achieve in Java, or I know would require a lot more work. Specifically, I was able to put together a description of a data structure - and though the use of macros, delay evaluation of parts of the data until the right time. If I had done that in Java, I would not have been able to nest the declarations like I did because they would have evaluated in the wrong order. Pain would have ensued.

I also like Clojure's view of functional programming, although I have to say it requires work to adjust.

Is Lisp General Purpose

Yes.

--

Mark Volkman has a really good article on Clojure. Many basics are there. One thing that I did in the beginning was to just fire up a repl and experiment when I needed to figure something out programmatically. e.g. explore an API or do some calculations. After a short period of time with that I started working on more building up levels of effort, and I have a project that I'm working on right now that involves Clojure.

There isn't a bad book about Clojure that has been written. The Stuart Sierra book is being updated; and the Oreilly book is about to come out soon, so you might want to wait. The Joy of Clojure is good, but I don't think its a good starter book.

For Common Lisp, I highly recommend the Land of Lisp.

For Scheme, there are several classics including The Little Schemer and SICP.

Oh, and this: http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey (maybe one of the most important talks you'll ever watch), and this http://www.infoq.com/presentations/hickey-clojure (IIRC, really good intro to Clojure).

Improve this answer

5 Comments

From what I'm looking into right now, Clojure seems to be using Java libraries to it's own goals (insert criminal rageface), is it effective though? From a few comparisons I've notices that lisp has extremely fast runtime (in CPU seconds) (similar to C/C++, thousands less then Java) and way less development time... Isn't making it run in JVM kind of "spoiling the fun" or am I missing something?
Clojure doesn't reinvent things that don't need to be reinvented. If there's a Java library that does what you need then you can use it. Interop is really good. There's a growing number of 'native' libraries too.
Darn, hit enter. Clojure can also be pretty darn fast too, and there are tricks you can do to speed things up. For example, after I wrote some code I added some type hints so the compiler could generate code to interact with those objects directly rather than through reflection. It sped things up about 10 times. Then I changed one function call from a serial version to a parallel version and it got about another 4 times faster. YMMV. I've never really heard of LISP being heralded as a speed daemon, but I don't think its nearly as important as it was 10 years ago. Fast enough is fast enough.
Any arguments towards learning which one first? I'm getting quite interested in this (though I still main Java/C# until I finish the study) and they all look interesting. Clojure seems not as bad since I see they all run in a virtual machine of some sort, but does JVM really work well with it? Otherwise many say to learn Scheme first although it's more "theoretical" while CL (Common Lisp I take it) has way better libraries... But is that really the only difference?
Clojure works really well in the JVM. Like I said, since you have some experience working with the JVM; it might be the way to start, but that doesn't mean what you learn while working on Clojure won't help you with the others once you decide to pick them up.
3

common lisp

  • Common Lisp is both compiled and interpreted. Deployments (in Windows) can be done by an exe with DLLs. Or by a precompiled bytecode. Or by installing a Lisp system on the target device and executing the source against it.

  • Common Lisp is a fully usable industrial language with an active community and libraries for many different tasks.

  • Lisps are generally faster for development and due to the abstraction capabilities, better at developing higher level concepts. It's hard to explain. Ruby vs. C is an example of this sort of thing. All Lisps carry this capacity IMO.

  • Common Lisp is a general purpose language. I don't know offhand if modern Common Lisp implementations directly support executing assembly, so it may be difficult to write drivers or use compiler-unsupported CPU instructions.

I like Common Lisp, but Clojure and Racket are not to be sneezed at either. Clojure in particular represents a very interesting track, in my opinion.

For e-books, you can get On Lisp by Graham and Gentle Introduction to Symbolic Computation. Possibly others but those are the ones I can recall.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.