I think lisp will be adequately enunciated, so I'll move on to the others
Haskell is a lazy, strongly-typed functional language. It's syntax is very close to mathematical notation, and it enables code reuse by not allowing side effects. It'll teach you to think in actual algorithms, where most languages teach you to think about how to implement those algorithms.
Prolog is a logic language. It'll teach you logic, and some of the fundamental ideas from that field. Backtracking search, unification, and other interesting ideas.
Forth is a reverse-polish-notation stack language that is very 'close to the metal' and yet a higher order language than C. Forth will teach you more about the workings of a computer than anything but assembler, and it won't break your soul like assembler might.
Erlang is strict strongly-typed functional language that is all about concurrency. Right now it's probably the best language to write highly concurrent applications in, and, as it turns out, most of the internet can be made highly concurrent.
Smalltalk is the mother of all object oriented languages, and shares with lisp the interesting concept of a running image. In smalltalk, everything you do is in a live instance of an image, and to deploy, you simply move the instance over and run it on the server. This also one of the first languages to have an effective refactoring browser.
Python is a dynamic object-oriented language that incorporates features from a lot of previous languages. It's got some interesting things and a fairly nice syntax. Take a look at TurboGears, Pylon, and Django
Ruby is a dynamic object-oriented language (lisp + perl) that is (like lisp) all about metaprogramming. Ruby has also got an interesting framework that is becoming notorious, Rails, which makes OR mapping and quite a few other things brain-dead easy. If you get into the internals of rails, you'll learn a lot about metaprogramming.
C is The Language. If it has to be fast, small, and close to the metal, C is the go to language (no pun intended) There are a lot of situations where you'll end up needing to rewrite in C if you hit performance problems, so knowing some C will let you squeeze about an order of magnitude of performance out of things. Plus, you can start to understand drivers for your hardware here.
Java is less about the language and more about the IDEs. With the possible exception of Smalltalk, Java has the best IDEs and refactoring software. This is the kind of thing that most languages should have, but don't.
Anyway, this is kind of just a menu, but if you learn three or four of these, you'll be well on your way to deciding which one suits your style.
Sorry, but I think that is complete bullshit. Why should some beginner start with Lisp and Haskell? He should start with something that is useful for him, that is, he should consider what he wants to do, pick a suitable programming language and get started.
Nothing against LISP, but if he was into Web programming for instance, I think it would be a bad choice. Maybe an experienced programmer could leverage the power of LISP for that task, but a beginner needs good documentation, examples to look at, a community to ask when he is stuck etc. I don't think LISP would be top of the list in those categories.
The value of learning all those different languages is not that they're immediately and obviously useful. The value is that each one has a different set of tradeoffs and assumptions, and being fluent in all of them will teach you how to think more flexibly.
Sure, a beginner should use a language where he gets feedback and support. But a beginner who aspires to be a real programmer rather than a 9 to 5 coder will need a much broader base of experience than he can get by only working in one or two languages, and understanding that sooner rather than later is key.
I may have misinterpreted what he wanted, but if you're asking 'how do I learn to hack', it's a whole different question than 'how do I learn to write mediocre web applications'
If your goal is to learn to build rails sites, start with rails; however, if your goal is to be good at programming and subsequently be able to build things that other people can't, in the sense of PG's hacker advantage, then you should learn to hack, not build rails apps.
I agree with this list - completely in spirit, though I'd probably recommend different languages in a few places - but I'd also recommend at least playing with a couple of "industry-standard" programming languages.
Playing with C++, for instance, especially after having used C and Java, will give you a better understanding of what not to do. And if you play with Objective-C for a while too, you'll see two ways of handling object orientation that are dramatically different: what seems like a minor difference makes for drastically different expressiveness and flexibility.
I'd also recommend picking up Perl, for a different understanding of what not to do. Ruby is at its core a reimplementation of the good parts of Perl, with inspiration from Python and Lisp, and it hits a very sweet spot as a result; Perl has a lot of good parts, but it has a lot of warts that seemed like a good idea at the time and have been preserved for backwards compatibility.
And one of the things that I've noticed is that Real Programming focuses on interfaces in a way that toy programs don't: in web programming, for instance, you're more constrained by the browser-CGI-server interface than anything else. In programming for platforms with GUIs, the learning curve is not the language you use but the API to the window system.
Excellent list, and pretty much precisely what I would have posted with a few very minor tweaks: Ruby and Python are nearly interchangeable. Time is limited, so have a look at both and pick which one you like. Tcl is also a neat language in some ways - it's even better for DSL's than Ruby is, and has the lisp like property that you can create your own control structures.
Anyway, jaggederest's list is pretty much the list to learn if you want a broad overview.
"Haskell enables code reuse by not allowing side effects"
As an onlooker, I wonder: is reuse in Haskell fundamentally better than reuse in another language where the programmer avoids (or clusters) side-effects?
Well, if you avoid side effects assiduously enough, other languages can certainly have that sort of purity.
However, you have to remember, avoiding side effects is what enables lazy evaluation, which is a huge gain in terms of performance. If you're not restricting side effects, you can't default to lazy evaluation.
True... And not having lazy evaluation encourages one to write Matrix.CalculateDeterminant() rather than Matrix.determinant, as it should be. But I don't think that has to do with reuse.
I think lisp will be adequately enunciated, so I'll move on to the others
Haskell is a lazy, strongly-typed functional language. It's syntax is very close to mathematical notation, and it enables code reuse by not allowing side effects. It'll teach you to think in actual algorithms, where most languages teach you to think about how to implement those algorithms.
Prolog is a logic language. It'll teach you logic, and some of the fundamental ideas from that field. Backtracking search, unification, and other interesting ideas.
Forth is a reverse-polish-notation stack language that is very 'close to the metal' and yet a higher order language than C. Forth will teach you more about the workings of a computer than anything but assembler, and it won't break your soul like assembler might.
Erlang is strict strongly-typed functional language that is all about concurrency. Right now it's probably the best language to write highly concurrent applications in, and, as it turns out, most of the internet can be made highly concurrent.
Smalltalk is the mother of all object oriented languages, and shares with lisp the interesting concept of a running image. In smalltalk, everything you do is in a live instance of an image, and to deploy, you simply move the instance over and run it on the server. This also one of the first languages to have an effective refactoring browser.
Python is a dynamic object-oriented language that incorporates features from a lot of previous languages. It's got some interesting things and a fairly nice syntax. Take a look at TurboGears, Pylon, and Django
Ruby is a dynamic object-oriented language (lisp + perl) that is (like lisp) all about metaprogramming. Ruby has also got an interesting framework that is becoming notorious, Rails, which makes OR mapping and quite a few other things brain-dead easy. If you get into the internals of rails, you'll learn a lot about metaprogramming.
C is The Language. If it has to be fast, small, and close to the metal, C is the go to language (no pun intended) There are a lot of situations where you'll end up needing to rewrite in C if you hit performance problems, so knowing some C will let you squeeze about an order of magnitude of performance out of things. Plus, you can start to understand drivers for your hardware here.
Java is less about the language and more about the IDEs. With the possible exception of Smalltalk, Java has the best IDEs and refactoring software. This is the kind of thing that most languages should have, but don't.
Anyway, this is kind of just a menu, but if you learn three or four of these, you'll be well on your way to deciding which one suits your style.