I put down blogging for a while because it became apparent that I had little to say that is relevant outside my circle of friends. Struggling to fill this space, I found myself turning idle musings into statements of belief with conviction for the sake of sounding interesting. The truth is I have hardly any real opinions for which I could muster some conviction, and there are few things I can speak about with authority. I’m getting old now, and I just want to embrace authenticity and drop the know-it-all teenager act.

But, I like to exercise my imagination and writing muscles. The blog maybe isn’t the ideal format for me, but I’ll keep it around while I figure out something better.

I’ve also been busy. For reasons I don’t fully understand, I am on a quest to become really good at making video games, or more broadly, art. I’ve been at it since I was about twelve (before that I wanted to be a paleontologist or a ninja turtle). I’ve always spent most of my free time working towards my career goals. It has been an escape from social anxiety and depression, but it is also gratifying. I am a pretty good video game engineer these days. I have made some cool game demos and major contributions to games. I have worked with teammates I adore and respect. It has been all-consuming, and it has made me a little tired and atrophied parts of me I miss using.

But! I’m only twenty-seven. Many people my age are just finishing school. I am a couple months away from finishing a game on which I am a lead engineer. I am immensely proud of it and the team. It sounds like rhetoric, but it has really made me a better person. I suddenly feel easy-going and optimistic. I’m not sure what I will do next, but it will be fun!

A computer is…

• Processors – to move and transform information
• Memory – to store information to be moved or transformed
• Devices – to pass information in and out (Display, Keyboard, Network Cards, Storage Devices)

How does a computer store information?

• Memory is a huge line of “bits”
• Each bit is a tiny device that can hold a high or low electric charge.
• A bit can represent two possible numbers: zero (low charge) or one (high charge).
• Two bits can represent four possible numbers (00, 01, 10, 11), three bits have eight possible values, and so on… for N bits there are 2^N possible values.
• A number value can be represented using any “base”. Base-2, or binary is useful because each digit corresponds to a bit.
• Base-16, or hexadecimal, is also common because each digit corresponds to four bits (four bits has sixteen possible values).
• A computer may interpret numbers as characters (see ASCII), display color values, position coordinates, or anything…
• For signed numbers a bit is reserved for the sign value. For non-integer numbers, bits are divided into sign, base, and exponent (called “Floating-Point”).
• Modern computers work in groups of 32 or 64 bits, meaning that each variable has a range of 2^32 or 2^64 possible values.
• Each “byte” or 8-bit chunk of memory has a number identifier or “address”.

How does the processor process?

• A processor reads a list of instructions (or program) from memory and performs them in order.
• Most instructions can only operate on a specific kind of memory called the “registers”.
• There are typically sixteen-ish registers, where each is 32 or 64 bits.
• An instruction is represented as:
  • A number, or “op code”, that corresponds to an operation
  • A sequence of numbers which correspond to registers, memory addresses, or whatever – their meaning changes by operation.
• Instructions are often represented as “Assembly Language”. Some typical assembly might look like:

MOV AX, BX

Move – Copy the value stored in register BX to register AX.

ADD AX, BX

Add  – Add the value stored in register BX to the value stored in register AX, and store the result in register AX.

LOAD AX, DX

Load – Copy a value from memory into register AX, where the memory address is stored in registered DX.

JMP DX

Jump – Rather than continue executing instructions normally, execute the instructions starting at the memory address in register DX.

JE AX, BX, DX

Jump If Equal – If the values in registers AX and BX are equal, “Jump” (see above) to the memory address in register DX.

• Each processor is continuously running a program called the operating system (like Windows or Unix).
• The operating system loads other programs into memory (from hard drive) and instructs processors to “jump” between them.

How are programs written?

• Programmers rarely write raw instructions. Rather, they use a “high level” language (like C++ or Java)
• The text files that contain high level language are called “source code” or source.
• A program called a “compiler” (like gcc) translates source files into raw instructions (called “binary”).
• A program called an “environment” (like Visual Studio, Eclipse) is used to edit source files, feed them to the compiler, and report errors.
• An environment usually has a “debugger” which allows the programmer to pause the program at any time and inspect or change memory.
• A source file might contain this:

int max(int a, int b)
{
if(a > b)
return a;
else
return b;
}

• this defines a “function” named max, which might be “called” somewhere else with this line:

x = max(x, 10);

• Functions operate by using a “stack” – a sequence of memory reserved for storing values in a certain order.
• In the line above, x is a “variable” – a name for a chunk of memory where data is stored.
• Let’s say the “type” of x is “int”, so the compiler will read up to 32 bits and interpret them as an integer value.
• “x = something” means to determine the value of “something” and copy it to x.
• The function max is resolved by:
  • Copying inputs to the stack (in this case the value of x is the first, and 10 is the second)
  • …as well as the address of the current instruction
  • and then jumping to the first instruction of the sequence named “max”
• Here is what the instructions of max do:
  • If the value of the first input on the stack (named a) is less than that of the second (named b), then “return” the value of a, otherwise the value of b.
• When a function “returns” a value, that value is copied to the stack, and the processor jumps back to the instruction that called the function (also remembered on the stack).
• Back at the calling line, the “x = …” says to copy the output of max from the stack to the memory location named “x”.

What are pointers and references?

• Whereas most variables are names that correspond to a memory location where a value is stored…
• Pointers and references are names that correspond to a memory location that stores the address of _another_ memory location.
• So a pointer is a variable that stores the location of another variable, or “points” to it.
• Avoid pointers unless you need them (they can be tricky). You’ll find uses for them as you go.

What are structs? classes? objects? templates? inheritance?

• These are just ways of grouping variables and functions. You’ll figure ‘em out. Use google.

What tools do I need to learn?

• An environment with a debugger. Visual Studio and Eclipse are good.
• Source control. I recommend SVN, Perforce, or Mercurial.
• A good reference manual for whatever technologies you use.

How to make programs go fast?

• Not all memory is equal. Most instructions can only operate on registers (see above, How does the processor process?)
• Register memory is very fast, but very small. Values must be swapped in and out as needed from other memory.
• Cache memory is much bigger, but also slower. When it fills up, it must also be swapped out (google “cache miss”).
• Main memory is even bigger, and even slower. But it can also fill up, which leads to swapping with the…
• Hard drive storage is the biggest and slowest of all.
• A processor spends the majority of its time waiting for memory or storage devices to read or write data.
• The trick is to compact the most frequently needed data so it can be loaded into the fastest memory and swapped out as rarely as possible.
• Another trick is to divide up the work for multiple processors to perform in parallel without too much waiting on each other.
• Some processors have instructions for special purposes (like 3D graphics) which they can perform much faster than a sequence of general purpose instructions.
• Use a system timer, or a timing program to record how long each section of a program takes to execute, and target the slowest parts or “bottlenecks”.

How to make programs “clean”?

• Ask yourself, “Will a stranger understand what I’ve written?”
• Have a plan before you start! If you’re just experimenting, be ready to throw it away and start over. Experiments make for terrible code.
• Write comments that explain your intention, but don’t describe exactly what you’re doing (the code should do that).
• Make variable and function names as self explanatory as possible (longer names are okay).
• Break the work into small tasks and use separate functions, files, and other grouping systems to separate instructions and variables by their purpose (this is called “cohesion”)..
• Avoid having one “group” of code reference another unless there is a good reason (this is called “loose coupling”)
• Try to write less whenever possible, don’t duplicate. Re-use code. (this is called “modularity”)
• Be consistent. (this is called “code convention”)
• Clean up and rearrange code when it gets too messy (this is called “refactoring”)
• Have another programmer critique your code (this is called “peer review”).
• Test! Never assume something works. Use “breakpoints” (in your debugger) to be sure that every block of code is performed correctly.

How to fix bugs?

• This will be most of the job.
• If a bug halts the system, use your debugger to examine the current function and variables. Probably some data is wrong.
• If the bug is a glitch, some data must be wrong. Try to write code that detects the bad data and halts (google “code assertion”).
• The bad data must have been written from somewhere.
• If it is an input to the halted function, check the calling function (look for “callstack” in your debugger).
• Find the last line of code which may have changed the data which looks suspicious, place a breakpoint, and try to reproduce the error.
• Another method is to add a “data breakpoint” to the address of the data that is being corrupted. The breakpoint will pause the program for inspection whenever that data is modified.

Further Reading?

• C++ FAQ Lite (If you go with C++)
• Code Complete

For example, in Persona 4 enemies are either strong, weak, or neutral against elemental attacks. When you first confront a new type of enemy you have no information. As you try each elemental attack the enemy’s response to that attack is revealed and available to view at any time onward. The player begins with the task of trying each possible attack, and ends with the task of using the same attack every time.

Alternatively, in games like Poker, Scotland Yard, and Magic: The Gathering, the player can often combine several pieces of information to make an educated guess about the right answer. The choice is never clearly known or unknowable, but somewhere between. The game is an exercise in judgment, not rote procedure.

Positive feedback: The game becomes harder when you play worse, easier when you play better.

Negative feedback: The game becomes easier when you play worse, harder when you play better.

Examples:

• Mario Kart SNES has positive feedback: Gaining a lead separates you from the fray, reducing the threat of attacks, which makes it easier to increase your lead.
• Mario Kart Wii has negative feedback: Gaining the lead means contending with more attacks designed specifically to target the leader, while falling behind means better random items.

A goal in both cases is to create a suspenseful struggle, and to this end positive feedback wins. The reason for negative feedback is that the person falling behind or running ahead is no longer in the struggle. They need some help or harm to push them back in. But that push counteracts their accomplishment or lack thereof. Their actions become less important, and so the suspense is diminished. Too much chaos, not enough control.

IGN’s Matt Casamassina said it well:

…the manner in which you advance through the higher difficulty single-player courses — a good deal of skill, but just as much luck. You can be zipping through a 150cc stage without a single error and well ahead of every other competitor when, seemingly out of nowhere, bam! Blue shell. Lightning bolt. One cheesy last-ditch effort after another by unfair AI-controlled components. And suddenly you’ve gone from first place to eighth by no fault of your own. You don’t even have a defense against these items — that is, unless you consider praying that your cheap AI competitors don’t decide to rob you of a victory.

Big Illustration Party Time Podcast, episode 1

Today I found The Big Illustration Party Time Podcast, and I like hearing them talk about walking the line between art and business. It’s something game developers struggle with, too.

I considered making a career out of drawing. I stayed with game programming, but the goal is the same: make cool experiences. Programmers share this goal but have alien definitions of cool. Programmers want their gadgets to be thrilling, but an appliance should not require too much attention. If programmers made toasters they would have thirty buttons and complain about the quality of your bagels. At least games are supposed to impress, but the object of the programmer’s zeal is still sometimes misplaced.

Gabe from Penny-Arcade:

Indiana Jones – This was the year of procedurally generated content. Every other developer was telling me how instead of having artists and animators create a game for me they figured out a way to make a computer do it. They seem to think this is better but Indiana Jones is a great example of why it’s not. Instead of animating Indy they essentially taught him how to behave and react to his surroundings. They said this was better because it means you’ll never see the same canned animation over and over. What it means is that I see different stupid looking animations all the time though. I’m not sure that’s an improvement. I’ll take God of Wars beautifully animated special moves over Indy looking like some kind of retarded marionette any day.

So I don’t always feel like a programmer at heart. Though I’ve been sucked into technology hype, in the end I only care about tech insofar that it serves art. Tech hype is one distraction that illustrators don’t deal with–you wouldn’t care what brush was used to paint something. Another is scale. To a game developer it’s refreshing to hear creative people in mass media think about themselves as artists.

Players feel cheated when they learn a more difficult ability only to be defeated by an easier one. The easier ability is “cheap” because it cost less effort. They expect to be rewarded with greater advantage for greater effort. Therefor, an unbalanced game is one with abilities to master (let’s call them irrelevant) that give no advantage over some easier abilities. So, oppositely, we have a definition…

Balance: A game is balanced if it only contains relevant abilities.

Relevant Ability: An ability that offers some advantage over all easier abilities.

I suppose what this means for designers is that whenever you add or change an ability, check to make sure everything is still relevant. Though I can see how for some games, that might be difficult.

EDIT: Something about google maps widget broke. After hand-tweaking the link, I think I’ve fixed it.

View Rogers programming tour in a larger map

1. Interpreter / debugger: Flash MX Pro 2004. It’s pretty crappy. I’ll upgrade soon.

2. Editor: SE|PY ActionScript Editor. Someone recommended it in an article, and it’s free. It claims to have auto-complete, which works in some cases, but having become accustom to Visual Assist at Pandemic I’m unimpressed. Nonetheless, it’s better than working straight out of flash.

3. Source control client: SVNTortoise for windows. So far, it’s rad, and free.

4. Project management: Assembla. I found this today. Free private SVN hosting! And it’s multi-user, and it comes with a private wiki, and Trac for bug tracking, and a milestone calender, and a scrum board, and a chat room, and a clean web interface that ties it all together… I’m very pleased, though I’m hesitant to begin using stuff other than svn just in case the company tanks. Space is very limited (200mb). You can pay $12.50/month for 5 gigs. I doubt I’ll need it. I’ve read that some people in 2007 found bugs, but right now it would need to break the Internet to lose my favor.

Server will probably be Java, but I haven’t started.

I spent the remainder of those two weeks in Binghamton, which was also leisurely. I took a day trip to Malone, NY with my mom because she’s researching her French ancestors. The weather’s been nice and the leaves are colorful. I finally bought an xbox 360 and I played through Bioshock and Mercenaries 2. Both were shorter than I expected (I probably had 24 hours of playtime between both), although I avoided all the side-missions in Mercenaries 2. I finished some work, but for the most part I chatted with people, slept, cooked, and helped fix mundane computer issues.

So far only my week in Vegas has been very fruitful for programming, since I had plenty of time to myself. Within the other four weeks I probably only finished a day or two worth of work each week. As a result I need to reconsider my schedule. But I think my traveling days are over. I’m in Ocala Florida now with my friend Matt and I’m looking forward to getting back to work. Matt’s place is nice and there’s no one to bother me here. I’ll probably be here a month. Not sure where to next.