1. Introduction
Testing process in any software organization is the key element to produce bug free, highly quality oriented software applications. This White Paper provides a great deal of information regrading testing process of web based applications.
Before we go ahead, we would like to provide an idea what Software Testing is all about.
Software Testing is an activity aimed at evaluating an attribute or capability of a program or system and determining that it meets its required results. It also ensures the working of the designed application as per specification. There are many approaches to software testing, but effective testing of complex products is essentially a process of investigation, not merely a matter of creating and following rote procedure.
Mainly, we have targeted to cover the answers of the following four points:
1. Why we encounter bugs in software applications
2. What can be the best practice to prevent bugs.
3. What is the best way to get them managed.
4. What is the ideal testing process.
Software testing continues to grow more complex as the nature of web software application is getting more complicated and the vista of these application are becoming widen making it challenging for any tester to cope up with this process.
2.Why we encounter bugs in software applications:
Many of us encounter bugs in day to day life in the application that we use. Have we ever tried to give a thought why we encounter bugs in a software application. There are many factors playing a major role behind a buggy software. Most are man introduced and some are machine oriented.
If we elaborate the issue , we will have the following points:
2.1. Lack of proper communication: People associated with developing the software is not we aware of what an application should do and what it should not. In short, lack of requirements gathering.
2.2. Complexity of Software: Now a days software enters in to every domain of work. Complexity of current software system is so hard that it is very difficult to comprehend for anyone without the experience and knowledge of modern day software development. Right from Windows-type interfaces, client-server and distributed applications, data communications, enormous relational databases to sheer size of applications have all contributed to the exponential growth in software/system complexity. And the use of object-oriented techniques can complicate instead of simplify a project unless it is well-engineered.
2.3. Programing error committed by programmers: It is obvious that programmers can introduce syntax error or logical error without their knowledge, which may lead to disaster situation.
2.4. Rapid changes of requirements: Client can request any feature or changes in the mid of the development without knowing the impact of the changes. If there are many minor changes or any major changes, known and unknown dependencies among parts of the project are likely to interact and cause problems, and the complexity of keeping track of changes may result in errors. Redesign, rescheduling of engineers, effects on other projects, work already completed that may have to be redone or thrown out, hardware requirements that may cause unbalance in the developed system.
2.5. Dead Line and Time pressure: When unrealistic deadline is given, people rush in hurry without going in-depth of the product. Scheduling of software projects is difficult at best, often requiring a lot of guesswork. When deadlines predominate and the crunch comes, mistakes will be made.
2.6. Poorly Documented Code: It’s very tough to maintain and modify code that is badly written or poorly documented. That appears or results as a bug later after any changes. In many organizations management provides no incentive for programmers to document their code or write clear, understandable code. In fact, it’s usually the opposite: they get points mostly for quickly turning out code, and there’s job security if nobody else can understand it.
2.7. Lack of real Testing Environment: It is also important to consider the real environment where the software program will be implemented. It is very common that we can miss out those test conditions and scenarios to test for the lack of proper testing environment. This might be turned out as critical defect leakage at times.
2.8. Undefined Testing Process: Testing of a software system is not taken as seriously and carried out undocumented and undefined testing activities. Lack of well trained and experience QA professional also be the cause of buggy software.
4. What can be the best practice to prevent bugs:
We know that prevention is better than cure. This is the section in which we will discussion what can be done to prevent bugs before testers come to rescue. We had seen enough evidence in our company earlier that very few were interested in taking the initiative to prevent early mistakes. However, since the guide line in place, we witnessed a lot of improvement in the software developing stage.
3.1. Writing quality code: Though quality is a non tangible attribute, but programmer needs to ensure it right from the beginning.
3.2. Unit testing:Programmer should debug the code using any Unit testing tool to insure the functionality of the developed module. They should not limit themselves to positive cases but also negative use cases.
3.3. Use Editor tools: Despite the availability of automatic error prevention tools for coding, it seems developers pay less interest in adopting such tool. Automatic error prevention tools are the good way to guarantee syntax error free code.
Continue......
No comments:
Post a Comment