The Punished Fixer

I'm what I like to call a "fixer." I'm someone that (incorrectly) thinks they can fix nearly anything (given the right tools/budget/timeline). I don't tell a lot of people that. But, I'm usually recruited in my professional and social circles as the guy who can figure it out. I'm usually not the first person they ask, but I'm almost always the last person.

Recently, I was called in to a problem I had been watching develop for at least a year. While I tried to nudge people in the right direction without trying to sound like an arrogant know-it-all, I erred on the side of letting people make their own mistakes.

That strategy didn't work (for me). The problem became more serious. Finally, the person in charge told me they were basically out of ideas. They had given up. They didn't want to fix the mess they had gotten themselves into (even though I tried to subtly point out the warning signs along the way). They asked me to fix it.

I knew the system they were working on. By way of an exaggerated analogy, the code could be reduced to something like the following:

class Navigator:

    def __init__( self, map ):      = map
        self.position = ( 0, 0 )

    def move_to( self, position ):
        if position ) == False:
            raise NavigationError()
        self.position = position

class Map:

    def __init__( self, width, height ):
        self.width  = width
        self.height = height

    def is_valid( self, position ):
        # TBD: implement later when I have the time
        return False

In reality, the culprit chunk of not-implemented code was more subtle, and more difficult to find. But, the important part of the problem was that this person had left in some barely-functioning placeholders that should have been implemented on their first pass through the code. Instead, I think this person had diverted their attention to something else they felt was more interesting, and never circled back to address a fundamentally flawed piece of software.

When this code got out into the wild, a lot of people were having problems. They stopped trusting the software.

It made me upset because the other parts of the software where I had more influence were working really well. Instead, this subtle issue compromised the whole thing.

Well, the person who created the problem finally came to me. They told me they weren't even going to try anymore, and that it was my problem. In this situation, there was no way I could have intervened to fix the problems I saw earlier.

So, I started fixing it. I uncovered the root causes, found a lot of the missing parts, and started adding what was missing. As the software was improving, the original author started noticing how I was fixing things. They didn't like the way I was doing it. I didn't directly come out and tell them they failed at something that was really more closely related to their responsibilities than mine. I just did my best to get things working.

After things were getting better, the original author got upset. They told me they didn't like what I was doing, and that I shouldn't be trying to address the root cause. I should just be fixing the symptoms, and covering up their deficiencies.

My last interaction with the developer was yesterday. This particular situation has been bothering me for a week. The larger problems have been bothering me for years. I want things to get better. I want to re-address the whole situation. I want to believe I can fix my interaction with this other person. But, every time I try to make things better, this person reminds me how irrational they can be if I so much as suggest that there is even the smallest flaw in their abilities. Trying to maintain a relationship with a person who acts so defensively feels so futile. I feel abused and disrespected. But, I can't give up on them. I'm here to stay. Sometimes I feel like my life is all about fixing other people's issues.

At this point, I just want the software to work.