How to work with backdoor code changes?

Question

Scenario

I admit (somewhat shamefully) that I not only witnessed this particular practice, but also took it upon myself. My name is Jeff and I play a quality process to get my way. I mean the script.

Engineer A wants to do something in a specific way, but Engineer B has already implemented it. Instead of working within the framework defined by the Engineer B implementation, Engineer A overwrites it to fit its own path, and then discovers a suitable weak reviewer (or some other bend in the process) to allow for changes.

This, of course, has a knock on when Engineer B discovers a trick and tries to find a way to get his original approach reinstalled by a similar vile means, and thus the conflict begins.

Decision

There are many potential solutions for this scenario, such as having one person responsible for appointing reviewers or programming for a couple, but I'm not sure if they really can stop a particular engineer. I also do not think that not hiring engineers who can do this is the best plan, because often those engineers with the best abilities are prone to this dismissive behavior "my decision is clearly better than theirs."

This is usually a side effect in flexible processes when the detailed design phase is blurred with implementation, so the review is also a design conclusion. This is obviously an important area where the problem can also be solved.

Question

What approaches to the quality process mitigate this? Do you have experience retelling this, shedding light on what to do or what not to do? What were the consequences (good, bad, nonexistent)?

I must add that I ask how we are trying to deal with this problem in our own project, so I ask here.

Answer 1

1) A strong coding standards document that also includes code templates.

2) A team that discusses all together in order to agree on a common path forward instead of carrying out passive aggression against their colleagues.

3) A team that wants to listen to other people, and not every member who thinks about their own path, is best.

4) Postponement of work experience in a team after a decision is made. This is difficult if the senior member does not personally implement (3).

Answer 2

I have seen this behavior in several scenarios:

• Engineer B left the mess, and Engineer A cleaned it up.

• Engineer A believes that Engineer B left a mess and she cleans it.

• Engineer A is not strong enough to read and understand the existing solution, so he rewrites it in a way that makes sense to him. Reading code and understanding it is more difficult than writing code.

• The team is not focused on the “leave without a trace” approach in development - touch as few classes, methods and control structures as possible in order to correct a mistake or configure a function, since each change has the potential side effect. Engineers are allowed too much room for noodles.

You resolve each scenario differently:

• Do all engineers constantly rewrite the code of one person? Watch carefully and determine if engineer A. is struggling. Maybe she was not far behind. Perhaps it creates problems. If so, then work with her to speed up. If this fails, she must leave for the good of the team.

• This is the ego issue you mentioned in the JeeBee comments . Other answers here give good recommendations to reduce the problem. If ego problems persist, I would say that the team has the wrong focus. The bottom line should be to do as much as possible in the least amount of time with the least errors. Constantly rewriting another engineer code is not conducive to this effort.

  Encourage the team to answer these questions before they make a change: is my solution really much better? Do I really understand what another engineer was trying to do, or am I just lazy and rewrite it in a way that makes sense to me? If this is objectively better, why do I know that Engineer B is going to come back here and change it?

• Does one engineer constantly rewrite each code? Watch carefully and determine if he is fighting. If so, then work with him to speed up. If this fails, he must leave for the good of the team.

• I was blessed to work with great teams, so in my experience this is the most common problem. We solved this by first admitting that we had a problem (maybe I will develop a twelve-story program for noodles). Great engineers / developers are noodles. They tear things apart and combine them. Their first instinct, even when he revises his own code, is to break it and make it better. This is great at the design and discovery stages, but dangerous later in the dev loop. So, admit that you are noodles. Each time you pull the last out of the original control, resist your noodle instinct. Ask yourself what is the least you can do to solve the problem. Ask everyone on the team to take the “leave no trace” approach.

  Do not cover your inner noodles forever. If it will be increasingly difficult for you to resist the aspiration of your noodles in a certain part of the application, it may be time for a major refactoring. Come up with a plan and present it to the group. If this is a really good idea, they are likely to agree.

Answer 3

I have not seen any positive correlation between good engineers and anti-social behavior. Most of the really good programmers and architects I met were good communicators who gained their skills by learning from other people. Programming is a group effort. Someone like this must be very productive in order to compensate for the negative impact they have on other programmers.

I do not think this is a side effect of flexibility. I see that this happens in unsuccessful flexible implementations, but in my experience flexible teams work better together and know more that they are doing everything. Short iterations and quick feedback on team performance usually make it very productive.

The key to solving such problems is communication. People on the team must know what other people on the team are doing in order to work as a team.

Follow a reasonable team size. Large teams cause communication difficulties. Separate teams that are too large for smaller teams that have responsibilities.

Get up daily to meetings where people share what they did yesterday, what they plan to do today, and what problems they face. This can prevent people from implementing design changes in secret.

Make sure people are gathered. When people sit together and work together, they are more likely to seek solutions together.

Of course, such problems can occur, but if this happens often, it can be an indicator of other problems within the team.

Answer 4

One of the approaches that I have seen is to designate "guards" - rather senior developers, each of whom is responsible for the final state of one specific module of functionality.

In the event of an implementation dispute, the final word goes to the Guardian module.

Often the Guardian role extends to more active work, such as architecture, quality control, etc.