Playing Around: Games and scale

I've been spending the past couple of weeks returning to my roots by bringing the Project Darkstar C-language client up to the most recent Darkstar protocol and API (the one that we released as the 0.9.6 release). This became my job for the most part because I was the only member of the team not gainfully employed in doing work on the overall system performance. But it also became my job since I have probably had the most experience writing C code in the group.

In doing this, I've re-discovered what I liked about the C programming language. Even more, I re-discovered why I like the Java language even more.

I've always thought of programming languages as encapsulating models of what the computer is. BASIC makes the computer look like a calculator (historically, of course, the causal connection is the other way around). COBOL models the computer as a filing cabinet. FORTRAN models the computer as an array processor.

The C language models the computer as a PDP-11. The PDP-11, for those not old enough to know, was a great mini-computer made by DEC back in the day. It was cheap enough (by the standards of the day) that there were a lot of them around, reliable enough that you never felt like taking a baseball bat to one, and powerful enough (again, by the standards of the time) to do lots of interesting work. Although C was first written for the PDP-7 (an earlier DEC machine) it got a lot of use in the 11, where it was the system language of choice for Unix hackers.

I wrote a lot of C code early in my career (actually, I started out writing a lot of COBOL code-- a fact that I'm willing to admit, but not a time that I look back on fondly). Brian Kernighan and Dennis Ritchie have wonderful taste, and using the language was an education in itself in how to design something that was small, simple, elegant, and immensely useful. I don't know anyone who did a lot of programming in C that didn't have a lot of affection and respect for the language.

Returning to programming in C after a number of years (and the number has two digits, if we are talking about serious programming) I felt like the Tin Woodman in the movie version of the Wizard of Oz when Dorothy first finds him-- completely encrusted by rust. Every movement was somewhat painful, but once I started flexing a bit it all came back and it was remarkably fun. I found myself once again having the experience I often had, when C was my day-to-day language, of having my first version of a function taking 20 lines, and then cutting that in half, and then in half again, until the final version didn't have a whole lot extra in it. Quite frankly, it felt good and it was fun.

But it also made me appreciate the Java language all the more. I remembered what it was like before we had garbage collection (do I free here, or there-- need to do it at least once, but don't free anything twice). I remembered all of the mechanism that is needed to get the right code working on the right data structures. And while there are times when you have to do some nasty assertive forms of casting (I was reading byte streams from the network and reconstructing real data, after all) I was reminded of all of the errors that can occur when there are no checks.

Still, I did enjoy myself, and will probably do some more C coding in the near future (I've already thought of a couple of lines I can remove from the client). But it has also made me appreciate Java all the more, and wanting to get back to writing some code in that part of the system.