It is well-accepted that we should all learn something new every six months. But what should top the list for 2009? What new things should we learn this year that appear to have real staying power?

(Answers do not have to be limited to languages.)

  • C++, because the C++ 0x features will begin creeping in this year.
  • Lisp because it's been hot every year, for the last few decades for those that first discover it.
  • Ruby because it comes by default on Mac, and Windows has begun some serious support for it.
  • F# because the C# folks will want to try its functional programming within the enviroment they like.
  • Python with its new release
  • Lua because even more games will be scripted
  • Perl with its new release
  • C because people will get tired of all the other new stuff, and or they'll figure they should learn a low level language
  • Haskell because it's the thing seasoned programmers rave about
  • ...


  • JavaScript because the browser is the new OS (can't believe I forgot JavaScript)

ECMA/JavaScript, and it variants (ActionScript, e.g.).





D because D2 will probably be out sometime during 2009, and it's the best attempt I've seen so far at bridging the gap between high-level and performance/systems languages, and at bridging the gap between the procedural, OO and functional paradigms. Furthermore, D2 has broken just enough new ground to make it exciting, without making it utterly foreign to programmers who use other languages.

Other posts seem to think that pure functional languages are the next big thing. I believe this will not be the case for the following reasons:

  1. Mutable state in small scopes, such as the local variables of a function, is not a problem in practice, only for theoretical purists. In practice, parallelization happens at a granularity of at least a whole function anyhow (ignoring instruction level parallelism that is invisible to the programmer).
  2. Mutable state in the parts of a program where scalability doesn't matter is also not much of a problem. In many practical situations, only a small portion of the program needs to scale to a large number of processes/threads.
  3. Many things are inherently more awkward and/or less efficient to express without mutable state than with it.

The D2 philosophy is to take a middle ground and, rather than eliminate mutable state, try to manage it in such a way that it creates as few problems as possible, while still allowing it to be used where it makes code simpler or more efficient. To support this, D2's const system is transitive (meaning that not only is the object const/immutable, but anything reachable through the object is const/immutable), and functions can be labeled as pure. Functions annotated by the programmer as pure are statically checked by the compiler and are not allowed to have side effects. All reference parameters passed into a function labeled as pure must be transitively const or immutable. Pure functions are, however, allowed to modify local stack variables and heap memory allocated within the function, meaning that the internals of the function can be written procedurally.


Scala looks very exciting. Very powerful. Addresses many of the complaints I?ve had with Java. Type inference removes annoying redundancies. List processing is awesome. ?Properties? without setter/getter boilerplate is great. At least one excellent book now and at least two more promising books coming. A web application framework called ?Lift? is super powerful.

My goal is to become (more) competent with Scala, and find clients who want to use it.


Caja! Google + secure page-to-page interaction? Count me in.



Functional programming


C# - for the reasons detailed here.


Personally, I'm bound and determined to pick up Haskell. I'm looking forward to learning a new paradigm and some new problem solving skills.


Groovy (and Grails)


COBOL, because there's always work for programmer-archeologists.


Erlang - it's THE language for serious concurrent programming


JavaScript, because GNOME (leading open-source desktop enviornment) will be using it to develop desktop applications, giving a huge boost to Web developers, opening a huge amount of possibilities.



I almost said F#, because it's new and cool and will have Microsoft's weight behind it, but the question asked for real staying power, and I have my doubts about .NET.

If you believe .NET has real staying power, learn F#. If you have doubts about the staying power of .NET, learn Haskell. I can't say exactly which parts will take over, but during the next 25 years, many of the interesting ideas in Haskell will trickle into other languages. You will aready know them.

Haskell: after 25 years, an overnight success!


http://codehappy.wordpress.com/2009/01/02/2009s-hot-new-programming-language/ (now deleted).

According to that android is going to hit great markets this year I wanted to learn this language when it was first introduced around two years ago but until now my PC is not powerful enough to run an Eclipse IDE hehe.


Fortran's making a come-back!

  • JavaScript as web applications have hit the mainstream and you can't do them without JavaScript. It's come a long way from it's early roots and it has matured as a language.
  • Ruby as it is easy to read/write and has modern features like closures and mixins.
  • Groovy if you are a Java programmer as it runs on the JVM and you can take advantage of all of your knowledge of the Java language.

My goals for this year are Python and Ruby. Of course, as it has been for the last 15 years, I'll try to improve my skill with Haskell beyond nfact().


Clojure, for many reasons but primarily for backing away from OO and completely rethinking how to deal with state.


jQuery. I think 1/2 Stack Overflow questions today were about it.


Six months is far too much time.

Try to always be learning. If it's useful, great. If it's not, even better!


You said not only languages, so..


SharePoint and/or MOSS and/with/or Silverlight seem hot..

SQL 2008

Windows Server 2008

Dynamic Syntax in C# dotnet

Study Field: Physics (more and more a factor in computer technology research)


My guesses at a few things:

From Microsoft, there are a few things:

From other companies there are a few things that may take off:

Cloud computing is still in its infancy but there may be something that comes along to make it as awesome as the web was back in the days of Mosaic being the browser used as Netscape and Internet Explorer didn't exist yet.


SQL. All platform, all dialects.

As usual, really...


J because you'll rock everyone's code-golfing world with the programs you produce for Stack Overflow.


Oberon - because you'll be one of the five-six dozens :)


Obligatory Tiobe link. Me, I would go with Objective-C and Android, if I had the time and the actual need to program for platforms requiring them.


I would definately have a look at Clojure -- it was talked about alot at JAOO (www.jaoo.dk) in Aarhus this month


I agree with: F# and Haskell. Either one would be fine to look at. Functional programming and parallel programming are the hot potatoes these days.

We have to remember (and this was something I heard from a VERY talented CPU-guy) is that we have more or less pushed the bounds of what we can get from single-core CPUs. So, we are leaving the old RISC days of "happy single-core architecture" because we simply can't ramp more Watts onto the Silicon, unless we want it to melt. The solution is -MORE CORES- which means "parallel programming".... Look into that, not matter what platform you are on...


I would also look at HTML 5 -- particularly Websockets. Leaving the old half-duplex communication scheme, and achieving full-duplex from within the browser will change the way we think about the internet. We have grown accustomed to the stateless environment we live with web-wise... and that's about to change!


Objective-C with Cocoa and Cocoatouch for iPhone OS development. Has really been picking up steam this year/


See http://stackoverflow.com/tags for the answer.