[Note: I wrote this a long time ago and it may not be as applicable now that there are gamedev programs at universities. You can tell it’s dated by the references to Windows XP and Playstation 2…]
So, you want to get into game programming, and want to know which universities offer game programing courses?
My advice: go into Computer Science[1]. Universities don’t need to offer degrees in game programming any more than they need to offer degrees in writing spreadsheets or writing word processors. Games are a type of program. Learn to program well, and you can program games.
Be careful when you learn things that will be obsolete in five years (DirectX 9, Windows XP, Playstation 2); try to focus on the main ideas instead of the specifics. You don’t want to spend your efforts learning something that will be obsolete by the time you get out of school.
I found most of the courses I took in Computer Science to have some relevance to games:
- Introduction to Programming
- Learning to program is easy. Learning to program well is not[2]. A good introductory course should teach you how to approach and solve programming problems. Given a problem, you first have to find the computer science equivalent. (This is also true in math, where you first turn “word problems” into symbolic equations.) You then solve the problem in the computer science domain, and translate it back into the real-world solution. You need to know what your tools are -- things like scripting, various programming languages, debuggers, libraries, editors, data structures, algorithms, and so on.
- Programming Languages
- You’ll most likely want to learn C++. However, many top universities don’t teach C++ at first. They teach “weird” languages like Scheme or Haskell. Why is this? It’s because these weird languages are easier to learn, and they teach you to really think about the problem instead of the program. When you can think about problems instead of programs, you can pick up new programming languages easily, and the details of the language don’t matter so much. When you learn many different languages, you’ll learn about different ways of approaching the same problem, so that you’ll be able to pick the best one when you have to solve real problems. A more direct application is that these high level languages often have constructs that are very useful in game scripting languages.
- Data Structures & Algorithms
- Data structures and algorithms are key to solving many problems. You’ll want to learn about arrays, linked lists, binary trees, general trees, balanced trees, hash tables, heaps, and so on. You’ll also want to learn algorithms that operate on these data structures, like partition, depth-first traversal, tree rotation, merge sequence, and find-median. Using these basic algorithms, you can define more useful ones, such as quicksort, mergesort, subsequence search, and binary search. You’ll want to know how to decide which data structure and algorithm is best for your problem. In addition, you’ll learn how to combine data structures and algorithms to build task-specific objects, like stacks, queues, priority queues, sets, bags, and maps. Just about all of these are useful when writing games.
- Compilers
- Understanding compiler techniques will let you understand how code is compiled into assembly. This is really helpful when writing fast code. In addition, compiler techniques like tokenizing, parsing, and code generation are useful if you’re going to write a scripting language. Techniques like garbage collection aren’t only useful for memory management; you can use them to save game data. You can also compile sprites, textures, 3d commands, shader commands, and all sorts of other data that doesn’t look like a programming language.
- Operating Systems
- A good OS course really gives you insight into how the software side interacts with the hardware side. Like a compilers course, an OS course can give you good knowledge about how to write fast code. You’ll learn about file system organization (and you often want to write your own to access data off of CD-ROM, or to provide persistent object data), the use of threads (from low level issues like locking to high level issues like when threads are useful), and network communication (multi-player games!).
- Graphics
- A good graphics course will give you theory of graphics instead of just programming libraries. In this day of 3D hardware, you might wonder why you care about learning graphics theory. When you understand the theory, you’ll understand why certain things work better than others. Also, some algorithms (like BSP, oct-trees, object collision, camera angles) are going to be written by you, not by the graphics library.
- Computer Architecture
- Like an OS course, a computer architecture course will give you insight into how the hardware works and how to optimize your code to take advantage of it. In particular, you’ll want to learn about disk vs. memory vs. cache vs. registers, about latency vs. bandwidth, and about CPU pipelining.
- Artificial Intelligence
- Despite the growing popularity of multi-player games, artificial intelligence is becoming more and more an important aspect of games. A good AI course will introduce you to a large set of techniques (heuristic search, planning, genetic algorithms, neural networks, bayesian networks, natural language parsing) so that when you design an AI for your game, you’ll know your options and what the tradeoffs are.
- Databases
- Especially in multi-player games, it’s helpful to know how to store shared data, search it quickly, and deal with concurrency issues. A good database course should teach you all of these.
I’ve found that I can be a better game programmer by being a better programmer, and I can be a better programmer by understanding a little bit about each aspect of computer science. As you learning something new, think about how it could be used in a game, and write a game that explores that part of computer science.
If I recommend not learning specific technologies, how are you ever going to be able to use them? I recommend not taking classes for them. Instead, learn them on the side. Use the university classes to learn things that will be true for a long time; work on side projects on your own time to learn things that will change. I was always working on a game on the side while in high school and college, and I learned a lot by doing that. Not only did I get to apply the things I learned in class, I also got to learn things that would never get taught in a class.
Don’t limit yourself to computer science. Learn math (vector algebra in particular is useful for 3D games, calculus lets you handle continuous motion more efficiently, and other kinds of math are useful too[3]), writing/communication (good communication is essential when you need to convey information to the user), drama (storytelling is common in games), economics (especially for strategy games), physics (object motion and collision is straight from physics), and whatever else seems interesting. College is a good time to be exposed to a wide range of ideas.You never know which ones will be useful to you in the future.
Read this article[4] and this article[5] too.