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.

This is a silly excuse to feel self-important. Democracy does not hinge on the average person solving world problems. We can’t. It works because the average person can, with great accuracy, say whether they (not anyone else) are better or worse off than they were two or four years ago, and vote accordingly. That’s the feedback that drives politicians to maximize our well-being. And they do that by finding real experts to solve our problems. Our wacky opinions are just noise in the system.

So personally, I don’t vote because life is peachy.

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.

Tool:

One who lacks the mental capacity to know he is being used.

Ayn Rand is a popular topic today. She illustrates her thesis in a way that strikes a chord with many people. But you will need to stomach loads of pessimism. Satire without comedy is depressing.

Like this post doesn’t mention any examples. See? Lazy.

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.

That works in a big pond. Throw fools overboard, and you can forget about them. Your life is easier, theirs is harder, justice is served. But in a small pond, you will still see those guys around. The more you throw over, the less pleasant your boat ride. The taxpayer spends more on the people thrown to the streets than if they had stayed in public housing. They will get sicker, and we will pay more for them in our emergency rooms. They will turn to crime, and we will pay for them to be policed, arrested, and jailed. They will hang around our shopping areas, smelling like pee. The world isn’t big enough anymore to say “you are not my problem”.

In the 50’s Desi Arnaz pitched I Love Lucy to CBS, but they said he was too Latin to co-star as Ricky Ricardo. He took the show on tour, made people laugh, and CBS agreed to make the show. In his memoirs Arnaz wrote,

“I know of no other country in the world”, in which “a sixteen-year-old kid, broke and unable to speak the language” could reach the success he had.

Uplifting! In retrospect, our sense of taste and decency is often just silly fear. I think it’s good that we avoid governing it.

So taste it, UK!

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.