As is the case for everyone on Earth, time is a very fickle and scarce resource for a developer. It must be managed carefully in order to ensure that the payoff of time-investment is maximized. There are several practices which assist a developer and a development team to ensure that their time investments are legitimate.
In considering time, we live in the moment called “now.” Now is always bright and clear and is wedged between the past (which tends to become murky and stuffy) and the future (which is completely opaque and unfathomable).
In terms of the developer’s life, the old saying “there is no time like the present” really is true. The only things we can be certain of are in the past or are currently occurring. The future becomes less and less certain as one looks forward. We must attempt to aggregate as much important work as we can into the here-and-now. Yet, too often, developers try to put things off and push them down into the dark cloud of the future with expectations that the future is set in stone. This is the source of so much chagrin in life. The future becomes dark and unfathomable very quickly (maybe within minutes of “now”).
All of us must understand that there is precious little that one can do about the future other than to hedge bets. Of course, there is nothing wrong with planning, but all planning should also include contingencies. What if the planned event doesn’t come to pass as expected or even at all? Of course, the lack of planning in key areas of life is the hallmark of foolishness.
The problem arises when we willingly decide to throw items that we should deal with here and now down the road to some undetermined time. The more that we develop this bad habit, the more undependable we become to our peers, our management, and our business partners. We will miss deadlines (which we consider to be mere paper-walls drawn across our future), rush to create careless code as time dwindles, or exhaust ourselves with overnighters as we try anxiously to pay off the promise-debts we incurred for ourselves in the first place.
Proper time and task management is of crucial importance to handling the workload but this must be coupled with a strong and unwavering discipline that enforces the fact that work destined for “now” cannot be pushed into the future unless there is some overriding need (e.g. a priority reshuffle, the breakdown or failure of a critical resource, a crucial life event, etc.). Even when something must be delayed for a legitimate reason, it must still be handled with proper discipline to prevent it from “falling through the cracks.”
As many who know me would agree, I am an advocate for Agile development processes. A technique such as Scrum brings a strongly-manageable understanding of the tasks slated for “now” and for the very immediate future. The backlog extends in both directions, encompassing the past and embracing the future. The lessons of the past feed forward into the” now” and immediate future by using past team performance to predict a reasonable and achievable set of goals within the short sprint timeframe. However, Agile processes by themselves do not overcome the individual developer’s need for disciplined time and task management.
It is incumbent upon each member of the team to consider the effect of delay upon themselves, upon the project, and upon their peers. While both life-events and work-events (e.g. Email, calls, production issues, health problems, family issues, business events) will interrupt a developer’s workday, planning blocks of time and allocating them to meet the current “now” development needs should be a part of one’s daily calendar. There is no problem with pre-planning the next few days, but always with the understanding that the future is fluid and changing. The best way to ensure you are not pressed for time towards the end of projects, deadlines, and sprints is to do the bulk of the work upfront while “now” is now. Essentially, the effort curve towards any deadline should be front-loaded.
Remember, the key is to ensure that contingencies in the future are anticipated. By concentrating on the bulk of the work (and the more difficult and intricate parts of the work) up-front, one minimizes the possibility that the future can cause excessive amounts of work, overtime, or sloppy coding as the deadline looms. Try as much as possible to eliminate the source of such frustration. Do not be glib in throwing any task “down the road” for any reason other than one which forces one’s hand.
At times, procrastination can be a good thing to a project as long as it is a group-mediated procrastination effort. Many times, seemingly great ideas for product additions and changes, or for refactoring may bubble up within the business and development teams, but when examined though the prism of time are either not so great or not as pressing as originally imagined. This is where processing ideas through an Agile process backlog grooming approach really pays dividends since the truly critical functionality tends to bubble up into the current sprint and the fluff tends to be pushed down deeper into the backlog stack.
In closing, it is my habit to advise every developer I meet to avail themselves of a good time and task management class. This is beneficial and can provide an excellent external source of control to the mayhem of planning for “now.” However, one also has to develop a strong habit of being disciplined in following the task and time management goals. This cannot be taught, it must be acquired and cultivated. I can assure you that if you do, you will be a more productive developer and able to accommodate unexpected future events with less stress and anguish.