I am working with a team that has been working together for a while. I learned today that one of the “normal” practices for this team is to reboot development machines between code changes. This is done to mitigate the various odd behaviors and crashes they encounter if they don’t. My first thought after hearing this was, “WHAT?!?!” It sounds amazingly unproductive to me. Of course, in my experience I tend to develop code a bit differently than other people.

My development practices tend toward a short “author/build/test” cycle. Short in terms of a function or two. Normally, I would follow the new code flow in a debugger, to make sure things are behaving how I would expect them to. This system allows me to guarantee that my code is solid when I make it available to everyone else, and I have a system that allows pretty rapid development. My guess is that members of this team do a lot more authoring before testing changes. This, in my experience, just leads to more difficult debugging, and less tested code. Especially when in this development system we don’t have debuggers. I guess I should feel lucky that I have printf available to me.

I asked why no one had figured out why a reboot is needed, and was told that the person who could fix the problem doesn’t run into the problem because they develop differently from everyone else. What kind of dysfunctional system is that?

Given the longer “author/build/test/reboot” cycle of this team I may have to modify my own practices. It will be impractical to reboot my machine 12+ times a day. Perhaps I’ll spend some free time trying to understand what the root problem is and fix it for everyone, instead of just complaining.