Which (computer) language to learn next?

Ok, I have as one of my professional goals, to learn a new computer language. I am at master level in several, proficient in others, and have working knowledge of a fair number. I’ve forgotten more than I care to admit about some (Fortran, Basic, C/C++, APL, x86 Assembler). The contenders for me should be useful languages. These are not things that should be learned for the sake of learning, but for real useful purposes. Right now the list I have in mind are:

  * Go
  * Rust
  * Erlang
  * Lua

Go looks interesting in that it looks like something fairly easy to develop in. I like to code in a way where I don’t have to write a great deal of boilerplate to accomplish simple to complex things (I am looking at you Java, Python, and others). There should be clear expressive power in the syntax, the appropriate amount of syntactic sugar to make coding easy, but then the rest of the system should just get out of the way (which is what Perl basically is). Go looks similar in concept, with a number of things that are quite interesting to me. Perl never really did multithreading well. Neither does Python nor Ruby. In all cases, you have to appeal to a lower level pthreads like implementation. And having done my fair share of pthreads style programming, it sucks. Perl has some nice modules to hide all of this, so multi-threaded shared memory programs are easy to code, but this is simply hiding the pain (and its, alas, not real shared memory threading … its processes and IPC … not ideal). Go has this built in by default. It appears to do a terrific job with it. But on its down side, it appears to have the java penchant for verbosity … albeit with a saner design. Verbosity for the sake of verbosity is … well … not a good design point. Rust looks very intriguing. Again, similar in some ways to Perl, but looking like a more modern design, and very much a “hard things should be easy to do” approach. I am still not a huge fan of callbacks/closures though I see their utility in some places. They do make debugging somewhat more challenging in a number of cases. For things like node/javascript, they are all about callbacks/closures … which has driven me nuts at times trying to find out where code goes off-reservation. Its interesting in that variables are immutable by design, unless you enable them to be mutable. Which is intriguing … but I think also unnecessarily complicating. Usually when I declare variables … I want them to be mutable by default, and constant only if I insist. This is a “minor” issue I see, but one I think I can work around. I like Perl’s “my variable” bits for local variables. The Rust “let” command defines the space for storage, and the “let mut” tells you that you can change that. Erlang has been in use as a soft real time language with built in concurrency and availability for years. It has a number of interesting design points. Its syntax is also quite different from others. I am still trying to figure out if this would be useful to us. Lua is interesting as it is used as an embedded language in a number of cases. Something akin to the way Forth used to be used. Very interesting at a number of levels. A nice JIT is available as well.