The first law of Lazy Punditry is: If you have something to say, and wait long enough, someone else will come along and say it better.
I’ve been finding the Twitter phenomenon truly baffling. Why would I care to post an up-to-the-minute timeline of my life? Why would I care to follow such a timeline of someone else?
Like DrBacchus, I may eventually try out Twitter just to see if I really am missing something; but frankly, it’s not high on my list of things to do.
Antonio Cangiano’s blog post, Haskell Eye for the Ruby Guy, is worth reading on its own merits; and it feeds into a series of blog posts I have brewing, and which will boil over and splatter all over this blog shortly. (Metaphors are meant to be tortured.) But one of the comments, by “Procyon”, particularly caught my eye:
There are only a handful of language that define all the current paradigms. If you know them, then you know ALL computer languages, given a couple hours to pick up their syntax.
Haskell, Scheme, C, Smalltalk (or Eiffel, or Java. OO is so overrepresented you have lots of good choices.), Prolog, Erlang, and Forth. Learn those and you will have fad-proofed yourself. All the fads for at least the next 10-20 years will just be combinations of these basic language paradigms — unless something truly revolutionary happens, but we will recognize that easily if it happens.
That’s it, in a nutshell; that’s what I’m after. I want to find out the deep ideas underlying the craft of programming, and be able to ride the ebb and flow of industry trends with some grace and wisdom.
From Procyon’s list, I still need Haskell, Scheme, Prolog, and Erlang. He also lists Forth, which I’ve never used; but I spent a fair amount of time writing code to generate PostScript, which is an NP-complete stack-based language that is clearly based on Forth. If that line item is meant to represent stack-based programming, I consider it checked off.
I learned OOP by reading the first edition of Bertrand Meyer’s Object Oriented Software Construction. Thus, I learned the principles in a pure implementation of the paradigm (Eiffel), then going on to apply that knowledge in a hybrid implementation (C++, Perl, Python, Java). I’d followed that pattern once before to good effect, learning the principles of modularity and information hiding in a (ruthlessly) pure implementation of it (Ada-83) and going on to apply it in C. Having had some success in this path, it sounds as though Haskell should be my next step: it is the purest available implementation of functional programming.
Of course, I still need to finish my Java certification goals first.