Which dialect of lisp should i learn

Check out DrRacket and associated books. Your best bet is a wonderful book, The Little Schemer. Frankly, everybody speaks so highly of it, but I'm not getting it. Since you're a newcomer I'd go by community. Clojure has by far the biggest and the friendliest community.

Then there's scheme with an equally friendly but smaller community. And then theres common lisp. The community is probably bigger than the scheme one, but it's also where the zealots are. This thread is the perfect example, all the non CL posts get downvoted no matter how well reasoned they are.

Don't complain that you get downvoted, when you post nonsense. Personal attacks also don't advance your case. No attack meant, just an observation, I had actually written the post with you in mind.

Although in all fairness despite your zealotry you are the most objective of them. Also what's my "cause" even supposed to be? Convince op to use clojure? I gave my recommendation because they asked, that's all. Clojure is not a dialect of Common Lisp. They are both Lisps, but neither is a dialect of one another. I use Clojure at work and recreationally, and I learned Lisps first from it, so I am a bit biased, but I do think Clojure is a good Lisp to learn in I'd say Racket is a close second.

So my rec would be to learn Clojure, and this is my curriculum of choice: 1. Bookmark them. Even better, get the Android app, so you can practice on the go, the bus, the bathroom. Also for some reason the order of exercise in the Android app is the best, so I'd try and follow that. You don't need to go through them all, you can probably stop after easy or medium. Once that's done, get Clojure Cookbook and go through the recipes.

Oh and, always go to the Clojure slack beginner channel and don't hesitate to ask questions and for help. Now try to build something from scratch, like try to write a tic-tac-toe game, or write a search engine, or whatever you prefer. There are two kinds of Functional language.

There are those who rely on first-class functions as their unit of abstraction. In those, functions close over their environment, and can be passed around as values. Python has support for this type of functional programming, but it is somewhat mediocre compared to most Lisps. Python still relies a lot on Classes and Objects, and there are some constraints with the way its functions are first-class especially around anonymous functions and partial application.

Scheme and Racket are pros at this when it comes to Lisps. And then there are those where data is immutable, and most functions are pure. In those, everything will be an expression that returns a value, instead of a statement which returns nothing.

Recursion will be used for looping, because data can't mutate, so it must be passed along. Records will be value based, instead of identity based, because they are immutable. Clojure is the king here when it comes to Lisps.

Nothing will be easier to do, especially to you, someone unfamiliar with Lisps, and learning it. But it should be more fun and more rewarding. The development process is more interactive, Lisp languages tend to have every feature under the sun for you to learn and mess around with.

Also expressiveness is really high, that means anything a little boilerplate, or requiring too much typing or contortioning can be factored out by a Macro. And structural editing is quite productive once you learn how to use it properly. And once you know a Lisp, you can start exploring Emacs, and understanding how Emacs work, and how to modify it to your liking, which is a very fun new world of possibilities.

There's Emacs. I know that Walmart was still is? I use it at my work for secret stuff ; , but it's handling backend micro-services processing thousands of requests per second. Circle CI pretty sure have a mostly Clojure based stack. Consumer Reports online is apparently built in Clojure.

Apparently Atlassian have some Clojure backends. Boeing apparently runs some Clojure based in-flight diagnostic. ITA apparently uses CL for searching for airfares. And AutoCad uses CL it seems. NuBank is entirely written in Clojure, a pretty big fintech bank in Brazil of devs. AdZerk an ad serving company, and NextJournal, an awesome data-science notebook offering both have full on Clojure stacks. Apparently Cisco has a product called Threat Grid which is implemented in Clojure. Because everyone that could learn it, like you, back out because they ask this question :p Chicken and Egg is the answer really.

Though I'd say, Lisp is tailored to experts, it doesn't make things easy and obvious, it kind of gives you infinite flexibility and customization. It has the opposite mantra of Python, the one and only one way, Lisp is like all and every possible way. So imagine a language that gives you infinite flexibility and customization, and every possible way to do anything and everything, yet is dynamic and without static type to help guide you in any of it, and has a syntax that isn't like anything you've learned in school, not like the math you know, not like the English you speak.

That kind of language can't be wielded by just anybody. Go with clojure, it's by far the most mind altering Lisp because of it's extremely nice immutable datatypes. Common lisp by comparison, feels arcane, outdated and non lispy. You have to learn non composable macro syntaxes, and it's often way too low level and concerned about memory and imperative code and OOP. Scheme is nice in terms of self contained purity, but then again not as nice to use and not as mind altering as clojure. Clojure is basically a lisp build around immutable datastructures, common lisp is a lisp build around metaprogramming, and scheme is a lisp build around lambdas.

Only because Common Lisp has been around so long that people have forgotten what Lisp was like before it. Do you know the rest of the story, too? Posner, James L. McDonald, Jon L. White Eric Benson, Richard P.

Gabriel Lucid, Inc. Many companies used it during that time for deployment of Lisp applications. I hadn't heard of L, but that seems in line with Brooks' earlier criticism that the language was too big.

The Common Lisp product was great. L is a Lisp for embedded systems. It's a subset of Common Lisp - nothing unusual. The origins of lisp are that of a mathematical tool. Clojure is much closer to math with its referential transparency, immutable datatypes, deep proper object equality, and data first philosophy, than common lisp with its systems programming, lisp machine, need for speed approach. If we're talking origins of lisp, the original description of lisp[1] spends much of its time describing cons cells, something that clojure lacks completely.

Yeah and the original cons cells had proper equality defined on them, which common lisp doesn't have. Also the original lisp wasn't a lisp In clojure you can trivially use your own cons cells and get equality for free, in common lisp you can't build the proper mathematical properties without essentially reinventing clojure. Substantiate your claims. Most things in common lisp don't work with 'equal', which "poisons" the well so to speak.

For example hash tables. Quit with :quit or Ctrl-D on empty line. Nice to hear, not CL tho ;P The equal ' 1 2 ' 1 2. But I'm really not sure if that's a bad thing. Clojure has it's own std-lib. You can even share a significant part of your code between clojure and clojurescript.

The origins of Lisp is 'list processing', hence the name, which is an abbreviation of 'List Processor'.

Earlier he experimented with list processing in Fortran, but wanted to have a whole new programming system. Turns out we're both right. I considered it important to make these expressions obey the usual mathematical laws allowing replacement of expressions by expressions giving the same value. The motive was to allow proofs of properties of programs using ordinary mathematical methods. This is only possible to the extent that side-effects can be avoided. Functions with side-effects are common in LISP.

That's why LISP functions are more like traditional procedures and less like mathematical functions. Did you even read the piece by McCarty? He talks about how it was meant as an alternative to the computational models based on turing machines in addition to a symbolic computation tool for AI and therefore used side effects for convenience but also tried to keep mathematical properties, like referential transparency. Tbh it seems pointless discussing this with you because the idea of common lisp being the embodyment of the lisp philosophy seems to have become personal to you.

Sorry my energy reservoirs are drained, I'm just gonna ignore your posts, and head back to work, there's a large CL codebase that needs to be rewritten to clojure and that's stressful enough. Only if your knowledge of Common Lisp is at the level of "armchair specialist". Much of this appears to be related to Clojure which has not only become a properly separate dialect of Lisp in its own right, introducing many of its own good ideas, but also now has a near-identical version targeting JavaScript and has inspired many other Lisps targeting other platforms.

I would say Scheme, solely because of the Little Schemer , which is one of the most mind-blowingly fun yet extremely hard books I've ever tried to read. This combination is fast, powerful, mature and well-documented. Also Clojure is a gaining a lot of mindshare these days, and for good reason.

Great data structures, profoundly good concurrency support puts Scheme and CL to shame in this regard , and a great community. This isn't to say I don't enjoy CL or Scheme. And CL brought me to Clojure. It all depends on your goals I suppose.

If you want to learn a Lisp that is immensely practical go for Clojure. Otherwise CL or Scheme are both great. I learned Scheme in school.

It was a great learning experience and I will never forget the fundamentals of functional programming. It probably doesn't matter which version of LISP you pick up, as long as you understand the core of its usefulness - stateless lambda calculus.

I would say all of them, at least at first. Eventually you will probably develop a preference for Scheme or Common Lisp, but they both have enough differences that it's best to get a handle on everything that's out there. Scheme has continuations for example, and it's good to learn about those in Scheme, even though they can be implemented in Common Lisp. Learning the difference between lexical and dynamic scope is important, and if you learn both Common Lisp and elisp you'll come across the implications of both.

Was a kind of "loaded" question to begin with but OP probably didn't know about it. Which one is best is probably not as relevant as which one "works" for you. Really, there is not that much difference. Likely a preference for one over the other maybe influenced by which one you learn first. For one thing, SBCL is very strict. If you just want to "have fun" the GNU clisp is easy and available for virtually every platform.

Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow.

Learn more. Which dialect of Lisp should I learn? Asked 12 years, 4 months ago. Active 3 years, 3 months ago. Viewed 35k times. Improve this question. Humphrey Bogart Humphrey Bogart 6, 12 12 gold badges 50 50 silver badges 58 58 bronze badges.

Duplicate: stackoverflow. I did a search on that before I asked this but the nature of the question evolved as I was typing it. I will ensure not to reinvent the wheel. People always talk about how macros in Common Lisp are "unhygienic" by default, but it is trivially easy to write a hygienic macro on Common Lisp. There is a big amount of documentation available and in the last 10 years the amount of libraries, books and tooling has increased to make CL programming nicer than ever. The implementations can be really high performance.

SBCL can be had for free and it's performance is awesome. It is amazing that a dynamic programming language could be that fast. Also the implementations are mostly very nice to the programmer. Common Lisp also allows to do low-level stuff if you like, for example it has full support for bitwise binary manipulation.

Numeric support is magnificent and standarized: All CL implementations support real, fractional, complex, int, arbitrary precision numbers, and work with them really quickly. Clojure seems more limited compared to Scheme or Common Lisp, being tailored for doing everything the functional way; while both CL and Scheme allow you to be 'eclectic' and use whatever programming paradigm the situation calls for.

I'm using Chez Scheme for a side project. It supports R6RS. And should power Racket soon! Blackthorn on Aug 18, [—]. It has Pulsar, which is miles ahead of any other lisp's threading abilities. I wish it had a more mature static typing story, but I guess you can't have everything. It was designed for concurrency.

Yes, I suppose LFE has a pretty good concurrency story too! KirinDave on Aug 16, [—]. Clojure is, I think, still my most go-to Lisp. You can argue Clisp is easier to get a quick project going with, but short of that rather old project nothing with a setup any less capable than "lein new" is going to compare for dashing something out real quick. Because it works. Because it's not frustrating.

Easier to use than sbcl, which mostly fails to install. That's interesting, because I've never had sbcl fail to install from a package manager on linux, BSD, or Mac. Since decades on windows with foreign locales. The installer just breaks, and self-building fails also. With rpm or apt it works of course, but doesn't feed my interest. Are you sure? My machine is localized for spanish language. Elisp, because it's the practical way to do "real work" in Lisp under the radar ;-.

Cheating because it's not a lisp. But it was created by a schemer who originally put scheme in the browser before he created javascript. Not what I prefer, but it's the most lisp-like language I actually use in real projects. The support for closures, lisp-1 invoking functions from variables, and dynamic typing feel very scheme-like. No, it's not even sort of a Lisp. JavaScript is not secretly a Lisp. I know there is no formal definition, but without homoiconicity provided by s-exps, it is hard to call it a lisp.

Of course, it sounds like you're well aware of this. Do you use a lisp for hobby projects. There are a bunch of Lisp dialects without s-expression syntax. My bad M-expr syntax wasn't homoiconic. JavaScript is not a lisp. Hacker News new past comments ask show jobs submit.