- Programming Methodologies
- Home
- Introduction
- Understanding the Problem
- Identifying the Solution
- Applying Modular Techniques
- Writing the Algorithm
- Flowchart Elements
- Using Clear Instructions
- Correct Programming Techniques
- Debugging
- Program Documentation
- Program Maintenance
- Useful Resources
- Quick Guide
- Useful Resources
- Discussion
Programming Methodologies - Debugging
Identifying and removing errors from a program or software is called debugging. Debugging is ideally part of testing process but in reality 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, like 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 line 13. Here programmer wants to check if the divisor is 0, to avoid division 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 divide 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 implies 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 quality and efficiency is called code optimization. Code quality determines life span of code. If the code can be used and maintained for a long period of time, carried over from product to product, its quality is deemed to be high and it has a longer life. On the contrary, if a piece of code can be used and maintained only for short durations, say till a version is valid, it is deemed to be of low quality and has a short life.
Reliability 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 like sqrt()