* C++, Java, C# or some other imperative OO language
* Scheme, Common Lisp, Clojure or some other lisp
* Haskell, OCaml, Scala or F# (and maybe Erlang?)
* Prolog or Mercury
* LabVIEW, Luster/SCADE or some other dataflow language
* Factor, Forth, Joy or Cat
This gets me imperative/OO, monitor based concurrency, Lisp-ness (homoiconic language, real macros, DSLs), functional, strong static typing, type inference, powerful type systems, logic programming, dataflow and concatenative.
Yes, there are gaps - I'd also add Oz, Python/Ruby/Boo/Groovy and J into the mix to get a more fully rounded paradigm tour and, even then, there are some things missing, though at this point you should have a strong knowledge of languages and paradigms and should be able to tackle most problems pretty well - or at least, know enough to choose a good programming language for the task at hand.
Hmm, after looking at your rather nice list, six was probably too low; I think I'll revise my estimate to a more conservative eight. There'll always be some gap, of course, but eight ought to get closer to the point of diminishing returns I had in mind.
Incidentally, I'd probably include some form of assembly as well, for the whole "must understand the underlying hardware" aspect.
Ohhh! That was certainly an oversight on my part - an assembly language should be included.
Eight should be enough, after that, you probably wouldn't learn enough to make the effort worthwhile (except maybe to learn a language for a particular need, eg available libraries). I think my number seven then would be an assembly language and my eight would be Oz, ATS[1] and J[2] (not really in the same category, but more of a misc interesting languages category). I would then add Python/Ruby/Boo/Groovy in with C++, C# and Java.
ATS and J are both unique in their own ways. I'm not sure what value there is in learning either of these (since I don't know them) but they seem different enough to teach you something new. J (or APL or K) do teach you about array processing languages and point-free programming, so maybe this is useful. ATS is interesting because of its emphasis on types in a way I haven't seen in other languages:
I'd actually be inclined to get C++/C#/Java off the list entirely due to not showcasing any one perspective particularly well, to be honest. Smalltalk or Ruby would better illustrate OOP, and between them the OOP language and the assembly should cover the basic procedural approach well enough, I think. Also, plain old C could possibly stand in for the assembly, especially if you were mostly using it "portable assembly" style instead of relying mostly on libraries.
For what it's worth the list I had mind originally was something like:
* C, for low-level procedural and machine-awareness
* Ruby, for high-level procedural and OOP (plus scripty perl-isms)
* Scheme, for distilled lisp-iness without distracting details
* Haskell, for HM static typing and functional purity
* Two empty slots to cover languages I'm less familiar with
After seeing your list, I realized I'd carelessly underestimated the number of empty slots necessary...
Yes, there are gaps - I'd also add Oz, Python/Ruby/Boo/Groovy and J into the mix to get a more fully rounded paradigm tour and, even then, there are some things missing, though at this point you should have a strong knowledge of languages and paradigms and should be able to tackle most problems pretty well - or at least, know enough to choose a good programming language for the task at hand.