Boy I think I took that advise from the wrong source.
Math can make me a better programmer.
Statistics can make me a better programmer.
Accounting can make me a better programmer.
Biology can make me a better programmer.
Chemistry can make me a better programmer.
Building Macros and DSLs are the new Ivory Tower of software architecture.
I started out in 'scripting' languages, and I can even say that learning Java, in a group with some very skilled OO gurus, was a mind-expanding experience.
I have even seen it happen, en masse, at a company which was composed of various language partisans uniting under one roof. After exposure to each others' ways, I think we all become better programmers for it.
But on the other hand, the days where one could get away with treating 'LISP' as a proxy for 'Functional Programming' are long gone. Aside from the hoary old beasts from the 20th century such as Java, pretty much all the major languages have first-class procedures and suchlike nowadays. LISP is no longer distinguished by having good support for functional programming; it's distinguished by lacking good support for procedural programming.
Spend a few months to find a reasonable ecosystem (NB: the libraries, tools and community, not just the language), then move on.
But I did learn Haskell later, and I think that made me worse at the job (C++) I was doing at the time, because it gave me the habit of trying to write C++ in a functional style and made me more frustrated with C++'s type system.
I learned Basic because I had a C64 (show of hands: anyone else?)
I learned Fortran because my Running Start advisor didn't think 8 credits of C in a term would fit into high school credits well and I had to match HS and college credits according to an arcane formula. Ok, I still shiver at the thought of Fortran....
I learned some C years later because it was a "serious" programming language. Not very well though.
PHP because it seemed like a good idea at the time.
Perl because I wanted to apply for jobs using it.,
Python because I was unemployed for a bit and bored.
Ruby because a customer asked me to teach them (yes, I objected saying I didn't know the language. I was told "that's ok!")
and so on.
However the things that have made me better have not been knowing all these languages but knowing the human side of the problems I am solving. I taught myself accounting to run my own business, never knowing that it would become my life (I now write open source accounting software).
So if I were to give a new programmer advice, it would be:
1) Learn a few languages, because then you can learn new ones easily.
2) Learn about databases, not just SQL, but also as much about the low level implementation as you can.
3) Learn about problems and other unrelated disciplines so you can better solve the problems. So yes, math, statistics, accounting, biology, chemistry, permaculture, etc. are all good things to study.
Today, statistical learning is considered to be a better approach to building an AI. Much of the techniques of ML are expressed easily and efficiently using linear algebra for which Matlab (Matrix Labaratory) or Octave is much better suited.
I think Lisp fell out of favor as it is terrible when it comes to number crunching.
[1] The dramatic collapse of this ideology is chronicled in this wired article (Two AI Pioneers. Two Bizarre Suicides. What Really Happened?): http://www.wired.com/techbiz/people/magazine/16-02/ff_aimyst...
The first statement is true: statistical learning is considered to be the leading edge of current AI research, especially since it attacks combinatorial explosion head-on. However, linear algebra is the baseline of current work, rarely the driving force. While the 'pull eigenvectors out of shitloads of data" method has been very effective and profitable, it is a very shallow approach to AI (especially considering the problems attacked in the 60s). Luckily, more intelligent algorithms are being developed that combine symbolic and probabilistic reasoning in a more direct way: compare LSA to LDA for example; LDA has a more cohesive and explanatory structure. These kind of things demand flexible programming environments (such as Lisp): Matlab is where algorithms go once they've been proven useful for 'normal people;' it is the domain of the analyst who cares about the data instead of the algorithm itself :).
I thought C++ (.mex or .oct files) are where algorithms go once they've been proven useful for 'normal people'.
[1] http://bfrsblog.blogspot.com/2011/10/making-emacs-first-clas...
[2] How I miss the free Matlab license at the Uni. Last I checked a commercial license costs about $2000. So, now I've been forced to shift to Octave. Heck, if Octave is good enough for Andrew Ng, I guess its good enough for me.
A more useful exercise is to consider the factors that go into people choosing a language in the first place. I don't think people usually think hard about how powerful or elegant the language is, at least when they're starting out, rather they pick it up when they need to solve a specific problem. For example, here's how I ended up using the languages I've learned in the past:
QBASIC - Because I wanted to make video games when I was a kid, and things like functions and classes and scopes confused 10 year old me. The idea of executing a sequence of commands was simple enough to grasp.
C - Because that's what all the "real" programmers used, and I had reached the limits of what I could do with basic.
VB - Because writing a GUI in C sucks.
Perl - Because that's just what you used for web pages at the time.
Java - Because of college.
C# - Because VB was pretty lame.
Python - Because I needed something better to write small programs in, and the entirety of perl would regularly fall out of my head because it's too complex.
F# - Because C#'s verbosity gets on my nerves and everyone was all up on functional programming; but I found the library support in most other functional languages lacking.
Ruby - Because it's kind of the lingua franca of web startups at the moment.
And on and on. I'd say about half the languages up there are actually pretty awful, and none of them are as good as LISP, but they did something specifically useful for me at the time I learned them. I can't really say that about LISP, because LISP doesn't really have a niche. The reason I ended up learning LISP (Clojure specifically) was because I wanted to be a better programmer, but I don't think that's really a strong enough argument for it if people want it to "win"