There are a number of common-sense software development practices that can actually hurt your chances of success.
Here are 5 common-sense items you might want to avoid:
1) Treat Team Members the Same
It’s common practice and it makes sense. It’s fair, right? Treat everyone the same. What could be wrong with that?
The origins of the “fairness” practice may come from early childhood when kids discover crying “no fair!” is a great tactic for getting what they want, or maybe it has something to do with the golden rule of “treating thy neighbor as thyself.”
But in practice, we usually do treat our neighbors differently. Some neighbors we hang out with, invite to our houses and party with into the wii hours of the night. Other neighbors we avoid like the plague. So why do we force ourselves to treat all team members the same?
Some team members contribute immensely to the success of the project; they are self motivated, get their work done on-time and get along with everyone. Others, we can hardly count on, they consistently miss self-projected deadlines, they are sick a lot (in the Bahamas) and frequently complain about others.
Why should these two personalities be treated or rewarded similarly? Doing so only reinforces the negative behavior and increases the risk of losing the preferred team member. You have limited resources, both in time and reward-money. If you spread them equally among the team, it’s a disservice to your organization.
You can count on your best team members recognizing that and not tolerating it for long.
2) Follow Established Procedures or Processes
Procedures and processes are there for a reason: to avoid mistakes and to identify the people who make mistakes. Following the rules only makes sense. Avoiding mistakes is a good thing.
Well it might be a good thing, until your best team members start to feel as though their hands are tied behind their backs and if it wasn’t for some stupid process, they would be able to get a task done in 1/10th the time.
Avoiding mistakes is a good thing, but at what cost? Software engineers are essentially problem solvers. That’s what they do all day. The best of them enjoy and derive fulfillment from solving problems with the least amount of effort (both personal effort and computing resources). They are by nature very intelligent people. Every developer on the team probably possesses well-above-average intelligence. They will find ways to solve problems, but if they are bound by some arbitrary rules that prohibit them from deviating from standard procedures and processes, their productivity (and creativity) is limited.
This isn’t to say teams should avoid processes all together. But as a team, there are two ways to view processes: one is to view them as the laws of the land which should be followed at all times and the other is to view them as a set of recommended guidelines that seem to work well, but feel free to deviate as you see fit. The latter is far more productive for intelligent people.
To invoke another biblical adage: The process is created for the team, not the team for the process.
3) Create a Detailed Design Before Starting Development
Seems like a great idea. A detailed design is like a step-by-step instruction list on how to get the job done. Having a detailed design makes the programmer’s job much easier. Nearly brainless. If X is the input, Y is the output. Don’t think about whether or not it makes sense. Just do it.
With detailed designs, you nearly guarantee an increase in productivity and you nearly guarantee a result that’s mediocre at best. Without the ability to refine and adapt a solution as the work is being performed, you eliminate hundreds of branches of potential evolution, which could have made the result that much better.
But having evolutionary branches of a potentially better solution scares a lot of project managers. What if the branches are never-ending and the solutions never get done? That’s a real possibility if the project manager doesn’t do his job well, because a huge part of that job is to help guide the evolution to an outstanding result.
Plus the up-front savings of avoiding a detailed design and opting instead for rough design guidelines will often produce better solutions in less time.
4) Make it Difficult to Change Requirements Mid-way
Project managers are all about delivering their projects on-time and on-budget. The number one risk-factor for delivering a project on-time is a change of requirements.
And, that’s why we have change committees involving numerous people from different departments whose job it is to approve any changes to the established project scope. They analyze the impacts of a change on the project schedule and the budget, often inflating both to increase the likelihood of rejection or at least provide some padding in case the change is approved.
The results are predictable. Changes are nearly always killed by the change committee. Who in their right mind would approve a change that increases the cost of the project and delays the delivery date?
Here’s the big problem with killing nearly all changes: some change is good and by making changes difficult in general, too many changes are killed. It’s a chemotherapy approach of dealing with change…kill nearly everything and hope that the few surviving cells happen to be the ones you wanted to keep in the first place.
That’s definitely one way to do it. But, development teams that employ a democratically-run change committee (1 person, 1 vote) will never create outstanding products. Ideally, changes should be reviewed by teams of 3-4 people, with 1 person having the ultimate say, after considering the input of the committee.
5) Assign Tasks Based on Resource Availability
Gantt charts are a project manager’s best friend as they allow the project manager to view the entirety of the project in a visual representation with dependencies and they can even provide resource assignments. But one of the drawbacks of the Gantt chart (such as Microsoft Project) is that project managers are encouraged to simply assign tasks based on resource optimization and leveling features.
The problem with this should be obvious: important tasks are often randomly assigned to team members based on their availability rather than their skill sets. This is a huge mistake!
Another one of the project manager’s major roles is determining the strengths and weaknesses of each team member and assigning tasks based on this information. Assigning critical or show-stopper tasks to a weak team member is a recipe for disaster. Likewise, assigning trivial tasks to your most talented team members is a waste of your best resources (not to mention a risk of decreasing job satisfaction for those team members).
No Gantt chart is going to identify this information for you. That’s your value-add to the team.
Hopefully by avoiding these common(-sense) mistakes, you can improve your development success. Remember, a lot of the above hinges on the quality of your team, which I wrote about previously. I’d love to hear your thoughts on the above suggestions. Get in touch on Twitter if you agree or disagree with some reasons or examples why.
Stay on the cutting edge of software development by getting innovative tips, trends and stories delivered to your inbox every month!