Site Loader
Rock Street, San Francisco

Abstract

This article will help
out to understand the bugs and debugging techniques with useful debugging techniques,
during and after the development of software. In this article we will analysis
different bugs specification with its removal techniques.

We Will Write a Custom Essay Specifically
For You For Only $13.90/page!


order now

Introduction

Software development
procedure complete with different steps debugging is one of it. Efforts and
abilities make the software able to process the task but if software having
bugs all the effort will be useless and abilities will be not honored. In this
discussion 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 are
bugs and how could be prevent rate to remove. This is all about, what is bug,
how and where it could be recognize and what are the tools and techniques to
remove the bugs.

“Debugging is the
procedure to find and reduce the number of bugs in computer programming or
software.”

 

Criteria and acceptance
of bugs vary from person to person or organization according to their
requirement. There may be a bug for someone but not for other one for example a
person required calculation while using software but the software’s calculator
not working well it means software having defect whereas other person not need
of calculation while using software, if its calculator not working well, it is
not defect for him.

Need
of Debugging Research:

Research and
investigation are important participants of improvement of any matter as well
as software debugging and testing. Software is major part of every filed of IT
and without and research and innovation in software engineering is not possible
to go ahead and it is possible if worked on new ideas and innovation and
without research it is not possible.

Bugs
and Debugging concepts:

Since the software
engineering and programming start error problem start as well and different
techniques adopted to remove these bugs. Problems of software running and its
abilities to achieve remained the topic of IT experts with the acknowledgment. Most
important about the debugging is to know about the bugs i.e. categories and
classification of bugs.  If the developer
are mature and having good experience of programming could be develop flawless
program which having no need of debugging and review whereas if developer
having poor hand on programming, leave the bugs while developing program which
need to care off to compete the market. In this situation firstly we have to
find out the bugs in the code of program. There is proper quality assurer
required to find out the bugs. After finding the bugs has to know the type of
bug i.e. syntactical error, build error or semantic error. At this point know
about the defect removal and its importance in the program.

“Purpose of debugging
to locate and fix the offending code responsible to violate the specification
required.”

A good compiler
can do some static analysis on
the code. Static code analysis is the analysis of software that is performed
without actually executing programs built from that software. Static analysis
can help in detecting a number of basic semantic problems, e.g. type mismatch
or dead code. Having a look at the user manual of the compiler employed, where
all the features should be documented, is highly recommended. For gcc,
the standard compiler on GNU/Linux systems, there are a number of options that
affect what static analysis can be performed. They are usually divided into two
classes: warning options and optimization flags

 

“Debugging is
the procedure to remove unwanted codes in programming along with bugs i.e. not
meets the specification and goals of software.”

 

Debugging is
basically taking care under three steps.

First stage
started when a programmer developing software and doing coding. This stage is
initial stage to take care the software codes and other things. Without the
knowledge of debugging a programming will not develop proper software or code. Programmer
should familiar with debugging techniques before developing and if s/he knows
the developed software will be flawless or have little mistakes whereas if s/he
not familiar the result will be annoying or may be unacceptable so the software
developer having ability to ensure quality will be a successful programmer. In
the developed era of software engineering Integrated Development Environment
(IDEs) used to develop the software which helps out to capture the bugs and
errors in the software structure.

Second stage of
debugging is where when software developer reviews his written codes and
development. This stage is also belongs to the developer where the review their
written codes or developed product as per his/her expertise and find out the
errors and blocks and remove these bugs to finalize the product for test. This
stage also very crucial about the ability of developer to remove the bugs
because to find the error from the own written codes and formulas is much
difficult rather the other one.

Third stage is a
process to start test of developed software and for final confirmation and to
allow him for final launching. Under test procedure software has to pass the
tough scrutiny under the supervision of Software developer along quality
ensurer. It is the final stage where all errors and bugs have to remove
otherwise has to face claim against this software. Under this stage it is
checked undesirable behavior of software, unexpected result, inadequate
performance, failure under workload, found offending codes need to fix, exposed
under any other weakness. This process may also be called “problem
determination” due to the enlarged scope of the analysis required before the
defect can be localized.

Software
debugging is well known among software engineers, locating a defect takes the
most effort in debugging. Debugging during the coding process is at the
smallest granularity. In the early years of software development, defects that
escaped code reviews were found by compilation and execution. Through a painful
process (such as inserting print statements for the known outputs at the
appropriate places in the program), a programmer could locate the exact
location of the error and find a suitable fix. Even today, debugging remains
very much an art. Much of the computer science community has largely ignored
the debugging problem.

The two biggest
causes of bugs were memory overwrites and defects in vendor supplied hardware
or software. To help the software engineers in the debugging of the program
during the coding process, many new approaches have been proposed and many
commercial debugging environments are available. Integrated Development Environments
(IDEs) provide a way to capture some of the language specific predetermined
errors (e.g., missing end of statement characters, undefined variables, and so
on) without requiring compilation. One area that has caught the imagination of
the industry is the visualization of the necessary underlying programming
constructs as a means to analyze a program. There is also considerable work in trying
to automate the debugging process through program slicing. When the testing of
software results in a failure and the test case is analyzed to be not the
source of the problem, debugging of the program follows and the required fix is
determined. Debugging during testing still remains manual, by and large,
despite advances in test execution technology. There is a clear need for a
stronger link between test creation and test execution processes in order to
minimize the pain involved here. Debugging in production or deployment is very
complicated. Short of using some advanced problem determination techniques for
locating the specific defect or deficiency that led to the unexpected behavior,
this debugging can be painful, time consuming and very expensive. When this involves
multiple software products and critical interdependencies, with no easy way to
narrow down location of the offending code, this is a real nightmare. As the
debugging moves away from the source code, it becomes even more manual and time
consuming.

 

In early age of
software development there was lot of problems to find out the bugs and
ultimately bugs were found the stage of test. Find bugs while coding was
approximately not possible. With the development of technology; developer
became able to find out their mistakes with taking prints of the specific coder
of error and fix it. Even today debugging is most difficult process of software
engineering and a big portion of software error remain unsolved even after
proper and expensive effort of well aware programmers whereas some ignore these
errors which cause to major problem later. There are some technologies
available to find bugs i.e. promela, SDL etc. but these are used at lower level
and small organization to find the bugs whereas large organization believe on
well organization partitions and techniques to find and remove the bugs.

 

 

 

Verification:

 

Verification of
the process to find out the correction and debugging made in software are
working.

 

Historically, software verification has had little impact on the
real world. Despite the plethora of specification and verification technologies
(described above), the problem has been applying these techniques and theories
to full-scale real-world programs. Any fully-detailed specification must, by
its very nature, be as complex as the actual program. Any simplification or
abstraction may hide details that may be critical to the correct operation of
the program. Similarly, any proof system that can automatically verify a real program
must be able to handle very complex logical analyses, some of which are
formally indecisive. The use of complex theorem proving systems also requires
high skills and does not scale to large programs. The human factor also enters
into the equation: crafting a correct specification (especially one using an
obscure formal system) is often much more difficult than writing the program
being proved (even one written in an obscure programming language) 20. To
date, success in program verification has come in restricted domains where
either the state space of the problem is constrained or only a portion of the
program is actually verified. General theorem proves, model checkers, state
machine analyzers, and tools customized to particular applications have all
been used to prove such systems.

 

Testing

To test the software validity software testing is important
part. Code review, design review, structure proofing and required specification
review are parts of software testing. Testing is having various stages and it
is an external process and don later i.e. after development .However testing is
preferred process which show the software satisfy the customer requirements.
There are different techniques to test the software validity i.e. white box
testing black box testing. Make sure the customer requirement and acceptance
while testing. In testing sample of software tested instead of whole software
where possible bugs could be found. If the internal coding and structure found
according the requirement it is called test is successful otherwise test would
be called failed. The result of testing doesn’t mean the software is successful
or not whereas the result shows that where are the weaknesses in the structure
and if possible could be amended.

There are different technologies used to test the software i.e.

i.                   
Test Metrics

ii.                 
Static Testing Source Code Analysis

iii.               
Test Automation

iv.               
Regression Testing

There is a question when should stop the testing, indeed when we
should insured about no more bugs. Metrics used
24 during the testing process that target defect discovery and code size are
product/release size over time, defect discovery rate over time, defect backlog
over time, and so on. Some practical metrics that characterize the testing process
are test progress over time (plan, attempted, actual), percentage of test cases
attempted, etc. In some organizations, the uses of test coverage metrics are
used to describe the thoroughness of the testing effort.

 

Source
code analysis is well developed source code analysis branch under which codes
of software analysis and find out the current and potential error in the
software’s code. In which find out the target code is available in the
structure and at the accurate place. The benefit of source code analysis, you
will aware about the code’s structure in the software and its weaknesses for future
references and development and it should be done before the final version of
software. In the modern era of software engineer compiler perform this duty to
find out the incorrect codes and mark them for debugging and future reference.

 

Under
the test automation four procedures are adopted to complete the test automation
i.e. test design, test creation, test execution and debugging if bugs found. Due
to somehow inefficiency of manual testing system automation testing is being
adopted by the large organization speedily whereas complexity of automation is barrier
somewhere to adopt it. In the case of testing that requires explicit use of
graphical user interfaces, the automation of the test execution has already
produced major productivity gains across the industry. There are a number of
commercial and research test tools available in the industry. A formal
description required to automate the design test of specification of software
behavior resulting in model of software behavior. As the massive use of Unified
Modeling Languages (UML) as a designed language provide opportunity for the
techniques 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