Site Loader
Rock Street, San Francisco

AbstractThis article will helpout to understand the bugs and debugging techniques with useful debugging techniques,during and after the development of software.

In this article we will analysisdifferent bugs specification with its removal techniques.IntroductionSoftware developmentprocedure complete with different steps debugging is one of it. Efforts andabilities make the software able to process the task but if software havingbugs all the effort will be useless and abilities will be not honored. In thisdiscussion will try to draw the importance of software debugging and its consequences.Debugging is to remove the bugs of software but most important to know what arebugs and how could be prevent rate to remove.

Best services for writing your paper according to Trustpilot

Premium Partner
From $18.00 per page
4,8 / 5
4,80
Writers Experience
4,80
Delivery
4,90
Support
4,70
Price
Recommended Service
From $13.90 per page
4,6 / 5
4,70
Writers Experience
4,70
Delivery
4,60
Support
4,60
Price
From $20.00 per page
4,5 / 5
4,80
Writers Experience
4,50
Delivery
4,40
Support
4,10
Price
* All Partners were chosen among 50+ writing services by our Customer Satisfaction Team

This is all about, what is bug,how and where it could be recognize and what are the tools and techniques toremove the bugs.”Debugging is theprocedure to find and reduce the number of bugs in computer programming orsoftware.” Criteria and acceptanceof bugs vary from person to person or organization according to theirrequirement. There may be a bug for someone but not for other one for example aperson required calculation while using software but the software’s calculatornot working well it means software having defect whereas other person not needof calculation while using software, if its calculator not working well, it isnot defect for him.

Needof Debugging Research:Research andinvestigation are important participants of improvement of any matter as wellas software debugging and testing. Software is major part of every filed of ITand without and research and innovation in software engineering is not possibleto go ahead and it is possible if worked on new ideas and innovation andwithout research it is not possible.Bugsand Debugging concepts:Since the softwareengineering and programming start error problem start as well and differenttechniques adopted to remove these bugs. Problems of software running and itsabilities to achieve remained the topic of IT experts with the acknowledgment.

Mostimportant about the debugging is to know about the bugs i.e. categories andclassification of bugs.  If the developerare mature and having good experience of programming could be develop flawlessprogram which having no need of debugging and review whereas if developerhaving poor hand on programming, leave the bugs while developing program whichneed to care off to compete the market. In this situation firstly we have tofind out the bugs in the code of program. There is proper quality assurerrequired to find out the bugs.

After finding the bugs has to know the type ofbug i.e. syntactical error, build error or semantic error. At this point knowabout the defect removal and its importance in the program. “Purpose of debuggingto locate and fix the offending code responsible to violate the specificationrequired.

“A good compilercan do some static analysis onthe code. Static code analysis is the analysis of software that is performedwithout actually executing programs built from that software. Static analysiscan help in detecting a number of basic semantic problems, e.g. type mismatchor dead code. Having a look at the user manual of the compiler employed, whereall the features should be documented, is highly recommended. For gcc,the standard compiler on GNU/Linux systems, there are a number of options thataffect what static analysis can be performed. They are usually divided into twoclasses: warning options and optimization flags “Debugging isthe procedure to remove unwanted codes in programming along with bugs i.

e. notmeets the specification and goals of software.” Debugging isbasically taking care under three steps.First stagestarted when a programmer developing software and doing coding. This stage isinitial stage to take care the software codes and other things. Without theknowledge of debugging a programming will not develop proper software or code.

Programmershould familiar with debugging techniques before developing and if s/he knowsthe developed software will be flawless or have little mistakes whereas if s/henot familiar the result will be annoying or may be unacceptable so the softwaredeveloper having ability to ensure quality will be a successful programmer. Inthe developed era of software engineering Integrated Development Environment(IDEs) used to develop the software which helps out to capture the bugs anderrors in the software structure.Second stage ofdebugging is where when software developer reviews his written codes anddevelopment. This stage is also belongs to the developer where the review theirwritten codes or developed product as per his/her expertise and find out theerrors and blocks and remove these bugs to finalize the product for test. Thisstage also very crucial about the ability of developer to remove the bugsbecause to find the error from the own written codes and formulas is muchdifficult rather the other one.Third stage is aprocess to start test of developed software and for final confirmation and toallow him for final launching. Under test procedure software has to pass thetough scrutiny under the supervision of Software developer along qualityensurer.

It is the final stage where all errors and bugs have to removeotherwise has to face claim against this software. Under this stage it ischecked undesirable behavior of software, unexpected result, inadequateperformance, failure under workload, found offending codes need to fix, exposedunder any other weakness. This process may also be called “problemdetermination” due to the enlarged scope of the analysis required before thedefect can be localized.Softwaredebugging is well known among software engineers, locating a defect takes themost effort in debugging. Debugging during the coding process is at thesmallest granularity. In the early years of software development, defects thatescaped code reviews were found by compilation and execution.

Through a painfulprocess (such as inserting print statements for the known outputs at theappropriate places in the program), a programmer could locate the exactlocation of the error and find a suitable fix. Even today, debugging remainsvery much an art. Much of the computer science community has largely ignoredthe debugging problem. The two biggestcauses of bugs were memory overwrites and defects in vendor supplied hardwareor software.

To help the software engineers in the debugging of the programduring the coding process, many new approaches have been proposed and manycommercial debugging environments are available. Integrated Development Environments(IDEs) provide a way to capture some of the language specific predeterminederrors (e.g., missing end of statement characters, undefined variables, and soon) without requiring compilation. One area that has caught the imagination ofthe industry is the visualization of the necessary underlying programmingconstructs as a means to analyze a program. There is also considerable work in tryingto automate the debugging process through program slicing. When the testing ofsoftware results in a failure and the test case is analyzed to be not thesource of the problem, debugging of the program follows and the required fix isdetermined.

Debugging during testing still remains manual, by and large,despite advances in test execution technology. There is a clear need for astronger link between test creation and test execution processes in order tominimize the pain involved here. Debugging in production or deployment is verycomplicated. Short of using some advanced problem determination techniques forlocating the specific defect or deficiency that led to the unexpected behavior,this debugging can be painful, time consuming and very expensive. When this involvesmultiple software products and critical interdependencies, with no easy way tonarrow down location of the offending code, this is a real nightmare. As thedebugging moves away from the source code, it becomes even more manual and timeconsuming.

 In early age ofsoftware development there was lot of problems to find out the bugs andultimately bugs were found the stage of test. Find bugs while coding wasapproximately not possible. With the development of technology; developerbecame able to find out their mistakes with taking prints of the specific coderof error and fix it. Even today debugging is most difficult process of softwareengineering and a big portion of software error remain unsolved even afterproper and expensive effort of well aware programmers whereas some ignore theseerrors which cause to major problem later. There are some technologiesavailable to find bugs i.e. promela, SDL etc. but these are used at lower leveland small organization to find the bugs whereas large organization believe onwell organization partitions and techniques to find and remove the bugs.

   Verification: Verification ofthe process to find out the correction and debugging made in software areworking. Historically, software verification has had little impact on thereal world. Despite the plethora of specification and verification technologies(described above), the problem has been applying these techniques and theoriesto full-scale real-world programs. Any fully-detailed specification must, byits very nature, be as complex as the actual program. Any simplification orabstraction may hide details that may be critical to the correct operation ofthe program.

Similarly, any proof system that can automatically verify a real programmust be able to handle very complex logical analyses, some of which areformally indecisive. The use of complex theorem proving systems also requireshigh skills and does not scale to large programs. The human factor also entersinto the equation: crafting a correct specification (especially one using anobscure formal system) is often much more difficult than writing the programbeing proved (even one written in an obscure programming language) 20. Todate, success in program verification has come in restricted domains whereeither the state space of the problem is constrained or only a portion of theprogram is actually verified. General theorem proves, model checkers, statemachine analyzers, and tools customized to particular applications have allbeen used to prove such systems.

 TestingTo test the software validity software testing is importantpart. Code review, design review, structure proofing and required specificationreview are parts of software testing. Testing is having various stages and itis an external process and don later i.e. after development .

However testing ispreferred process which show the software satisfy the customer requirements.There are different techniques to test the software validity i.e. white boxtesting black box testing. Make sure the customer requirement and acceptancewhile testing. In testing sample of software tested instead of whole softwarewhere possible bugs could be found. If the internal coding and structure foundaccording the requirement it is called test is successful otherwise test wouldbe called failed. The result of testing doesn’t mean the software is successfulor not whereas the result shows that where are the weaknesses in the structureand if possible could be amended.

There are different technologies used to test the software i.e.i.                   Test Metricsii.                 Static Testing Source Code Analysisiii.               Test Automationiv.

               Regression TestingThere is a question when should stop the testing, indeed when weshould insured about no more bugs. Metrics used24 during the testing process that target defect discovery and code size areproduct/release size over time, defect discovery rate over time, defect backlogover time, and so on. Some practical metrics that characterize the testing processare test progress over time (plan, attempted, actual), percentage of test casesattempted, etc. In some organizations, the uses of test coverage metrics areused to describe the thoroughness of the testing effort.

 Sourcecode analysis is well developed source code analysis branch under which codesof software analysis and find out the current and potential error in thesoftware’s code. In which find out the target code is available in thestructure and at the accurate place. The benefit of source code analysis, youwill aware about the code’s structure in the software and its weaknesses for futurereferences and development and it should be done before the final version ofsoftware. In the modern era of software engineer compiler perform this duty tofind out the incorrect codes and mark them for debugging and future reference. Underthe test automation four procedures are adopted to complete the test automationi.e. test design, test creation, test execution and debugging if bugs found. Dueto somehow inefficiency of manual testing system automation testing is beingadopted by the large organization speedily whereas complexity of automation is barriersomewhere to adopt it.

In the case of testing that requires explicit use ofgraphical user interfaces, the automation of the test execution has alreadyproduced major productivity gains across the industry. There are a number ofcommercial and research test tools available in the industry. A formaldescription required to automate the design test of specification of softwarebehavior resulting in model of software behavior. As the massive use of UnifiedModeling Languages (UML) as a designed language provide opportunity for thetechniques which are widely used to capture the more formal descriptions.

Post Author: admin

x

Hi!
I'm Eric!

Would you like to get a custom essay? How about receiving a customized one?

Check it out