The one thing that’s always bothered me though is the App Store and conditions. A central directory of apps and central point of download is a good idea. A standardized update procedure is an even better idea, at once solving all the bullshit problems windows users have to put up with (how interested are you in updating Adobe Reader or Java all the time, really?)

The one thing I don’t agree with is the approval process. And Apple just went from tolerably bad to intolerably worse on that one. I think it’s a bad decision to restrict what you may run on the phone and how, but it’s still a decision I can respect — their rules on how you execute stuff within the context of their operating system.

However, the new terms of service for iPhone OS 4 says this:

Applications must be originally written in Objective-C, C, C++, or JavaScript as executed by the iPhone OS WebKit engine, and only code written in C, C++, and Objective-C may compile and directly link against the Documented APIs

Here’s where Apple has clearly and definitely stepped over the line. Not only must the resulting application conform to certain demands, now my development process must conform to certain demands?

Code generation is an incredibly useful technique, and they’re banning it simply to stop the Flash compiler and make a grand statement? Either way, how in the world are they planning to enforce this? Will this lead to an arms race between Apple trying to detect application code that has been compiled to C, C++ or Objective-C and a company like Adobe making a compiler that compiles Flash to those languages in a way that looks as close to human-written as possible? Unless I have to submit a full-length video of myself coding the entire thing, there is just no way to tell with a reasonable accuracy.

How much collateral damage is acceptable, Apple? How many other companies and customers will suffer over your crusade against Flash? How many developers will hate your guts before this is over? There are just so many pins the developer voodoo doll will take.

The iPhone app craze will eventually die as more people realize the gold rush is over. And at that point, Apple can keep its Objective-C Nazi corner, while the rest of us go back to using the best tools for the task at hand.

I would be much happier if everyone could start creating flash-free websites. Anyway, today’s ordeal made me think back to the fine old days when everything was a table. HTML wasn’t made to display layout. The nice things about HTML, hyperlinks, worked just fine in regular text documents with some simple formatting, like bold and italic, its creator figured.

The nice things turned out to be really nice though, sparking an incredible development where pages got increasingly sophisticated layouts. The original HTML text format included tables, a fact which was quickly used to hack together all kinds of pages. A table could be used as a grid to stuff things into certain places, and a table inside a table could be used to create more interesting layouts, not to mention a table inside a table inside a table.

Because tables were meant to be (you know…) tables, different browsers rendered them slightly differently. Fine, if all you want is a table of text. Not so fine, if what you wanted was a pixel-perfect design. The solution to this was to add a whole slew of properties to each table, row and cell.

So after hacking together a sophisticated web site layout using table, the result was predictably a complete mess. The tables holding the text in place was mixed in with the text itself, making sites a nightmare to update or maintain, to not even mention changing the design.

A solution was clearly needed, to separate the design from the contents of web pages. So, why not adopt a language that wasn’t meant as a design language either? Sure thing, Cascading Style Sheets (CSS), a language meant for styling rather than layout was adopted during a long and slow process full of bugs, browser incompatibilities and new hacks.

Today’s standard of “good” for the web means using HTML strict (which few do) and control the appearance using CSS. The result is slightly less convoluted than the tables approach, but takes about 20 times as much effort to understand or write correctly, involves just as much hacking and is so fraught with peril that most people simply avoid it, going back to tables or mixing in horribly ugly JavaScript. Or, as seems to be extremely popular with games companies, insist on making the entire website in Flash, even though there’s absolutely no need for it.

So the page we were looking at today needed 3 columns of the same height. Let’s do it the old way with tables, for nostalgia’s sake:

<table>
  <tr>
    <td>Column 1</td>
    <td>Column 2</td>
    <td>Column 3</td>
  </tr>
</table>

Okay. Not too bad. So how to do this with CSS? Generally, you’ll need 3 DIVs next to each other, all with float: left. This makes them each have an individual length though. There are several ways to get around this, but none of them are good. The first involves stretching images across the DIVs as background images, which means you’re now bound to the color of those images instead of a color value. Also, you can’t have borders.

The second way we tried involved a very complicated set of maneuvers using three extra panes and shuffling content out the left side of the screen and then back in. The description for how to do this was about 10 pages long. And oh, it turned out to not work with borders either. Sigh.

So finally we found one way that seemed to work with borders. Only it didn’t, since you didn’t get any bottom border that way. The good part is that you could hack around that by using an image.

So for the old horrible table version, you substitute a mess of nestled DIVs and several pages of CSS, and it doesn’t even work fully without adding a picture where you essentially paint the entire bottom of the border along the page (yes, you actually paint a snapshot of your entire webpage, 1 pixel high). Way to go.

<style type="text/css">
      #container { float: left; background: url(images/example-6.gif)
          bottom center no-repeat; padding-bottom: 1px; }
      #inner { float: left; overflow: hidden; }
      #inner div { float: left; background: #ccc; border: 1px solid #000;
          width: 200px; margin-right: 5px; margin-bottom: -1000px;
          padding-bottom: 1000px; }
      #inner .col2 { background: #eee; }
      #inner .col3 { margin-right: 0; }
      .clear { clear: both; padding-top: 10px; }
</style>
...
<div id="container">
  <div id="inner">
    <div>Column 1</div>
    <div class="col2">Column 2</div>
    <div class="col3">Column 3</div>
  </div>
</div>
<p class="clear">

That seems like a great way to code! Not to mention that part of your design is now locked up in the image.

The best part about all of this is that it’s presented as “without CSS hacks”. Well, if having to use 6 nestled divs, large-number positive and negative margins and all kinds of bullshit like that isn’t an ugly hack, then I don’t know what is. The fact that the art of web design has advanced to the point where the normal thing you have to do is one big hack isn’t encuraging. And then they add the hacks on top of that…

I never liked tables, but at least they worked. In one of those memorable IRC quotes (in Swedish), someone said:

<sycon> imagine 1000 ants, tables are like the cage that keeps them in place, in the right place
<sycon> css is like a child with spasms trying to poke them all into place with chopsticks.

After spending countless hours trying to do seemingly simple things, I think I agree. Something’s still broken with the web, and no one seems to care to fix it. Well, other than inventing more workarounds.

But hey, at least you can draw Homer Simpson with it. So, ok, let the flak begin. Look, a Parrot.

Funnily, the exact same bug has apparently been a problem on wordpress before, on version 2.5, in a different file.

Anyway, I fixed the problem. If anyone wants the fixed file, here it is:

Download file.zip

Download the archive, unzip the file.php inside and replace the one in your wp-admin/includes folder with it.

Now we suck at verifying user input from web forms. The current state of code that verifies user input has both managed to take us back to the kindness of the command line when it comes to freedom of input and manages to check all the wrong kinds of things. Why is it so hard to write these checks? I suspect because people don’t really think much about them, and I bet there are more interesting things out there than to write user input verification.

These problems aren’t some beginner coder errors either — they’re rampant on even the biggest sites out there like paypal.

The most common field to get me snared is the phone number field. In 99% of all cases, the site assumes that all phone numbers in the entire world are formatted like US phone numbers. Not, as one could imagine, because I’m claiming to live in America — I clearly just told the site that I live in a European country. So anyway, inputting my actual phone number causes an “invalid phone number” error. Not that there is any mention whatsoever on the site about what the correct format of a phone number is (there are, in fact, even several ways of writing a US phone number).

This sets off a wildly unamusing guessing game of how to “convert” my phone number into a format the site will accept. This practice often costs the sites money as I end up giving up and going somewhere else, frustrated and unable to make a simple online purchase that didn’t really require that phone number anyway, did it?

Passwords

Another highly amusing game is the one where web sites try to force users to choose “secure” passwords by enforcing the formats of passwords. “You must have at least 6 characters, with at least one letter and one number”. Sounds good, except in general these passwords are restricted to only contain letters and numbers. Hold on, isn’t it common wisdom to include at least one non-alphanumeric character in a secure password?

As such, out of my set of passwords, the only password which tends to pass most password verifications is my least secure one. The idea that you could fix a social problem through technology is somewhat funny anyway — “password1″ is not more secure than “password” in any way that really matters.

The same thing applies to the old trick of forcing your users to change passwords every month. This can have two potential outcomes — users append a counter to the end of their password, and increment it every time they are forced to switch, or they keep a post-it note taped to their monitor with their current password. Neither outcome is a net gain in terms of security.

Some sites even let the user set a password which is then considered invalid when the user tries to log in (ebay, for instance,  has done this) — causing a prompt for a new password and much annoyance.

Format wars

Parsing stuff is what computers are good at. So forcing me to input something in a strict format is always a loss. Either separate the fields and force me to select the individual parts of a date separately or actually use all that computing power at your disposal to do your user a favor. Telling me you have no idea what I mean by “2009-12-21″ because you expected “20091221″ is annoying the user for no good reason, even if you told me to not include dashes.

If you find yourself in a situation where you need to verify input  from the web, take an extra minute to consider how you could make things as convenient as possible for the user, which ones of your assumptions only hold true for the region you live in… and when you’re done, whatever you do make sure you tell the user exactly what the expected format is.

Essentially, the system is meant to test the students’ solutions to homework problems. This is done by providing a solid definition of what the input and output of the application are supposed to be on the standard in/out channels, and setting up a whole bunch of test cases, including a memory limit and a CPU time limit. Students submit their source code to the system, which compiles it and runs all the test cases against the application in a black box test. So far, so good.

Seeing these guys at work, compared to me and my colleagues at work, makes a few things very apparent: even with a fairly solid grasp of algorithms and datastructure, their number one problem is code. Where professional programmers swim through code like sharks in the sea, the students appear to be more or less drowning. Theoretical learning aside, the education lacks practical programming, debugging, practical programming and some more practical programming.

It would seem that these programming exercises would be the perfect opportunity to get that kind of experience, if it wasn’t for the fact that the test system is itself a black box. You put in your code, and it tells you yes or no. It’s not quite a boolean pass/fail answer, but close enough: you will get told a result from the set: Didn’t compile, Passed, Failed, Crashed, Time Limit Exceeded. When I first heard of the system, it was motivated with the fact that sometimes in professional programming, that’s all you get.

I agree. Sometimes, you get gnarly bugs that give you less information than a world pro’s poker face. I’ve spent weeks tracking bugs like that sometimes, using all kinds of tools at my disposal to try to wring more  information out of the error, until finally the knot was untied. But — for all the bugs like that I’ve been through, none of them were eventually solved by guessing what was wrong and how to fix it.

Supposedly, the tool is meant to teach the students to debug their code… which it somehow does by disallowing all normal debugging tools. You can’t run a debugger on it, you can’t print traces, you’re not allowed to log to a file or socket, you’re not even allowed to know what input caused the error. The only tools you have at your disposal are your wit in coming up with your own test cases and code reviews.

Any attempts at normal debugging would be classified as cheating. If I was faced with a bug under those circumstances, I would do whatever I could to get more information out of it. Hey, I can crash it with different signals — that’s a few bits of information I could get back from it. All those kinds of tricks of the trade that real programmers use to, you know, solve problems… would be cheating.

This leads to a skewing of results… very simple bugs turn into monster problems, since you can’t identify and fix them. What they are learning is not how to debug their programs but how to painstakingly solve the very specific problem of pleasing the system. By artificially making easy things hard, the system has effectively found a way to avoid teaching the students essential skills in programming: simple debugging tools like tracing and breaking into a debugger. Instead, they learn programming by coincidence: poke something until you (hopefully, eventually) get a green light.

That’s not a lesson to learn.

The only way to go about this, faced by the obstacle made up of this system, is to learn a different skill: testing. More on that later.

More on studies: An Exceptionally Stupid Idea, Go Tinker, What’s a Good Final Year Project?

Still, there are some issues with free software that don’t really show up to the same degree with commercial software. One such thing is documentation. It’s painfully obvious that documentation is written by people who:

1. Already know the software in and out.
2. Don’t like writing documentation.
3. Know nothing about how people learn.

For instance, when I started a side project a few months back, I was looking for a build system. After settling on CMake, I set about trying to make sense of it. There’s the ever-present getting started example, of course. And then there’s the full reference of everything you could possibly want (almost).

But in between those, there’s nothing. Well, nothing except a book, which just goes to show you that there’s something missing — a professional writer could obviously make some money out of explaining things in a reasonable way.

The problem with this is that it doesn’t match how people learn. Getting started is a good step, but a relatively small one. Most of the time will be spent incrementally expanding the knowledge, moving from beginner to expert. Most time will thus be spend in some kind of zone in between the “getting started” and “reference of everything” levels.

Worse than that, some open source programmers have a tendency to view their full reference documentation as an appropriate resource for everyone. “It’s all in there,” right? But pointing a beginner at a 40-page document detailing all the options of some application when all they want is to run it properly isn’t very helpful. I’m sure you know what I’m talking about if you’ve ever used an open source command line tool.

That ends us up with the really dark side of free software culture. The true douchebags out there will not only be extremely smartass in their RTFM comments, they’ll also be incredibly sensitive and defensive about the software they’re working on.

I ran into a problem with cygwin’s SSHD implementation last week. In searching for the solution, I found this mail list answer:

  Wrong.  That is uninformed speculation and guesswork.  Stop
spreading misinformation.

  Cygwin SSHD has had the support for fully logging in as any
user since 1.7, as you have already been told and completely
ignored.  Go and read the manual.  The link was in the previous
email I sent in this thread.

  freesshd works exactly as Cygwin *used* to before it got
subauth support: when you log in with a key, rather than a
password, you just end up as an admin user.

Wow. This kind of answer is wrong on so many levels. First of all, while he makes it seem like the functionality has been there forever, cygwin 1.7 is still not even out of beta. The chance that an end user has it is about 0. So, with the current version (1.5),  supposedly cygwin sshd works just like freesshd. This is clearly false, because the original poster reports one working and the other not (which is, by the way, exactly the same results that I had).

So, a user reporting a problem about logging in gets pointed to a long documentation about security settings in a beta version, doesn’t understand a word from that document (no surprise there), and as a result gets told to “stop spreading misinformation”. Truth is, simply installed like any normal user installs applications, one works and the other doesn’t, something made quite clear by an answer from the original poster in a different place in the thread:

> Are you talking about password or public key authentication?
> If the latter, Have you tried the LSA authentication package
> in Cygwin 1.7?

I don't know. I'll try to deciper that. Sounds complicated. In
the meantime, friend is using freesshd.

The essence of what he’s saying (which has been completely missed by the cygwin developers) is that the effort required to get cygwin to work like one would reasonably expect of it is much higher than the effort required to just google for something that just works out of the box. The fact that you could potentially make it work is irrelevant, because he’s not getting any help actually making it work.

He might as well just have said, “I don’t care about making it work for you. It works for me.”

Software companies usually compensate for their complete lack of useful technical support with a good (or at least reasonably decent) amount of help documentation. Free software usually has neither.

I encourage any programmer to practice their technical skills on an open source project. But while you do so, take the opportunity to practice your people skills a bit as well, or why not your writing skills? Don’t be an open source douchebag — someone reporting your software’s flaws is not attacking you personally.

The degree I’m doing currently has been very much centered around graphical programming, aswell as using various programming languages to bolster our CV’s I would imagine. We’ve not really touched on networking, or AI at all. Our main language in graphical programming has been OpenGL too, we’ve dabbled with DirectX a little, mostly managed directX with XNA.

As a programmer already in the industry, could you give me any advice on the type, and level of project I should aim for, for it to be a suitable demo project to show to prospective employers? It’s difficult enough as students to find our way into the games industry; if we don’t know what employers want, or what is considered worthy in the eyes of the employer, it lowers our odds tenfold.

In a way, the answer to the question depends on what kind of position you’re trying for. I’ll try to answer with regards to as many positions as I know.

For starters, is graphics programming what you want to be doing? If it is, things like what graphics APIs you know become a lot more important. From what I know, most games studios that do windows game development have gravitated towards DirectX. With that in mind, having done a large(ish) project on DirectX could definitely be a plus. If all other things are equal, I’d definitely go for learning DirectX.

Not having experience with networking or AI isn’t all that much of an issue, unless you imagine going specifically for a networking or AI programming position (and even then, it’s more of a bonus than a requirement). One thing is clear however… if you’re looking to get into professional development at a large studio, you should be going for C++.

Now if we look past the technical requirements, there are a few things that can be said about such a project in itself. What you get from a good project is a nice entry into your demo reel — something to show off. This has a few implications, but most importantly something I’ve touched on before, in A Spectacular Failure: your project is going to be judged on emotional first impressions, not how technologically advanced it is or how nicely coded it is.

Your number one enemy is over-scoping the project, ending up with something that does lots of things, but does none of them in a great way. Come up with a good core gameplay for the game, and then polish it to a great shine. Fix all those annoying glitches and bugs, make sure everything looks as impressive as possible. It doesn’t need to be rocket science, as long as it’s well executed. In the end, what a games studio is looking for is a programmer who knows how to finish projects in a good way.

That doesn’t mean your project should be Space Invaders, but in general trying for something too big is more of a problem than overdoing something too small.

Finally, as an entry on your demo reel, make sure you make the game available in an easy manner. Have a page with plenty of screen shots, videos and preferably the game itself easily downloadable. Your coding ability will definitely be tested with some form of work sample as you apply to studios, so the code itself being available is less important. Reading code is hard, so it’s unlikely that someone will have time to read yours. However, having a finished game to show off is worth a lot, as is the experience of going through all the phases in finishing a game.

Other posts you may find interesting, relating to getting into the games industry and getting started with games:

• Getting Into Games
• An Exceptionally Stupid Idea
• Let’s Make a Game Engine

Working at a Games Studio

Getting started with something I intentionally left out:

Low pay. Good luck trying to buy a house.

There’s a well known discrepancy between salary in your average programming gig and your average games programming gig. I left it out of the original post because of two factors:

1. The difference is highly overstated. Salary varies much more within each class of work than between the two. While it is true I could probably get more money by switching to another job, the same is true for many others, and the difference wouldn’t be worth it to me.
2. It’s your choice. I expect you to make a well-informed choice on taking any job when it comes to what you get paid. Don’t just take any job because someone told you you get paid a lot in a certain business — make sure you get what you’re worth.

A second issue from the same commenter (and several others):

Yes, you have to come to work on Saturday and Sunday.

This is an issue in the industry, and I’ve seen pretty bad cases of it. Since I started coding games, the working conditions have improved by far though — and this doesn’t only seem to be my situation but applies to many others I’ve spoken to at other studios (mainly within EA though — would be happy to hear the perspective of other people). At the moment, from where I’m sitting, things are looking pretty good.

I’m not saying crunches don’t happen, I’m just saying they’re reasonably few, have a good purpose and focused time span, and include a time off compensation after the deadline has been passed.

The most problematic part of this is that it’s extremely hard to figure out if this applies to any given studio without actually working there or knowing someone who does.

I wouldn’t want to be the guy working on the next Madden game

Well, I actually know the guy working on the next Madden game and he is incredibly dedicated and seemed to love what he was working with last time I saw him. About the comment, he told me “Well we don’t want that guy anyway,” which is very true — the reason there is a Madden game every year is because there are lots of people interested in a new Madden game every year, and among that crowd there will certainly be people who are interested enough to want to work on the game.

It’s funny, because I sometimes hear the exact opposite of this comment at work. “It’d be so awesome to work on an iterative title where you just got to improve things and do all those cool changes that we have to cut”. Working on Madden is a pretty sweet place to be if you love sports games.

People sometimes seem to think that innovation only means new game franchise. There are lots of interesting developments and innovations within franchises, even within a “plain old sequel”, and working on one of those titles avoids one of the great drawbacks of the games industry: half the time you’re semi-panicking because your game engine isn’t in a shippable state and there’s a whole game team trying to use it to create a game.

That way, working on Battlefield: Bad Company 2 is nicer than working with the first game: the same chance for innovation, but less problems with others not being able to innovate due to the state of the code.

Getting started

A question that keeps popping up is any version on this:

I’m a frustrated web developer who’s always wanted to make the move into game development, but have yet to find the time to train myself and start shifting my skills over.

Any tips for someone looking to start out in that direction?

I’ve touched on this subject before, in An Exceptionally Stupid Idea, which tells the story of what I did. That post may be best applicable if you’re still in college, but there is a certain truth to it regardless of where you are. Time is money however, and with anything in life  you’ll need to do investments… so seeing where you could free up time is a first step.

What do do with the time once you have it? Well, the games industry is looking for a few things:

• Skilled programmers
• … who know the language
• … and with some experience of games

The third is actually somewhat optional, though most recruiters would never admit that. Becoming a good programmer is a hard topic to cover — more than half the stuff on this blog is already devoted to that, so I’m not going to comment further on that one.

Chances are slim you’ll be coding anything but C++ if you code games, so if you’re not already very familiar with the language, you should get familiar with it. It’s often said that good programmers learn new languages quickly, and to a certain extent I agree with this… but if the problem is complicated enough, you need to be a language expert.

Finally, getting some form of portfolio is good, even if it’s “just a side project”. That could also be a good project to use as practice if you’re not too familiar with the language. Further, it helps if you’re a gamer and stay on top of what’s going on in the industry.

This actually ties into another comment, which was the most compact piece of information:

C++

If you dislike C++, turn elsewhere. I personally think it’s an extremely capable language once you learn to harness it properly. It is dangerous without the safety equipment though, and sadly some of that equipment doesn’t work with games.

Other languages are starting to appear when it comes to games coding. I’ve heard examples of LUA, java and C# being used as scripting languages, and of course there’s UnrealScript. These can be extremely beneficial for iteration times and such, but the grunt of the software is still going to be C++.

Update: I should also mention another old post of mine about this: Let’s Make a Game Engine!

Games Programming

I tried to avoid getting into the details of hardware and the coding that goes with it in the previous post, since I love talking about these sort of things and I didn’t want it to become a rant but hey, you asked!

Console hardware (I’m looking at you, PS3) is made for pretty graphics demos, not simulation. If you work on the AI or physics, be prepared to focus your energy on low level optimisation and cache misses, because your AI code is never going to be any more sophisticated than a state machine.

Well… I’m the lead AI coder on Frostbite, and while there are lots of things to be said about the Frostbite AI, “no more sophisticated than a state machine” is not one of them. I agree, some things (especially physics queries) are expensive on the hardware, but that simply means you need to re-think how you do stuff.

SPU code is a vastly different beast from your average code. There are some bad programming habits that can completely destroy your code for SPUs… and among those bad habits are the ones that would lead you to get stuck on low-level optimizations. Once you learn how it works, there is an incredible amount of power in the PS3. I’d dare to say it’s still relatively untapped, and that as time passes we’ll see more sophisticated uses of it.

The limitations of console hardware is different. That doesn’t mean you can’t implement physics or AI, it just means maybe you’ve got to challenge your assumptions about how you implement physics and AI.

I guess the Parallelism approaches are a little different in both worlds. I bet you gamedev guys have been working with Data Parallelism for a while (i.e: programming the Playstation2 Vector units. I don’t think life is getting any easier on you guys with all those Cell SPEs to squeeze!).

In the enterprisey side, task parallelism is an emerging topic with languages like Erlang, Clojure and Haskell offering different abstractions for spreading computations over different hardware threads/cores.

The vectorization units of the PS2 are a quite limited way to do data-parallel work, so I disagree with you here — with the SPUs on the PS3, it actually is easier, because it’s less limited in what you can do with them. Vectorization units and other primitive forms of data-parallelism often work in lockstep, whereas the PS3 actually has a bunch of individual, highly capable although slightly quirky processors.

Games are full of data-parallelisable problems as well. Rendering is the classic example — the reason GPUs have been such a hot development the last few years is that rendering lends itself so well to parallelism. But there are many other things as well — the aforementioned AI is ideal in some ways, as it tends to be made up of lots of separate processes for different actors or entities.

Task parallelism is also something that can be utilized to a great degree in games since there are simply so many orthogonal tasks to complete. Update the UI, do physics simulations, calculate character skinning, play audio… I can’t go into details on that, but we do a whole lot of it in Frostbite. Sadly, you do end up needing to care about many of the details that using an abstracted language would let you ignore though.

Still, it’s one of the most exciting aspects of coding for me, since games are one of those applications that can actually use all the power of parallel computers.

With this post, I will try to list what I see as the biggest differences between working on a game and working on a different kind of software project. If you have any questions related to it, please post them as comments and I’ll do a follow-up round.

The Passion and Dedication

It sounds like a cliché, but games are made by mostly gamers. In all the teams I’ve worked with spanning maybe a hundred, there’s only a few people that aren’t absolutely passionate about games, and completely dedicated to making kick-ass entertainment.

The enterprise coders I’ve worked with pretty much fall into two categories: the day job coders who don’t care much and the hackers that appreciate technical challenges. As you move into games, not only does just about everyone fall into the second category, but nearly everyone is also excited about the games themselves, regardless of the technical challenges involved.

If you’re looking for a place to work where your colleagues will be really cool, skilled people with a passion, then the games industry is where to look.

On a cynical note related to that, the abuse of this passion and dedication is what has given the games industry something of a bad reputation (and a well deserved one too). My impression is that working conditions have improved quite a lot across the board, even if there are still the occasional horror stories. If I were to give one piece of actual advice, it’d be to be rather thorough in your background checks on companies.

Creativity

Game developers live off creativity. Even the most simple churn-out-sequels factory will attract highly creative people, and studios will tend to cater to creativity to a much higher degree than most other software development companies.

If you’re highly creative, you will probably find it easy to fit in. My experience is that creative suggestions are almost universally appreciated regardless of source.

Cross-discipline, Bleeding Edge Development

Games teams are made up of a number of disciplines that vary depending on what type of game you’re making, but generally speaking you’ll at least have Designers, Graphical Artists, Animators, Sound Designers and Programmers. Our projects have Mission Designers, Environment Artists, Effects Designers and other disciplines as well.

In a way, this is no different than many other types projects where some end-users create some of the data for the system, but there is a major difference in the fact that the hardware platforms are either consoles or PCs with specs so high that they don’t even exist yet. The coders on the team will be creating a game framework, which is then populated with different kinds of content to produce the game.

The problem with this is that they’re using the software tools you’re building (like the editor and data processing pipeline) to create the game while you’re still trying to build the tools, only to run it in a game engine that is also not done yet.

It’s a bit like trying to produce a business application while part of your team is working on creating the source code editor you must use, and a different part of the team is building your compiler. In some magical way, the components must all mesh together so that not only are the tools done when it’s time to ship the product, but that content creators have time to do something useful with them as well.

This creates an extra layer of complexity to the projects that I haven’t seen anywhere else. Inter-discipline dependencies between disciplines that work in very different manners can cause common project management techniques for software development to break down, because most of the team isn’t developing software.

Performance Focus and Hardware Platforms

From a technical point of view, there is a heavy focus on code performance. This creates a different kind of environment, where some modern programming techniques are simply too expensive to use. It also means you tend to get good at optimizations after a while.

The hardware we run on is increasingly becoming paralell. Using all of the power in the PS3, for instance, requires a fairly well developed parallelism, forcing the shift from single-threaded to multi-threaded coding onto game programming long before most applications need to care all that much.

(Note that my view on the state of the industry is rather limited here. DICE is ahead with the Frostbite engine on current console tech, some other engines are hopelessly behind, but it’s always hard to tell what others have in development.)

The hardware platforms themselves can sometimes be immature and cause problems when you have to jump through hoops to get things working (simple example: graphics driver bugs).

The platforms themselves also impose other restrictions on your code, like the low memory cap of current generation consoles and extreme penalties for cache misses and branching.

Playing Games at Work (!)

I couldn’t leave that out, could I? Yes, we playtest our games at work. They’re a lot of fun, most of the time, so getting to play awesome games before anyone else is quite a perk. To be completely honest I must admit that there are times when it’s not much fun at all… but they are quite uncommon. And hey… you get to shoot your boss.

• E3 has come and gone. I could link to a million things from there, but I’ll restrict myself to one: The Star Wars — The Old Republic trailer. That is one serious piece of awesome right there.
• No, one more E3 mention actually: You will burn in hell for pretending to burn in hell.
• In other game news, the new Red Faction seems to be a good game.
• On the subject of MMOs, Jeff Vogel posted an interesting article about addiction-based game design and Eric at Eldergame posted an in-depth article on the health of the MMO industry.
• Sad news: Fantasy author David Eddings is dead.
• Here’s a concept display of a new kind of interface, used entirely without clicking. I’m not sure if that’s the way of the future, but it’s interesting.
• Алёна C++ made this awesome map of C++. Goes pretty nicely with xkcd’s map of the online communities from a while back.
• Speaks for itself: some beautiful world records.
• And the asshole of the week (frightening how easy it is to find these): the guy who thinks he owns the word “edge”, and likes lawsuits about it — Tim Langdell.