Log in

No account? Create an account
14 August 2008 @ 07:53 am
In the programmer communities I frequent, there's a recommendation, a bit like "get enough calcium", that goes, "you should learn a new programming language every year." These days there are so many new ones coming out that it's easy to find the languages, it's just a question of how much time, energy and attention you want to throw at the problem.

I decided to sit down and count. And you know, if I decide that I started my programming career in 5th grade (that's about where I started to get serious, I think), then I have actually done that. In rough chronological order...

Programming Languages I Know or Have Known:

Early years through high school:
AppleSoft BASIC
6502 assembly language
x86 assembly

MIPS assembly

Early work years:
Java/C# (I know both only a little and they're very similar, so I count 'em as just one)
ARM assembly
LPC (DGD's dialect)

Last few years:

Not counting because I never got seriously literate with them:

So it looks like I was a slacker in my early work years, but made up for it recently :-)

I'm also not counting a lot of language-like complex things like file formats (RenderMan Shading Language comes to mind), language-like tools (Make, Jam, XiLinx FPGA design language) or protocols (TCP/IP, simple cryptographic protocols), though one certainly could. I believe it's a fairly similar kind of healthily mind-expanding. With those, as with programming languages, you don't learn much from the part that's mostly like the languages you already know. The healthy part is learning the parts of the language that *aren't* already familiar. Which is why I'm going to learn Haskell one of these years :-)
vito_excalibur on August 14th, 2008 03:19 pm (UTC)
I expect this is why Mr. E is learning Haskell!
Noahangelbob on August 14th, 2008 03:32 pm (UTC)
Very likely. It's definitely got one of the best reputations as a brain-food language.

And weirdly, these days it runs pretty fast. Most language-weenie languages do very poorly that way.

I've looked at it, but found it pretty dense and unapproachable at first blush. So I've put it off until I can put more dedicated time into learning it.

S'okay, I'm still on schedule to learn a new language this year. It looks like Lua is going to be the right embedding choice for something we're doing at work.
msde on August 14th, 2008 07:23 pm (UTC)
Amusingly enough, World of Warcraft taught me Lua.
eqeeqe on August 14th, 2008 04:31 pm (UTC)
Ah, thanks, I should take my morning vitamin. :)
Kathleen by daykarenbynight on August 14th, 2008 04:54 pm (UTC)
I'm surprised to see you put HTML here. I tend to silently disagree with people who call it a language or using it "coding". It doesn't even have control flow statements, does it? I've known NROFF, but probably wouldn't put that in a list of languages I know... but I would put postscript, which does have control flow.
Noahangelbob on August 14th, 2008 05:38 pm (UTC)
I include it mainly because of the amount of time I've spent wrestling with forms and attaching JavaScript and/or Ruby on Rails to it. It could be argued that it's more like a data format for JS and RoR in that capacity, though.
JohnGgomijacogeo on August 15th, 2008 07:50 am (UTC)
Yeah, there's no way I'd count HTML as a language any more than FITS, HDF, or NetCDF, or a host of others.

I think you could count Make as a language. Certainly if you push it to do serious magic. I worked on a project a long time ago that scheduled a bunch of work through a supercomputer center. I took the job requests and a list of dependencies and ran it through an architectural simulator to pack the jobs as well as possible and then exported the graph as a giant Makefile to actually launch the jobs. Make handled the run-time vagaries: say an estimated 300 second job only took 290 because of slightly higher disk bandwidth, if it could launch the next job a little earlier, it would. We tuned the architectural model well enough that the integrator for the project was ultimately willing to take the predicted run times in lieu of having to perform every multi-hour run. This allowed us to do 4-5 design iterations per day rather than 4-5 per week. We wound up winning the $(9-digit) deal and buying our main competitor.

I'd add another recommendation - call it the "Calcium ain't worth crap without vitamin D" addendum - every month, in one of the languages you already "know well", download and become passingly familiar with another module or library.

A few other ideas you might find interesting:
Cross language linking - with enough work, you can get almost any language to call a routine compiled in another language or share data structures. Similarly, there's a lot of potential magic down in the bowels of ld with linker scripts.
If you happen to like mathy things, R is cute.

Anyway, I should take my own advice more often :-) Good luck.
Noahangelbob on August 15th, 2008 02:17 pm (UTC)
Fair enough. Jam (another make-type tool) is similarly languagelike, though most of its control structures are implied. It's a bit like Prolog that way, though I like its implied control structures better :-)
msde on August 14th, 2008 07:25 pm (UTC)
Does a language count if you were moderately familiar with it 10 years ago and haven't used it since, and would have trouble putting together a hello world now?
Noahangelbob on August 14th, 2008 07:45 pm (UTC)
I include 6502 Assembly Language on my list, and I'd definitely have trouble with it now...

Then again, I was much more familiar with it back in the day.
Ryan Ingramryani on August 14th, 2008 09:20 pm (UTC)
I'd argue that it especially counts; the value in learning a language isn't having a new way to write Hello World, it's the effect it has on your mind and the way you write code in all languages, including that one.
msde on August 14th, 2008 09:41 pm (UTC)
I agree, I was having trouble trying to phrase the question neutrally.
Ryan Ingramryani on August 14th, 2008 09:27 pm (UTC)
You should totally learn Haskell. It's not as hard as it looks, although reading "expert" Haskell code can be. And some of the concepts are absolutely mind-blowing, like:

* Being able to do useful work without any mutable references at all.
* Being able to write compiler optimization rules in your source code

I recommend skipping most of the usual tutorials and start by reading Beautiful Concurrency, and then following it up with Write Yourself a Scheme in 48 Hours. Then, if you want to understand how it works on the 'nuts-and-bolts' side, go through the book Implementing Functional Languages: A Tutorial. I spent a few weekends doing the exercises from that book and had a ton of fun.
Noahangelbob on August 14th, 2008 10:33 pm (UTC)
Fair enough. I'll keep these in mind.