The IBM Rational Purify grants power to the
developers to deliver a product whose quality, reliability and performance
matches with the expectations of the users. The purify plus combines the
following and provides 3 benefits:
- Bug
finding capabilities from the rational purify,
- Performance
tuning effects from the rational quantify and
- Testing
rigors from the rational pure coverage.
Together these three things make purify a different
debugger that what the traditional debuggers we have. The above mentioned 3
benefits are measured in the terms of the faster development times, less number
of errors and better code.
About IBM Rational Purify
- The purify is actually a memory debugger by nature
and is particularly used for the detection of the memory access errors
especially in the programs that have been written in languages such as C and
C++.
- This software was originally developed by Reed Hastings, a member
developer of the pure software organization.
- However, Rational Purify
exhibits the similar functionality as that of the Valgrind, bounds checker,
Insure++.
- A process called dynamic verification using which the errors that
occur during the execution can be discovered by a program is supported by the
rational purify just like a debugger.
- However, there is another process called
the static verification which is just the opposite of the dynamic verification
and is also supported by the rational purify.
- This process works by digging out
inconsistencies present in the program logic.
- Whenever there is a linking
between a program and purify, the correct version of the verified code is
automatically inserted in to the executable part of the code by either adding
it to the object code or by parsing.
- So, if whenever an error occurs, the
location of the error, its memory address and other relevant info will be
printed out by the tool.
- Similarly, whenever a memory leak is detected by the
purify it generates a leak report towards the exit of the program.
Difference between Rational Purify and Traditional Debuggers
- The major difference between the rational purify
and the traditional debuggers is the ability of detecting the non – fatal
errors.
- The traditional debuggers only show up the sources which can cause the
fatal errors such as a de-referencing to a null pointer can cause a program to
crash and they are not effective in finding out the non – fatal memory errors.
However, there are certain things for which the traditional debuggers are more effective
than the rational purify for e.g.,
- The debuggers can be used to step line by
line through the code and to examine the memory of the program at any
particular instance of time.
- It would not be wrong if we say that these two
tools are complementary to each other and can work great for a skilled
developer.
- The purify comes with other functionality which can be used for
more general purposes rather than the debuggers which can be used only for the
code.
- One thing to be noted about the purify is that it is more effective for
the programming languages in which the memory management is left to the program
developer.
- This is the reason why the occurrence of the memory leaks is reduced
in the programs written in languages such as java, visual basic and lisp etc.
- It
is not like these languages will never have memory leaks, they do have which
occur because of the objects being referred to unnecessarily (this prevents the
re – allocation of the memory.).
- IBM has provided solution for these kind of
errors also in the form of its another product called the rational application
developer.
- Errors such as the following are covered by the purify:
- Array
bounds
- Access
to un-allocated memory
- Freeing
the memory that is un-allocated
- Memory
leaks and so on.
