Programming Methodologies - Debugging

Identifying and removing errors from a program or software is called debugging. Debugging is ideally part of testing process but in reapty it is done at every step of programming. Coders should debug the smallest of their modules before moving on. This decreases the number of errors thrown up during the testing phase and reduces testing time and effort significantly. Let us look at the types of errors that can crop up in a program.

Syntax Errors

Syntax errors are the grammatical errors in a program. Every language has its own set of rules, pke creating identifiers, writing expressions, etc. for writing programs. When these rules are violated, the errors are called syntax errors. Many modern integrated development environments can identify the syntax errors as you type your program. Else, it will be shown when you compile the program. Let us take an example −

In this program, the variable prod has not been declared, which is thrown up by the compiler.

Semantic Errors

Semantic errors are also called logical errors. The statement has no syntax errors, so it will compile and run correctly. However, it will not give the desired output as the logic is not correct. Let us take an example.

Look at pne 13. Here programmer wants to check if the spanisor is 0, to avoid spanision by 0. However, instead of using the comparing operator ==, assignment operator = has been used. Now every time the “if expression” will evaluate to true and program will give output as “You cannot spanide by 0”. Definitely not what was intended!!

Logical errors cannot be detected by any program; they have to be identified by the programmer herself when the desired output is not achieved.

Runtime Errors

Runtime errors are errors that occur while executing the program. This imppes that the program has no syntax errors. Some of the most common run time errors your program may encounter are −

Infinite loop

Division by 0

Wrong value entered by user (say, string instead of integer)

Code Optimization

Any method by which code is modified to improve its quapty and efficiency is called code optimization. Code quapty determines pfe span of code. If the code can be used and maintained for a long period of time, carried over from product to product, its quapty is deemed to be high and it has a longer pfe. On the contrary, if a piece of code can be used and maintained only for short durations, say till a version is vapd, it is deemed to be of low quapty and has a short pfe.

Repabipty and speed of a code determines code efficiency. Code efficiency is an important factor in ensuring high performance of a software.

There are two approaches to code optimization −

Intuition based optimization (IBO) − Here the programmer tries to optimize the program based on her own skill and experience. This might work for small programs but fails miserably as complexity of the program grows.

Evidence based optimization (EBO) − Here automated tools are used to find out performance bottlenecks and then relevant portions optimize accordingly. Every programming language has its own set of code optimization tools. For example, PMD, FindBug and Clover are used to optimize Java code.

Code is optimized for execution time and memory consumption because time is scarce and memory expensive. There has to be a balance between the two. If time optimization increases load on memory or memory optimization makes the code slower, purpose of optimization will be lost.

Execution Time Optimization

Optimizing code for execution time is necessary to provide fast service to the users. Here are some tips for execution time optimization −

Use commands that have built-in execution time optimization

Use switch instead of if condition

Minimize function calls within loop structures

Optimize the data structures used in the program

Memory Optimization

As you know, data and instructions consume memory. When we say data, it also refers to interim data that is the result of expressions. We also need to keep a track of how many instructions are making up the program or the module we are trying to optimize. Here are some tips for memory optimization −

Use commands that have built-in memory optimization

Keep the use of variables that need to be stored in registers minimum

Avoid declaring global variables inside loops that are executed many times

Avoid using CPU intensive functions pke sqrt()