next »

[Guard]

What is the longest time you've spent on a game fixing a bug?

I just made mine (which inspired this). My record is 5 hours of trial and error and then I finally got the right algorithm and made it work. It was a drop and pick up items from floor bug where clients would tell which item to delete.

So, what's yours?

[valkrin]

Days?

Multi-threaded, multi-process, real-time system with more than 500,000 lines of code. All sorts of bad stuff can happen.

[drChengele]

I guess 6 months or so.

An engine which was supposed to automatically generate textures from separate color and alpha channels by somewhat advanced texture-locking bitwork. It just didn't work.

I got around without it until I realized it was uncaching my textures due to an old, unused "uncache on idle" flag which was left uninitialized in the first stage of the blending process and thus triggered before the second one.

As for critical bugs, in my earlier days there have been a few instances of hunting a rogue pointer for what seemed like hours, yes.

[paste]

I spent about a week (about 20 hours altogether) trying to connect to a remote mysql database, even with code designed specifically to do that.  The exceptions were just so vague. "Unable to connect"... hurray!  So happy when I finally got it working though.  The worst thing is that even though I posted on message boards for help on the issue, I was so burnt out on the problem by the time I got it working that I have no idea exactly what I did that made it work right.  Oh well!

[ஒழுக்கின்மை (Paul Eres)]

about 4 months

[slembcke]

Like a year or more. The problem needed some pretty significant thought put into the API design beyond just the bug itself.

[increpare]

Couple of weeks.

[Cimpresovec]

Hmm. Few days, that darn separated axis theorem :D

[Muz]

Days?

Multi-threaded, multi-process, real-time system with more than 500,000 lines of code. All sorts of bad stuff can happen.

Lol, what is that? Some kind of smartphone operating system?

I've never really spent much time on an individual bug. Maybe around 8 hours at worst, which is about 3 days. Not counting the bugs I've never fixed. My games are pretty straight to the point, none of that multithreading crud, so they're not so hard to debug.

Figuring out what to code is another matter. Spent about 4 months straight (barely leaving the house and all) on pitch detection code.

[iffi]

I don't really remember, considering that I get sidetracked a lot (there's one piece of code I never bothered to debug for months, until I finally decided I didn't even need that class for my program), but the most memorable bug for me was when I was helping a friend debug some code during Java class back when I was new to programming. We spent class periods over several days at least trying to find out what was wrong, changing a bunch of stuff, adding console prints to find errors, and so on... until we discovered that he had accidentally used integer division in one place instead of floating-point.
Fun times, especially when we realized how simple the bug was. The program worked perfectly after that little change.

[benbradley]

I'd not been working in the games industry long when I got given sole responsibility of a PSP downloadable demo, so when it didn't work I assumed the fault was mine. Took me two months full time to figure out there was a misprint in Sony's library documentation and the only problem had ever been that I had to add two letters on to the end of a serial number.  Lesson learned.

4, 6, 12 months tho. That's.... impressive... in a kind of sympathetic way.

[GameRoom]

I remember trying to make this screen wrap system that wrapped with the view. It was so painfully laggy that I had to use a cheap workaround. Looking back I think I could easily fix this.

[Montoli]

Depends on how you count it really.  I strongly doubt that most of the people listing times > 1 week are actually spending all of their development time in that period on the same bug.  (Although things like licensor requirements can cause it.  That PSP bug sounds icky!)  My guess is that they're more like "this bug has been in there for months!  And every couple weeks I take a stab at figuring it out, but it wasn't until 6 months went by that I finally got the epiphany and realized what was going on!  (I'm basing this on the fact that there are very few environments, professional or otherwise, where someone has the incentive to spend 6 months on one bug, with no other progress in development.  Certainly most professional settings will go out of their way to avoid letting that happen, and most people doing this for fun will give up long before then and say "this sucks, I'm going to come back to to this, because it's boring spending a week programming with nothing to show for it.")

I mean, I've certainly had projects where a bug I knew about was in it for months, and I never got around to fixing it until the end because it wasn't trivial to find.  I think most programmers have.  (At least any that have work on projects that last that long.)

But realistically, I don't think I've ever had a bug that didn't take more than, say, a week of focused dev time to solve.  (Or at least to understand it in that time - I guess you could count it as a 6 month bug if you say "oooh, that's what's wrong, my whole renderer doesn't handle this case, I need to spend 5.5 months writing a new renderer to "fix" this.)

Or heck.  I guess you could have crazy long bug times just by taking a liberal interpretation of "bug".  For example, it took me about 2 months to fix the glaring bug in this program:

Code:

void main()
{
	print("hello world!");
}

Can you spot the bug?  The bug is that it displays "hello world" on the screen, instead of an innovative game about poetry!  Turns out that in order to fix the bug, I had to rewrite the program to be an innovative game about poetry instead of a hello world program.

[J. R. Hill]

Does installing windows count as a bug?

[slembcke]

I've come to think so.

[Hempuli‽]

In case this is about looking for the longest time between "why does that not work" and "now I got it working!", I'd say that my best is perhaps a couple days. There are some problems that I've just given up and then realized them later, sometimes during a very different project, though, so if those count I guess I can safely call it a couple months.

[mjau]

A couple months. It was a hard to track down thread-related bug that happened infrequently and seemingly at random, and it corrupted the stack so debugging wasn't much help. Every time I thought I'd found the cause I had no way to verify that the fix worked except to wait and see if it'd happen again... Found and fixed a couple other bugs in the process, but the real cause remained elusive. Eventually I tracked it down to the audio library; either we didn't use it correctly (though I couldn't find anything wrong according to the docs), or there was a bug in the library itself. Unfortunately the devs of this lib weren't much help at all, and it was closed source so I couldn't easily check it myself. After some more hair-pulling I just said fuck it and replaced the audio library with a different one (a few hours' work), and everything was fine from then on.

[yesfish]

When I was first learning to program there was this mysterious bug called "0xC0000005 ERROR". It would come up at seemingly random for no reason. It was to do with my sprite loading code and came up without warning.


Turned out that 0xC0000005 is the error code for stack overflow. I was loading image files onto the stack. Durrrr.

[Jacob_]

It took me a couple of days and a lot of head beating and swearing to stop my character model from either falling apart or being joined together in weird ways in between the server and the client. Latency, Lua, Box2D, and multithreaded IO don't like each other.

And back when I distributed free PHP scripts, it took me a long time to fix my site after someone exploited a "bug" and deleted every file on the server using a proxy. I did learn my lesson though, make sure that you take the PHP editor out of your script before posting a demo of it on your site...

[LemonScented]

Ignoring the "saw it intermittently over a period of months and had a look at it every time but worked on other stuff in the meantime" bugs, and the "I had to leave the game running a soak test for a week before I could reproduce it" bugs, the longest amount of time I can remember spending focussed exclusively on one bug was about 20 hours. A memory trample in a multithreaded PSP game, using an early version of the PSP debugger which was woefully inadequate.