Common Lisp is the best language to learn programming

I think that people think that imperative programming is somehow 'more natural'. I still sort of think that but, I haven't seen that bourne out when I try teaching programming.

All programming is foreign to people when they start. And you are influenced by what you start with.

I started with Forth ( ages ago ) and when I first started using an imperative language, it was a struggle for me.

Why don't you think Clojure meets those criteria?

- Canonical implementation on the JVM

- Borrows modern functional programming concepts from Haskell (type classes -> protocols, immutability, etc)

- Robust concurrency constructs. While not directly copied from Erlang, designed with clear understanding-of and respect-for Erlang's successes and failures.

- Minimalist standard library

The only thing I can think of that isn't minimalist would be the reader-macros for vectors, maps, sets, lambdas, etc. However, it seems like those serve to reduce confusion & strike a decent balance between uniformity of syntax and clarify of meaning.

Anyone can pick up Scheme syntax really fast. Where it gets difficult is when people start telling you to not use state, not change values of variables, and to stop using side-effects.

Most people have never done functional programming. How does one make the leap from imperative programming to functional programming?

Common Lisp code is much more portable across implementations so there are way more libraries and bindings to things like graphics and sound around (and easily available via quicklisp).

Racket OTOH is the best environment for learning to program in that I've come across, and I recommend it to people who ask me for advice about learning to program (despite being the author of that article). If Common Lisp had a similar environment for newbies it would be sweet, but not many people (myself included) care about Lisp IDEs.

The problem with Racket is that it has a huge problem with NIH as a project, and a lot of the libraries are opinionated about the way you use things like state.

I'm with you though. Lisp can be great for some problems but it's mostly not. The lisp guys hate hearing that and shout you down.

One measure of a language is how well it works to pass on a source base to a new team of programmers. I bet if someone were to go measure lisp against C they would find at least a 100x greater success rate with the passing on of C.

The lisp guys are profoundly focussed on how easy it is for them to write code. The real world is more concerned with how easy it is to maintain, review, enhance code.

I TAed intro CS in Java for a couple years and the vast majority of fundamental misunderstandings students had were caused by preconceptions and expectations of how things should have worked based on exactly this kind of previous experience. I think I spent at least as much time helping people un-learn things as I helped them learn novel concepts.

In the short term Java and C are friendlier, but this friendliness allows a student to put off confrontation with the essence of programming in a way lisps do not.

At my school, all engineering majors had to take freshman intro to programming in Scheme and it worked pretty well.

The important thing about learning to program is having an accurate mental model of what goes on in your program. C, and especially C++, make that much harder than it actually is and the way Lisp presents it.

Teaching students assembly as their very first language seems akin to teaching students Latin before they can learn French, German, Spanish, etc. Sure, it's helpful and...IF they get pass that first dry session.

I see CS as basically dual-grounded: everything is ultimately just syntactic sugar on machine code, and everything is ultimately just syntactic sugar on lambda calculus. Which reduction makes more sense depends on what you care about; the bare-metal view comes into play more when you're talking about low-level performance, while the mathematical view comes into play more when you're talking about algorithms and correctness. I guess it can get into some philosophical debate about which reduction is more "real"...

I'm not entirely sure which way is easier to start from. The argument you make here, that students have trouble going from mathematical abstraction to bare-metal implementation, is probably true; but I think students who first learn on asm and C also have trouble going the other way, from thinking about executing a series of instructions to thinking about enacting computations. That's one reason there's been some experimentation at places like MIT and UT-Austin with not starting with an imperative language, which they feel is very hard to get people off of once they've started with it.

For example, learning manual memory management and instilling habits around needing to worry about this made learning Java and C# a breeze. I can't imagine moving from a language with garbage collection to C would be as easy or smooth.

The execution model behind Lisp is trivially simple compared to C which makes the corresponding mental model of what your program is doing simpler.

As for what goes on "under the hood," SICP builds a virtual register machine and a Scheme compiler for it in one chapter. Find me a C book that does the same.

But you don't even need a chapter. Abdulaziz Ghuloum shows how to build a Scheme to x86 native code compiler in 10 pages: http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf

I adore Clojure (and Common Lisp to a lesser extent), but getting a new person excited about programming is far easier when they can do something useful really quickly. Python's massive collection of libraries makes that easy.

JavaScript is the language the modern web is written in and it's a language you can use to build and automate cool stuff that you can show immediately to your friends. You can build interactive programs, save state (in cookies), deal with formatting and input, and even do graphics with CSS or canvas. jQuery or its competitors will cover up most of the warts.

It's not a brain dead verbose bondage experience like Java nor deep in the metal like assembler. It isn't historic and systems oriented like C or mathy and abstract like Scheme or LISP. It can take advantage of much of the semantics of those languages as you learn it if you need them.

The tools to write and run it are simple and some good debuggers are built into your browser. Everyone owns a few client interpreters with a great application environment.

It's not pretty (boy is it ever not pretty) but JavaScript is the best language to start with.

If I couldn't choose JavaScript, I'd point my friends at Python or Ruby. They're better languages for both beginners and experts but they're not JavaScript.

I think one of the biggest problems with advocating Python as a teaching language is that programmers don't understand what the hard parts of Python are. Python is great because it's sort of a lingua franca for people who are well-versed in conventional, Algol-based imperative programming—it boils it down to its essence and omits anything unnecessary—so to a person who was versed in Java/C/C++/Perl/PHP/&c previously, moving to Python feels like everything unnecessary has dropped away. Consequently, it feels easy, and you look at it and think, "Oh, wow, this would be no big deal to teach someone, even a non-programmer."

In reality, though, you'd be surprised at the concepts people struggle with. Assignment poses a huge problem to beginners, and I have spent hours and hours of my life trying to explain the concept to baffled undergrads. Not that Scheme concepts are necessarily easier (e.g. recursion—although loops are not necessarily easier to a beginner) but that Scheme makes a point to have far fewer of those concepts to begin with. Keep in mind that in an introductory class, every new feature, no matter how small, can mean another week of instruction, which is why an intro class in C++ could mean almost no projects at all, but an intro class in Scheme could very easily give way to writing object systems, programming languages, and adventure games, as my first computer science class—using Scheme—did.

Sounds like it needs more extensions.

Ruby is a very good choice for sure. Between the two(CL or Ruby) I don't know which one I'd pick. I guess ruby has a little more practical aspects to it. Lisp has some advanced features that could be used for more advanced students.

I know you're being tongue-in-cheek with that, but I think there are three distinct use cases for learning to program.

For people who want to learn CS from a ground-up, theoretical foundation, Lisp is a nice choice. It is very easy to teach functional programming while simultaneously teaching the fundamentals of theoretical computer science, so you get the best of both.

For people who want a bit more 'traditional' approach, and also want to learn about computer science from a low-level perspective, C is a good choice. It teaches memory management and gives an insight into computer hardware & systems that higher-level scripting languages don't. (This latter part is where Java fails - how can you appreciate references and garbage collection until you've mucked around with pointers and malloc() in C?)

For people who just want to dabble in programming, or for people without a mathematical background, or for people who just want to prototype small projects quickly... then yes, scripting languages like Ruby (or Python) would be the 'best' way.

As you said, languages are like tools, but I think these three categories of tools cover the majority of use-cases nowadays for the beginning programmer.