I’ve been trying to write something here; really, I have. I have several unfinished drafts saved, staring me in the face. But, since I can’t think of anything worthwhile to say, I figured I’d share a story instead:
As far back as I can remember, I wanted to make video games; I have pictures that I drew in first grade of a stick figure with a pocket protector holding a computer monitor. But it was only recently that I learned these game-making magicians trained and lived in a magical kingdom known as Programmerlot. I decided that if I was ever going to fulfill my life’s goal of becoming a game programmer, I would have to journey to this fabled land. But when I set out, I had no idea what to expect.
My first stop was BASIC Village. It seemed as though a lot of upcoming young magicians were getting their start here, so I settled down. For a while, times were good. I came to know my TI-83 calculator inside and out. I was immensely proud of myself for being able to display messages on the screen; I could even ask the user for a number, and add another number to it! But I soon became disenchanted. There was little I could do except write small math programs with my beloved BASIC. I saw a few of my peers writing games of Pong, but I wanted more. I wanted to create the games people buy in stores, not trivial calculator applications. I decided it was time to move on to something new.
While traveling the countryside of Google, I heard of a new place: Assembly Town. Apparently, Assembly was an extremely awesome language; I wanted to make awesome games, so I rented an apartment for cheap and got to work.
I never successfully completed one Assembly program. From day one, I was completely lost. I was trying to take in strange new concepts like “Assembler”, “Linker”, and “Command Line”, and it was just too much. At this point, I thought it was time to give up; I simply wasn’t cut out to be a magician. But during my studies one day, I came across a reference to a slightly more distant locale: C City. I packed my bags that night, and arrived in C the next morning.
Coming from Assembly, C was a breath of fresh air. I could insert words in my code now; complete words, readable by humans! Still, life was not without hardships; gcc on Windows was a pain to install for a novice like me. However, I quickly conquered the basics, and I then felt I was ready to take on my biggest challenge yet: Pong. Real, live, graphical, Pong. It wasn’t easy. DirectX was difficult to learn, and even more difficult to understand. My first attempt was little more than the modification of some code from a book. But in the end, it compiled. And I was able to move the paddle back and forth, and hit the ball with it. And I was happy. I thought I had the world at my fingertips. But this is not the end of our story.
I continued to work off this code to create a small game where you controlled a space ship, trying to shoot an alien (although it looked more like a Christmas tree, since I can’t draw to save my life). After some problems, it worked. More happiness. But I could sense change in the air. I was constantly reading about a district of C City I had never heard of, called C++ Square. Although many were praising it for its “Object-Oriented Programming”, I saw no reason to move yet again. I was happy with C; I had made two games. But, curiosity eventually got the best of me, and I was off.
At first, I couldn’t see what made C++ so different. It was just C, with these newfangled “Classes” and “Objects”. But when I began to study the language in earnest, I saw what made it different, and I learned the OO Ways. However, I didn’t do anything significant with C++ on my first visit to its home; by chance, I heard of a new, rather out of the way place, called Python Land. I could see it on my map, but it was far off. Still, curiosity once again got the best of me, and I was traveling once more.
I found Python Land to be very quaint. I thought it was the coolest thing in the world that you didn’t have to specify a variable’s type when you created it. For the first time since BASIC Village, I found programming to be fun. With C and C++, I always loved the problem-solving, and I liked the end result, but the process of writing the code itself was not all that enjoyable; in Python, it was. But even after experimenting a little with PyGame, I didn’t think Python would be suitable for “real work”, so I went back to C++.
It was then I made my first complete game, from start to finish, on my own: Tetris. I was pretty proud of the fact that it was in C++. Although it wasn’t really C++; it was just C with the “struct” keyword replaced with “class”. For some reason, I was having trouble applying the OO Ways to my programs. I understood all the concepts well; I knew the difference between a class and an object, and I knew about encapsulation and polymorphism; but I just couldn’t bring it together.
So, I once again began roaming the countryside, in search of someone who could teach me proper OO techniques. Being the fair-minded person I am, I wanted to find out what was wrong with the OO paradigm, in addition to what was good about it. That’s how I stumbled on Paul Graham’s essays [1].
While checking out the links in the Criticism section of Wikipedia’s OOP page, I came to Paul Graham’s website. In case you didn’t know, Paul Graham is a Lisp programmer; he’s also a very good persuasive writer. Before then, I had heard of the magical Lisp Wonderland, but I had never had the impulse to actually learn about it; but after hearing Graham make statements such as “Lisp is the most powerful programming language” and “Java programmers are unlikely to be as smart as Python programmers”, I decided to check it out.
My excursion into Lisp’s territory was fairly short. I thought it had some novel ideas- code is data, blah blah blah- but again, it was nothing to use for “serious work”, especially since it didn’t have a free GUI that didn’t require 50 other libraries. The Dr. Scheme implementation of Scheme actually has a fairly nice GUI, but I never did much with it.
Still, I liked the Lisp language; a lot. I especially liked the parenthesis surrounding every statement (I think I’m alone in that sentiment). But the coolest thing was that it gave the same “fun” feeling as Python. I wondered if Paul Graham was right: that there are these magical “smart languages” (Lisp, Python, Ruby) that are leagues more powerful and interesting than “dumb languages” (C++, C#, Java). I think it was there I began my quest for the One True Language; something fun, easy to use, and powerful; and it needs a GUI (I’m still trying to become a game-making magician, remember?).
I decided the best place to start my search was with Java. If it really wasn’t a “smart language”, I wanted to experience first-hand why it wasn’t. When I got to the Kingdom of Java, I found it to be the largest city in all of Programmerlot. There are people all over the place, from veterans working on enterprise applications, to newbies asking for help on their CS homework.
My experiences with Java were rather good. Within a few days of learning, I was able to create a Pong Applet, and Swing GUIs. I always wondered why the long-standing citizens in the Kingdom professed it was so hard to learn.
I actually did get a minimal “fun” feeling from Java, mainly because it was so easy to quickly put something together. But it wasn’t the same fun I got from Python and Lisp. You see, while programming in Java was easy, it was also boring; extremely so. The language was so simple, I began to look at it as merely an interface to its standard library, rather than something you expressed your own ideas in. Looking for an excuse to try something new, I heard of a new version of Managed DirectX, called XNA, being released in the City of C#.
C# was easy to pick up, since I was fresh from my Java adventures, and XNA was like having a rock removed from my face after all that time working with plain old Win32 and DirectX. In fact, I’m working on a small RPG in C# and XNA right now.
Shortly after that, I stumbled upon Steve Yegge’s blog [2], where I found high praise of a language I had nary heard of before: OCaml. It was functional; which initially turned me off, since I had already had such a bad experience with Haskell; but it could also create Win32 applications, which piqued my interest again.
Entering OCamlot (which had a population of about five people) was the defining moment in my trip through Programmerlot, I think. It was then I finally began to understand the “smart language vs. dumb language” rhetoric I had been blindly spewing out for the past few months. Now, I’m not one of those language snobs who believes their language is better than everyone else’s; there are times when I would use Java, because it’s well suited for some problems. But I can see how some languages are much more well designed than others. Coding in OCaml was fun; truly fun through the whole process. My code was three times more concise than it was in Java, and it was more clever, too. I thought I had found the One True Language; but alas, I had not.
OCaml’s static type system drove me up the wall after a while. Seriously, where else do you get error messages like “This expression has type Point but here is used with type Point”? Maybe I just didn’t learn enough of it to get past that stage of frustration. I’d still rank it among my favorite languages, if not my most favorite, but I couldn’t imagine doing a huge project in it. Thus, my quest for peace continues.
So, what’s next? After my C# RPG is done, I’d love to get into 3D graphics with C++ and DirectX. But if I just stick with those languages, I’ll stop learning; and when you stop learning, you end up working on a business application written in Java. Thus, I have to keep moving on over the horizon, searching for the One True Language; but what does that horizon hold?
Much of the Great Northern Functional territory remains uncharted; exotic languages like Erlang, Maple, and Dylan await. To the west lie web languages and other oddities: SQL, ASP, and maybe a bit of Prolog can be found there. There is a tropical island in the deep south where people speak Smalltalk. I have also heard of a prosperous country not too far from Python Land where the Rubyists make their home; I believe that will be my next stop. But I have little hope that any of these languages will solve my problem. I am not an expert with any of the languages I have come across, but I know enough to know that they are not perfect. Maybe no language is.
All I wanted to do was be a magician; I had no idea it would be so complicated. Overall, the future looks bleak; but if there’s one thing I’ve learned in my travels through Programmerlot, it’s that the future holds many surprises, and things are never as bad as they seem.
[1]: Paul Graham’s website can be found at www.paulgraham.com
[2]: The archives of Steve’s blog can be found here, while his latest works are stored here