By V. Berba Velasco Jr., Ph.D.
As published on
Impact Articles and www.articlecity.com. Copying of contents, in whole or in
part, is permitted provided that the author by-line is kept intact and
unchanged. Hyperlinks and/or URLs provided by the author must remain active.
Let's say that you have a software project that's under severe time pressure.
Let's say that this deadline is so tight that you already know it will involve
many late nights of black coffee and frenetic programming. What can you do to
make this process go faster?
I honestly don't know, since the correct answer will depend on one's individual
circumstances. However, I can tell you how many programmers do respond under
such circumstances. They decide to save time by skipping over the software
planning and design phase, and immediately start coding away.
To an inexperienced or otherwise undisciplined programmer, this seems to make
sense. After all, the finished product is what truly matters, right? The
customer doesn't care about flowcharts, class diagrams or software
architectures. All they want is something that works.
It seems to make sense, but it's a foolhardy approach. That way lies madness.
We've all heard that an ounce of planning is worth a pound of cure, but in the
world of software development, this adage is often forgotten.
If a real estate developer needs to get a house built quickly, does he save time
by skipping over the architectural design phase? Does he decide to dispense
with blueprints, and just start laying down concrete? Of course not. He knows
that the results would be chaotic, and that work will progress more slowly
without careful forethought and a concrete plan.
Yet that's the approach that many people take when it comes to software. They
decide to just start coding away, thinking that this makes the software
development process more efficient. On fairly simple projects, this might work.
On anything of moderate complexity though, such an approach is doomed to fail.
Sure, you may save time at first. However, without a concrete software plan and
a carefully considered design, problems are bound to catch up with you before
long. Many of these problems won't become clear until the testing phase comes
around, and by then, it may be too late.
Sadly, such reckless thinking is often encouraged in the corporate world. Due to
time constraints, a misguided manager may instruct his team to skip over the
design work and just start hacking away. This makes the team seem focused and
productive, but this strategy can wreak havoc on the project timeline. What's
more, the resultant code is often a tangled, poorly documented, chaotic mess.
If this software must be maintained for years to come, then you have a recipe
for disaster.
Mind you, I'm not saying that an elaborate design is always necessary. If time
is short, then one might not have the luxury of an intricate software plan with
exhaustive design documentation. However, one should at least have a general
software architecture laid out-one which is detailed enough to make the
software development process smoother and easier. Programmers rarely err on the
side of over-planning, but they frequently fall into the trap of insufficient
design detail. Don't make this mistake, if you really want to save time.
About the Author:
V. Berba Velasco Jr., Ph.D. works as a senior electrical and software engineer
at Cellular Technology Ltd (http://www.immunospot.com,
http://www.elispot-analyzers.de,
http://www.elispot.cn). a biotechnology company that prides itself on
its standards of excellence.
