Archive for December, 2007

2007 Book List

Tuesday, December 25th, 2007

Here’s my yearly list of books that I’ve read. I’ve put the titles I think people ought to read in bold.

[1] The Soul of a New Machine
[2] Zinn and the Art of Road Bicycle Maintenance
[3] Learning GNU Emacs
[4] The Diamond Age
[5] Snowcrash
[6] The Pleasure of Finding Things Out
[7] Mona Lisa Overdrive
[8] The Urth of the New Sun
[9] Dreaming in Code
[10] Positively False
[11] Managing Humans
[12] The Pragmatic Programmer
[13] Practical Common Lisp
[14] Hackers and Painters
[15] The Cathedral and the Bazarre
[16] On the Road
[17] The Mythical Man Month
[18] The Knight
[19] The Wizard
[20] Memory as a Programming Concept in C/C++
[21] True Names and the Opening of the Cyberspace Frontier
[22] Revelation Space
[23] Outdoor Survival Skills

My History of Programming

Wednesday, December 19th, 2007

This essay is a somewhat brief history of my programming experiences. It is by no means all encompassing, but I’ve tried to hit all of the big moments in my programming career (my favorite classes and so forth).

Although I had experimented with QBasic a little bit as a lad, it wasn’t until High School when I got my TI-85 graphing calculator that I really started to program. The TI-85 was a wonderful device that allowed users to program in a BASIC right on the calculator using the keypad. The primitives and control structures were all listed in horizontal menus, and you’d select which one you wanted using the menu buttons as the top of the keypad.

I didn’t have a manual on BASIC, so I fooled around with each keyword until I understood what it did. The first program I managed to write was a simple Fahrenheit to Celsius converter. The program prompted the user for a number, which would then be run through the function c = (f - 32) * 5/9. I followed that up by giving the program modes so I could also convert from Celsius to Fahrenheit. After that I programmed miscellaneous math programs for the classes I was taking at that time, most of which were for trigonometry so that I could verify my answers.

Sometime around the summer of 1999, I purchased one of those “Learn in 30 days” books on Visual C++. It was so awful that I stopped using it after Day 2. I made an assumption that C++ was universally awful, and I stopped going down that road altogether. So I gave up on C++ and kept doing little things on my 85 for the rest of High School.

I enrolled in a University in 2001 and wasn’t certain what I wanted to do with my life, so I signed up for two General Education classes and the introductory Computer Science course since it sounded like fun. The course (cs110) was taught in Java by Prof. G. Object Oriented programming pretty much blew my mind–everything was so abstracted and elegant. The next course (cs111) was an extension of 110, further exploring abstraction and data-hiding. The only project I recall from either class was a movie rental program that allowed users to register products (DVD’s and VHS tapes), and check them out to customers. To augment 111, I put together a little command line battle simulator that allowed the user to equip items (which never changed), and battle a single monster to the death. It was kind of like those old text games such as Adventure, or Zork–except without features.

After cs111 there was a jump in difficulty, as I took a course on Data Structures from Prof. A. It wasn’t so much that the ideas were tough, it was that his style (at least at that point) was to throw the class into the deep end of the pool, with three large assignments of which he provided a specification that we had to program. The lectures were rarely on the same topic as the assignments, forcing us to come into our own by researching and developing our own solutions (meanwhile studying the lectures for the tests). At the time the experience freaked me out, but now I’d consider it one of the most helpful exercises I had during college.

The next interesting course I took was on assembly language, which I must confess, is probably my favorite language. Everything is broken down into logical little pieces and you’re able to see why, and how every single little thing in your program is working.

The quarter after I took the course on assembly, I didn’t feel like I had built any large programs, and that I wasn’t really doing anything interesting, so I started programming a Multi-User Dungeon (MUD) in Java. I used it as an opportunity to teach myself 1) Network programming and 2) Multithreading. This project, which I called Vagabond, progressed pretty far. I got it to the point where there was a map that players could walk around on using simple keywords such as north, south, east, and west. Players could load, and save data. They could also interact with other people that were logged in. I even programmed my own text formatting library that used a subset of HTML to specify where on the screen text should be placed, and what color it ought to be. This enabled me to spruce up text such as “A <bold><green>Green Dragon</green></bold> draws near!”. Players could also use the color tags. Here’s a screenshot:
vagabond mud screenshot

It was about this time that I started teaching myself C. I was getting antsy to ditch Java (which all the courses up until this point other than the assembly course were taught in). Specifically I wanted to be able to interface with all the great C api’s that are out there. So I went to the university library and checked out their copy of K&R C. I had that book checked out for six months straight before I could afford to purchase my own (speaking of which I ought to donate a copy to the library..). My first C program was a little utility to convert number bases. I started out by having the user input a number in decimal, and it would simply print out the binary representation. Frankly it was easy, but most of the exercise ws to teach myself pointers (and the requisit arithmatic), and pass by reference. I also started to dabble in TeX, the great typesetting markup language since I wanted to print my sourcecode out and have it look nice.

Coincidentally, after that the CS courses finally started using C and C++ as their main languages.

The only two other classes worth mentioning were the Parallel Processing class I took, which used MPI as its API, and Computer Graphics which used OpenGL. Parallel Processing was one of the funnest and neatest classes I took. We had to take specifications and transform them into parallelized C programs. We then had to test them on networks with variable amounts of nodes. There’s something alluring about having to stay in a lab until it closes to rig up a supercomputer.

Computer Graphics was also great, there were only five people total in that class, so there was this weird, fantastic, signal to noise ratio with the professor. My term project for that class was a Legend of Zelda clone. The class didn’t even cover raster graphics (bitmaps/pictures), just vector graphics (mathematically derived), so I had to research and design pretty much the whole thing myself. I wrote it from the ground up, incorporting BMP’s, and used a certain gaudy pink color to mark areas I wanted to be transparent by upscaling to the RGBA colorspace (So if R=255,G=0,B=255, then when I convert it to RGBA, I sample it as R=255,G=0,B=255,A=0 for complete transparency (a=255 for anything else)). I got carried away with the clone and added audio support for background music, and a bump sound when Link would collide with an obstacle.
cs440 zelda

At that I graduated with my Computer Science degree, and since then I’ve led and trained a bunch of testers (albeit not programmed) a video game for Microsoft Game Studios, and learned Common Lisp. I’ve also been slowly rewriting the Legend of Zelda clone using a much cleaner approach, and I’ve been working on an open source version of Conway’s Game of Life called blife. blife is almost finished, and the newer Zelda clone is working, but I haven’t released anything yet.

LispCast

Thursday, December 13th, 2007

I’ve been enjoying a screencast put out by Eric Normand over the past month and a half. The topic that he’s been covering is programming in Common Lisp (which I’ve been studying for a few months now). During each episode, Eric works on a Reddit clone in CL, using freely available libraries such as Hunchentoot (a webserver written in lisp) and CLSQL. He also takes time to develop unit tests using Selenium, so that as he iteratively adds to the program, he is able to make sure that all functionality stays in tact.

Debut

Monday, December 3rd, 2007

The first videogame to bear my name, Viva Pinata (Windows version), was released about a month ago. It is currently somewhat tough to find in stores, so if you plan on purchasing it you may want to do so online. The game was initially created by Rare, and ported to the PC by Climax, and was published by Microsoft Game Studios.

If you have no idea what this game is, let me give you a quick overview. You play as a farmer, aptly personified with a shovel avatar. It’s your mission to attract Pinata-animals to your garden and domesticate them, while converting evil “sour” Pinata’s to your cause so that they do not kill your livestock. There are a few different super-varieties of Pinata that will require different varieties of plants and landscapes. For instance, you’ll need to have a water garden to get the Chippopotamus, and Dragumfly–and a savanna to get a Horstachio.

You can use your shovel to whack open Pinata’s. As you do so children will cheer. Your other Pinata’s will then rush over and eat its sweet sweet candy.

I’ll post a screenshot of the credits whenever I am able to do so. ;D