March 30, 2009 20:56
There are three types of development:
- (Re)design
- (Re)implementing the functionality
- Bugfixing and refactoring
Of course, sometimes your "implement the stuff" timespan can be interrupted with high priority bugs. And indeed your redesign sometimes can come along with new functionality from the get go.
However, it is important not to mix the approaches you use in each case.
- While doing a
(re)design you address the core issues: performance, scalability,
maintainability, etc. You think strategically and spend a lot of time
evaluating the alternatives. This should pay off in future, and the
price of a mistake is tremendous.
- While
(re)implementing the functionality, you're restricted with the existing
design and need to code the solution as well as possible, within this
design. You think tactically and spend some time evaluating the alternatives, and the price of a mistake is high.
- While fixing bugs or refactoring, you're restricted within existing design and implementation. You spend some time understanding the problem, come up with a fix and apply it. The price of a mistake is moderate.
It's often tempting to suggest a
better implementation while doing a bug fix, or come up with a more
decent design while refactoring code. Sometimes it might be reasonable,
sometimes not, but you need to remember that when you level up, the time spent on a solution increases and so does the price of a mistake.
While bugfixing, refactoring, re-implementing, etc - there is an alternative to immediately solving problems at the upper level.
Finish off the current task as well as you can, and add the issue to
your backlog with a priority. Tell the business that you cannot move on
until it is addressed (so that it wouldn't turn into a rain check). But
find time and resources to deal with the issue properly: in a rush, it
is possible to be wrong about the implications or overlook a better
way.
Make a healthier project without unnecessary pressure.