What is the difference between Purify and traditional debuggers?

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:

1. Bug finding capabilities from the rational purify,
2. Performance tuning effects from the rational quantify and
3. 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:

1. Array bounds
2. Access to un-allocated memory
3. Freeing the memory that is un-allocated
4. Memory leaks and so on.