Forth because it is interestingly different - it uses reverse polish notation (which is odd but good brain exercise), it is inherently incremental and interactive and it exposes low level things in a direct way. I wouldn't want to build a large system using Forth, but learning a low level language like this is good for you.
Smalltalk because it is a great way to learn about object-oriented programming; it has very simple (and elegant) syntax, has powerful features such as reflection and closures, and is generally very cool.
Prolog because it is also interestingly different to nearly all other programming languages; it's good for your brain.
C, which these days means C++ without classes and templates: a fairly decent procedural language, capable of quite sophisticated styles, but still very close to what's going on on the hardware, which all programmers should have some grasp of.
Scheme, because Scheme is computation! Knowing functional programming is a boon to any developer, seeing what can be done with a language where code and data have the same representation opens a whole new world of programming thought, and the nearest thing to an optimal mix of the two is Scheme.
ModulaThree?, because it teaches you large-scale programming, and you should learn one statically typed language so pick a good one, and you should bit-twiddle at least once in your life.
Scheme, or even Lisp, another vote because they teach you about programs as data.
Prolog, again because you should do at least one non-procedural language.
Python for anyone learning their first language, or for anyone who simply wants to get a job done without having to fight the language every inch of the way. People on the comp.lang.python newsgroup have reported successfully teaching it to children as young as eight. The only problem with learning it as your first language is that most of the languages you subsequently learn will probably seem ungainly and crude.
JPython/Jython same language but implemented in Java and compiling down to the JVM. Lets you combine the ease of python with the ubiquity of Java. The name was recently changed to Jython when the Python team moved out of CNRI.
C/C++/Java so that you can implement time critical bits of Python programs in a lower level language.
Smalltalk although there are more popular, languages that support late binding, dynamically typed, OO programming (Python and Ruby come to mind), none of them give you anywhere near the same warm fuzzy happy feeling that coding in Smalltalk gives you. Like LISP and Scheme, Smalltalk allows you to create both data and control abstractions that seamlessly extend the base language. Unlike LISP and Scheme, Smalltalk code is readable by humans <ducks flying bricks>.
Haskell to see that static typing doesn't have to be a straightjacket, and to see the power of lazy evaluation, currying, higher-order functions and function composition.
Mercury a logic programming language with no imperative features (such as Prolog's cut operator), that compiles to very fast native code.
Squeak (not just smalltalk), this is a trick one, if you really get into it, it teaches you about C,C++ and virtual machines, which is pretty close to assembler and bare bones hardware.
ML (www.dcs.napier.ac.uk/course-notes/sml/manual.html) because all good programmers are lazy. Currying, recursion and lazyness are my fond memories of ML, a language with no nasty side effects.
Lisp, because languages are evolving (regressing?) in this direction according to some. Also because some upstart guys called ITA Software apparently recently thrashed Expedia and Travelocity with a product written in Common Lisp (www.paulgraham.com/carl.html). Its also wierdly different (to this Java developer anyway). Good Lisp code is said to resemble a whole new language invented for your specific problem domain.
Python, because it has all (ok, most of) the power of Perl, with a syntax non-hackmeister Java programmers like me can understand.
Java, because it strikes a good balance between the raw untrammelled power of C/C++ and pragmatic, get-the-job-done simplicity. Also because of the cool refactoring tools.
Java, because it the power, the robustness and the mountain of APIs to do a whole lot of real-world tasks in a way acceptable to corporate sponsors.
APL, because a language where arbitrary multi-dimensional array structures are first-class data types, control flow and loops are only for beginner who don't "get it", and you need a whole special keyboard for all the non-standard operator characters has got to be cool :) Really though, it's a fine example of how a no-compromizes pure-maths approach to language design can result in astonishing power.
Forth, as a reminder that elegant languages need not be high-level, bloated or slow.
Extending the above, the innocent-sounding question 'what's the difference between static typing and dynamic typing' proved surprisingly controversial --SallyMoss
I'm impressed at how much you remember... --SteveF
Something else I found revealing was that all three august gentlemen listed above commented that none of their recommendations tend to be practiced in the quotidien world of business. In fact, only practical TimM recommended Java to keep the wolf from the door. There was a definite bias towards 'interesting' languages. There was also a division between those who favour parentheses(KeithB, in spades!) and those who don't (IvanM - RPN, honestly!)
I didn't say I didn't like parentheses! (TimM did though). Lisp and it's variants are interesting too and the parentheses aren't a problem if you have a bracket matching editor. Also - I have to admit, Java is the best one to learn from a career point of view (at the moment - who knows when that might change). (-- IvanM)
Hey, I think you'll find there are plenty of C and FORTRAN jobs going around. Not that I'd want to do any of them. Again, that is. (perfect-tense(for-a-while(make-living-off 'C 'KeithB)))
This is the first time I've been called a gentleman in ages. And in December too...
I guess our point is that if you learn these languages, you will have a good background for picking up whatever happens to be fashionable just now and are likely to do a better job. --SteveF
It's tempting to compare languages in isolation from where you'd use them. Personally, how I evaluate a language depends on where I'd use it. Here are four different contexts:
A low-level language (like C, or an assembler) It's a big step up from a beginner's "baby minding environment" to your first "unforgiving" environment where you have to think about low-level issues (e.g. bit-level work, pointers and hardware)
An everyday production language (separation of concerns and powerful abstraction being the chief emphasis)
Some sort of scripting language, almost certainly untyped and interpreted. Exposure to these should emphasize ubiquitous automation and throwaway prototyping.
Something declarative rather than procedural. This language should make some kind of task much shorter and simpler than it would be in an imperative language.
At the moment, I'd settle for C, Java, Python and Prolog respectively (trying to balance education and commercialism). I could be persuaded to substitute Ruby for Python if I had more time to play with it.
I'd like to revise my choices. But I'm torn. I still would very definitely recommend C and Scheme, but as time passes I'm less convinced by my own argument in favour of FORTRAN. Don't know what to replace it with, though. Self or Smalltalk would be the obvious choice (more as examples of what a really good environment can be like, than for the OO-ness of them), but that still doesn't feel quite right. The third should probably be a "scripting" language, but the question is about languages that you have learned, and the only full-strength scripting language I've learned is Perl, which I wouldn't recommend to anyone, other than as an object lesson on how it's possible to have too much of a good thing. --KeithB
WhatThreeLanguagesWouldYouRecommend