Common mistakes of software developers (cont.)

Some of the common problems are listed:

MY PROBLEM IS DIFFERENT

Many designers and programmers refuse to listen to the experiences of others, claiming that their application is different, and of course much more complicated. Designers should be more open-minded about the similarities in their work. In response, ask “what is different in the LCD display software in a cellular phone versus one on a temperature controller? Are they really different?” Comparing control and communication systems side-by-side, both are characterized by modules that have inputs and outputs, with a function that maps the input to the output. A 256 by 256 image processed by a algorithm might not be very different from graphical code for a LCD dot matrix display of size 320 by 200. Furthermore, both use hardware with limited memory and processing power relative to the size of the application; both require development of software on a platform other than the target, and many of the issues in developing software for a micro-controller. The timing and volume of data is different. But if the system is designed correctly, these are just variables in equations. Methods to analyze resources such as memory and processing time are the same, both may require similar real-time scheduling, and both may also have high-speed interrupt handlers that can cause priority inversion. Perhaps if control systems and communication systems are similar, so are two different control applications or two different communication systems. Every application is unique, but more often than not the procedure to specify, designs, and build the software is the same. Embedded software designers should learn as much as possible from the experiences of others, and not shrug off experience just because it was acquired in a different application area.


Large if-then-else and case statements

It is not uncommon to see large if-else statements or case statements in embedded code. These are problematic from three perspectives

1.) They are extremely difficult to test, because code ends up having so many different paths. If statements are nested it becomes even more complicated.

2.). The difference between best-case and worst-case execution time becomes
significant. This leads either to under-utilizing the CPU, or possibilities of timing errors when the longest path is taken.

3.) The difficulty of structure code coverage testing grows exponentially with the number of branches, thus branches should be minimized.

This example confuses new testers who lack in programming experience.
Developers think their code is always correct and as mentioned earlier 99 % errors are corrected by themselves and remaining 1%.errors will be found out by testers. In the below example the

IF (0 < x < 12) then
SYSTEM.OUT.PRINTLN (“Month is” & i);
Else
SYSTEM.OUT.PRINTLN (“Invalid input”);


Consider how this code could fail. Here are some of the simple programming errors that are very common mistakes that can go wrong:

a) Suppose the programmers said less than or equals instead of less than. The program would eject 0 as bad character. The only way to catch the error I by testing with 0.

b) If the code is written as less than 12 instead of less than or equal to 12, the program would go wrong.


“Testers with just the four boundary characters, /, 0, 9, and: will reveal every classification
Error that the programmer could make by getting an inequality wrong or by mistyping”

Error Handling:

Errors in dealing with errors are common. Error handling errors include failure to anticipate the possibility of errors and protect against them, failure to notice error conditions, and failure to deal with a detected error in a reasonable way. Many programmers correctly detect errors but then branch into untested error recovery routines. These routines’ bugs can cause more damage than the original problem.

Some times the errors are more even large while executing the tests and the Microsoft’s worst scenario is we can’t copy the error messages. There are some tools for copying the text of such error messages and also we can take the screen shots.


Conclusion:


Testers should have a common sense in smelling the non obvious things. There is a relation between developers and testers in fixing the bugs. The probability of fixing the bugs is always depends on the way the test cases are communicated. Test cases play a major role in the QA's life. Test Cases are written in such a way that they are traceable, self contained and should not be duplicated in preparing they should always be atomic.



"Why go into something to test the waters? Go into it to make waves"





HAPPY TESTING

Common mistakes of Software developers

Introduction:

Most Software developers are not even aware that there favorites methods are problematic. Quite often experts are self thought, hence they tend to have the same bad habit as when they first began, usually because they never witnessed the better ways of performing their embedded systems. These experts then train novices who subsequently acquire the same bad habits. The purpose of this presentation is to improve the awareness to common problems, and to provide a start towards eliminating mistakes and thus creating software that is more reliable and easier to maintain.

It is easy for spending a million on testing a program. Common estimation of the cost of finding and fixing the errors in program range from 40% to 80% of total development cost. Companies don’t spend this kind of money to “verify that a program works”. They spend it because the program doesn’t work, it has bugs and they want them found. No matter what development methodology they follow, their programs still end up with bugs. Beizer’s (1990) review estimation the average number of errors in program released to testing at 1 to 3 bugs per 100 executable statements. There are big differences between programmers, but no one’s work is error-free.

One error per 100 statements is an estimate of public bugs; the ones still left in program after the programmer declares it error-free Beizer (1984) reported his private bug rate, how many mistakes he made in designing and coding a program, as 1.5 errors per executable statement. This includes all mistakes including typing errors.

“At this rate, if your programming language allows one executable statements per lines, you make 150 errors while writing a 100 lines program.”

Most programmers catch and fix more than 99% of their mistake before releasing a program for testing. Having found so many, no wonder they think they most found a lot. But they haven’t .Tester’s job is to find the remaining 1%.

Correcting just one of the mistakes within a project can lead to week or months of savings in manpower (especially during the maintenance place of a software life cycle.).

Mail from Mr. Pradeep Soundararajan

For a long time i wasn't unable to update my blog after recieving the mail from Mr.Pradeep Soundararajan.


Hi Amardeep,

I am sure you know at least a little about me and you might not need my introduction. I found my blog linked to yours and as it seemed to be on testing, I did want to peruse it.

I was impressed by the fact that you linked people James and Dr Cem Kaner with respect of Mr. I intended to make you a few suggestions to help you write better posts.

1. The copy paste stuff never makes someone read your blog, since there are so many copy pasted stuff. All people might want to read is your experience, be it little or whatever or your day to day testing activities, the problem you face, the problems you solve, the testers you meet and lots more.
2. You might also want to read this: http://testertested.blogspot.com/2006/11/indian-testing-community-start.html

Best wishes and Happy Testing!



I feel really good after recieving the mail from
Mr.Pradeep Soundararajan. I always want to write my own experiences and thoughts after reading his mail. i will do my best in improving my blog and skills.


DEAR UPCOMING TESTERS : this mail is not only for me, but for all of you who just want to become the stars in TESTING INDUSTRY

why do software fails !

Generally speaking, there are bugs in software because of unclear requirements, software complexity, programming errors, changes in requirements, errors made in bug tracking, time pressure, poorly documented code and/or bugs in tools used in software development.

* There are unclear software requirements because there is miscommunication as what the software should or shouldn't do.

* Software complexity. All of the followings contribute to the exponential growth in software and system complexity.

* Programming errors occur because programmers and software engineers, like everyone else, can make mistakes.

* As to changing requirements, in some fast-changing business environments, continuously modified requirements are a fact of life. Sometimes customers do not understand the effects of changes, or understand them but request them anyway. And the changes require redesign of the software, rescheduling of resources and some of the work already completed have to be redone or discarded and hardware requirements can be effected, too.

* Bug tracking can result in errors because the complexity of keeping track of changes can result in errors, too.

* Time pressures can cause problems, because scheduling of software projects is not easy and it often requires a lot of guesswork and when deadlines loom and the crunch comes, mistakes will be made.

* Code documentation is tough to maintain and it is also tough to modify code that is poorly documented. The result is bugs. Sometimes there is no incentive for programmers and software engineers to document their code and write clearly documented, understandable code. Sometimes developers or programmers feel they cannot have job security if everyone can understand the code they write, or they believe if the code was hard to write, it should be hard to read.

* Software development tools, including visual tools, class libraries, compilers, scripting tools, can introduce their own bugs. Other times the tools are poorly documented, which can create additional bugs.

Globalization Testing

Globalization Testing ensures the application can function in any culture/locale. The goal of globalization testing is to detect potential problems in application design that could inhibit globalization. It makes sure that the code can handle all international support without breaking functionality that would cause either data loss or display problems. The following must be part of your globalization-testing plan:

1.) Decide the priority of each component :

To make globalization testing more effective, assign a testing priority to all tested components. Components that should receive top priority:

* Support text data in the ANSI (American National Standards Institute)format.

* Extensively handle strings (for example, components with many edit controls).

* Use files for data storage or data exchange (e.g., *Windows metafiles, security configuration tools, and Web-based tools).

2.) Select a test platform,

3.) Create the test environment,

4.) Execute tests,

5.) Recognize the problems.


LIFE begins when we loose,

LIFE ends when we win,

So, make sure that you always win.


-------AMAR DEEP MARADANA