Spend any amount of time working or playing on
computers and soon you’ll hear three words bandied about: troubleshooting,
testing and debugging. While the first two are common enough, their meanings
might seem blurred or even synonymous. In practice each of these actions is
different, though related.
Troubleshooting is the bane of the end-user and
customer support technician, and begins when software or hardware does not
perform as expected, giving an unanticipated or otherwise unsatisfactory
result. In many cases user error is at fault.
The first step in troubleshooting is to cover the
basics. Is the software or hardware installed properly? Is it configured
properly? Have you read the manual and followed all instructions? Maybe you
changed something in your system that precipitated the problem? Have you been
using this product all along, or is it a new install?
If it’s a new install you can almost be sure that
the trouble lies in the installation process, particularly in the case of
hardware. Hardware requires a device driver (software file) that acts as a
bridge or interface between the hardware and the operating system. If the
device driver fails, the hardware cannot communicate properly with other system
components. Device drivers might not be present or might have been installed in
the wrong order relative to the device.
If the problem lies in hardware that was working
perfectly fine up to the present moment, corruption of the device driver might
be the cause. Reinstalling the driver might solve the problem. An updated
driver might also do the trick. Other times, reseating a component in the
motherboard by powering down the computer, extracting the component then
reinstalling it takes care of the issue.
Troubleshooting hardware in Windows™ operating systems
is also available through the Device Manager and Help menus. A yellow
exclamation mark next to a component in the Device Manager indicates a problem.
Software that starts behaving badly might also be
corrupted. Reinstallation can sometimes help, but if a program began acting up
after new, unrelated software was installed, there might be a conflict between
the two. Firewalls and anti-virus programs are notorious for not playing
together nicely, and it’s probably wise to stick to just one program in each of
these categories unless you are an advanced user.
Troubleshooting in general usually involves
reading manuals or help files, going over the basics to eliminate user error as
a potential cause, and using a search engine to investigate how others have
solved the problem. If there’s one thing you can always count on as an end
user, it’s that someone has walked in your shoes before. The Internet community
is very good about providing help, and in most cases answers can be found by
diligent searching.
Testing is the precursor to debugging. Testing is
commonly the forte of programmers and advanced users, and occurs when a product
is new or is being updated and needs to be put through its paces to eliminate
potential problems. Testing identifies “bugs” or imperfections so that they can
be corrected in the debugging process, before the [next] official release of
the product. These “unofficial” releases are known as beta releases (e.g.
3.0b), and public volunteers are known as beta testers.
Beta testing is a valuable resource for software
developers because of the varied computer systems participating, combined with
the sheer number of hours and scenarios under which the program is used. This
flushes out unforeseen problems in a way that can’t be effectively achieved
using in house debuggers only. The beta testing phase gives authors a good idea
of the readiness of a product for the public domain.
Hardware is beta tested as well but since it is
financially prohibitive to provide free beta hardware to the public, hardware
testing and debugging is commonly done in house. Beta products might, however,
be premiered and in some cases distributed in limited numbers to industry
insiders at conferences such as COMDEX.
Beta software is specifically made available for testing
and is not considered a stable release. Beta testers install beta software at
their own risk, and to help software developers identify the source of a
problem, they must supply a healthy amount of information when reporting a bug.
Required data varies but generally includes system specifications, beta version
and build, the exact conditions under which the bug occurred, and error message
content.
Debugging is the forte of programmers and
developers, and involves fixing the very code of the software to eliminate
errors or bugs. Developers attempt to replicate beta-reported bugs on in house
systems for the purpose of eliminating them.
While there are many types of debugging tools, a
simple example is a tool that allows the programmer to monitor program code
while manipulating it to execute various commands and routines. One basic
approach is to simplify the code as much as possible at the suspected troubled
spot, while still replicating the problem, narrowing the focus to potential
problem lines. In reality, debugging is a complex process that requires
different approaches based on factors such as the complexity and length of the
software code itself, and the language it’s written with.
Debugging can be a tiresome task, though some
languages are easier to debug than others. Java, for example, includes routines
that handle exception errors. An exception error occurs when the program
encounters a situation that must be addressed before the program can continue
on properly. In this case a built-in routine initiates a “search” within the
various layers of software code, looking for an answer to the problem. If a fix
cannot be found, a fatal exception error occurs and the program shuts down. The
resultant error message might include a memory address or some other cryptic
data that will not help the user but could be valuable for debugging.
Well-written programs should not have fatal errors.
Older programming languages like C or assembly are
not as transparent and do not handle errors so efficiently. Debugging programs
written in these languages can test the skills and patience of the debugger.
Thankfully for the end user, commercially
available software has already been debugged of major flaws. Due to this very
reason, most problems encountered by the end user fall within the purview of
troubleshooting and can be fixed by means previously mentioned. On those
occasions that an end user does encounter a bug, going through the motions of
troubleshooting can reveal a work-around until the bug is fixed by the
developer.
When asking for help on a Web forum or newsgroup,
be sure to do your homework ahead of time. Troubleshooting is time consuming,
and people who volunteer their help appreciate someone who has made an effort
to find answers. Inquiring about a problem that has been asked and answered
repeatedly will not win you friends and is considered poor netiquette.
No comments:
Post a Comment