Determining Effectiveness Of Code Through Specification

Published Date: 02 Nov 2017

Determining Effectiveness of Code Through

Specification MiningABSTRACT: To find the bugs from any software, specifications are essential task which will increase the quality of code. For program testing formal specifications can help, also it can help with testing, optimization, refactoring, documentation, debugging and repair. It is difficult task to write specification manually and automatic mining techniques suffer from 90–99% false positive rates. To focus this problem, we propose a miner by incorporating code quality metrics. We measure a code quality by using different quality metrics and complexity metrics which improve the effectiveness of the code. Because of this technique manual inspection burden is minimised.

INTRODUCTION

Deployment of incorrect software were increases the cost of software. Also debugging, testing, maintaining, documenting software take so much amount of time. Modifying existing code, correcting defects, and otherwise evolving software are major parts of maintenance [1], which is reported to consume up to 90% of the total cost of software projects [2]. It is difficult to find out any software without bugs. Our aim to avoid the bugs from the software but it is not possible so we can use technique to detect the bugs and correct them. Currently testing is the defect detection method but it is very inconvenient and incurs high cost. Small specifications can be debugged by inspection. Complicated formal specifications are debugged by testing it. Programmers use the program verification tool to test the specification against the programs. Programming error can’t be prevented by the program verification tool. Verification tool only indicate the discrepancy between the program code and specification. Writing the code is the initial footstep of creating a software system. Maximum cost of a software project is committed to modifying existing code, detecting and correcting errors, and generally evolving a code base. By using implicit language based specification we can reduce the cost of specification writing. Incomplete documentation is one of the factor for maintenance difficulty. Maximum time span is spent for the studying existing software and understand the correct behaviour. Formal specifications are difficult for humans to construct [3], and incorrect specifications are difficult for humans to debug and modify [4]. Specification mining projects attempt to address these problems by inferring specifications from program source code or execution traces [5,6]. In our method tool finds the different factors in program code and present the results by comparison. We have applied our technique to mark out from genuine system and used the revealed properties to find previously unknown defects.

RELATED WORK

Specification Mining

This methodology presents a new automatic specification miner that uses artifacts from software engineering processes to capture the reliability of its input traces.

The major hand-outs of this approach are:

– A set of source-level features related to software engineering processes that capture the dependability of code for specification mining. We analyze the relative analytical power of each of these features.

– Experimental evidence that our notions of trustworthy code serve as a basis for evaluating the dependability of traces. We provide a characterization for such traces and show that off- the-shelf specification miners can learn just as many specifications using only 60% of traces.

– A novel automatic mining technique that uses our trust-capturing features to learn temporal safety specifications with few false positives in practice. We evaluate it on over 800,000 lines of code and explicitly compare it to two earlier approaches. Our basic mining technique learns specifications that locate more safety violations than previous miners, while presenting far fewer false positive specifications.

When focused on precision, our technique obtains a low false positive rate than previous miners, an order-of-magnitude improvement on previous work, while at a standstill finding specifications that trace 265 violations. To our understanding, this is the first specification miner that produces multiple candidate specifications and has a false positive rate under 90%.

In this approach present a specification miner that works

in three stages:

Statically estimate the dependability of each code

fragment.

Lift that opinion to traces by considering the code

visited along a trace.

Weight the contribution of each trace by its

trustworthiness when counting event frequencies for

specification mining.

The code is most trustworthy when it has been written by experienced programmers who are familiar with the project at hand, when it has been well-tested, and when it has been mindfully written.

Mining Temporal Specification

If we use implicit language-based specifications (e.g., null pointers should not be dereferences) or to reuse standard library specifications then it can reduce the cost of writing specifications. More recently, however, a variety of attempts have been made to conclude program-specific temporal specifications and API usage rules automatically. These specification mining techniques take programs (and possibly dynamic traces, or other hints) as input and produce candidate specifications as output. Basically specifications could also be used for documenting, refactoring, debugging, testing, maintaining and optimizing a program. Centre of attention is that finding and evaluating specifications in a particular context: given a program and a generic verification tool, what specification mining technique should be used to find bugs in the program and thereby improve software quality. Thus we are concerned both with the number of "real" and "copied positive" specifications produced by the miner and with the number of "real" and "copied positive" bugs found using those "real" specifications.

In this methodology propose a novel technique for temporal specification mining that uses information about program error handling. Our miner assumes that programs will generally adhere to specifications along normal execution paths, but that programs will likely violate specifications in the presence of some run-time errors or exceptional situations. Intuitively, error-handling code may not be tested as often or the programmer may be unaware of sources of run-time errors. Taking advantage of this information is more important than ranking candidate policies.

Programmers often make mistakes in exceptional circumstances or along uncommon code paths those observations are used to recommend a novel specification mining technique. Present a qualitative comparison of five miners and show how some miner assumptions are not well-supported in practice.

Lastly, we give a quantitative comparison of our technique’s bug-finding powers to generic "library" policies. For our domain of interest, mining finds 250 more bugs.[17] We also show the relative unimportance of ranking candidate policies. In all, we find 69 specifications that lead to the discovery over 430 bugs in 1 million lines of code. [17]

ACTUAL WORK DONE

In proposed method, our aim to develop a system which can be used to measure the quality of the code considering different aspects affecting the quality of the code. The term quality of the code can be explained using different factors such as code clone, author rank, code churn, code readability, path feasibility etc. To present a new specification miner that works in three steps. First, it statically estimates the source code fragments quality. Second, it assuming those quality judgments to traces by considering all code visited along a suggestion. Finally, it weights each trace by its quality when counting event frequencies for specification mining.

This system develops an automatic specification miner that balances true positives as required behaviours with false positives non-required behaviours. We claim that one important reason that previous miners have high false positive rates is that they falsely assume that all code is equally likely to be acceptable. For example, consider an implementation trace through in recent time’s modified, rarely-executed part of code that was copied and-pasted by an inexperienced developer. We believe that such a mark out is a poor guide to correct behaviour, especially when compared with a well tested, commonly-executed and stable piece of code. Patterns of specification adherence may also be useful to a miner, a candidate that is violated in the high quality code but adhered to in the low quality code is less likely to represent required behaviour than one that is adhered to on the high quality code but violated in the low quality code. We assert that a combination of lightweight, automatically collected quality metrics over source code can usefully provide both positive and negative feedback to a miner attempting to distinguish between true and false specification candidates.

Code quality information may be gathered either from the source code itself or from related artifacts, such as version control history. By augmenting the trace language to include information from the software engineering process, we can evaluate the quality of every piece of information supporting a candidate specification (traces that adhere to a candidate as well as those that violate it and both high and low quality code) on which it is followed and more accurately evaluate the likelihood that it is valid. The system architecture of the system is as in following figure, which explains the modules to be generated.

Fig. System Architecture

Explanation of system

Proposed system for determining effectiveness of code

through specification mining uses the various stages in this technique 1. Accept input in the form of computer program code.

2. Perform input purification.

3. Check for error occurrence in the code.

4. Check for the quality specification regarding the

given code.

5. Specify the rank for the different condition, using

calculated result.

6. Generate output in the form of quality report

FEASIBILITY STUDY:

1. Technical feasibility:

Technical feasibility deals with the study of function, performance and constraints like resources, availability, technology, development risk that may affect the ability to achieve an acceptable system.

It defines whether the work can be done, whether technology used is compatible or not with current system. Since the web based service will be developed using ASP.net, it is platform independent.

The technical issues investigated during the study are as under:-

The technology for implementation of the project system is readily available.

The system is capable of expansion.

The proposed system provides adequate accuracy, reliability and data security.

Here we have used .net technology, that is feasible for implementation of the project and in this technology we can make expansion as per future scope of the project. The proposed system has adequate accuracy & is securable.

2. Economic feasibility:

One of the factors, which affect the development of a new system, is the cost it would incur. The existing resources available are sufficient for implementing the proposed system and hence some cost has to be incurred to upload the service on the server.

3. Behavioral feasibility:

The web based service is found to be

Efficient

Time saving

Accurate

Secure and reliable

4. Operational feasibility:

There is no difficulty in implementing the web based service, if the user has the knowledge in internal working of the service. Therefore, it is assumed that he will not face any problem in running the service. The main problem faced during development if a new web based service is getting acceptance from the users.

CRITERIA FOR METRIC EVALUATION

Software metrics should posses to enlarge their usefulness according to the several researchers. Basili and Reiter suggest that metrics should be aware to externally noticeable disparity in the development environment. They also correspond to a intuitive notions about the characteristics difference between the software artifacts being measured [19].

The majority of recommended properties are quantitative in nature and as a result, most proposals for metrics have tended to be informal in their evaluation in metrics.

Reliable with the desire to move metric research into a more precise footing, it is advantageous to have a formal set of criteria with which to evaluate proposed metrics. More recently, Weyunker has developed a formal list of desiderata for software metric and has evaluated a number of existing software metrics using these properties. These desiderata notion of monotonicity, interaction, noncoarseness, nonuniqueness, and permutation.

TESTING METHODOLOGY

The complexity measure is designed to conform to our intuitive notion of complexity and since we often spend as much as 50 percent of our time in test and debug mode the measure should correlate closely with the amount of work required to test a program. In this section the relationship between testing and cyclomatic complexity will be defined and a testing methodology will be developed.

Let us assume that a program p has been written, its complexity v has been calculated, and the number of paths tested is ac (actual complexity). If ac is less than v then one of the following conditions must be true :

1) there is more testing to be done

2) the program flow graph can be reduced in complexity by

v-ac and

3) portions of the program can be reduced to in line code

Up to this point the complexity issue has been considered

purely in terms of the structure of the control flow. This

testing issue, however, is closely related to the data flow because it is the data behavior that either precludes or makes

realizable the execution of any particular control path. A

ADVANTAGES

1. This technique evaluate every line as per its importance not by its simple existence as part of the software code.

2. Measure quality of code by considering the significance, impact, importance.

CONCLUSION

Formal specifications have numerous applications, from testing, optimizing, refactoring, maintenance and documenting, to debugging and repair. However these formal specifications are difficult to produce manually. Our aim to produce better testing technique that finds defects in a program code. Specification mining for the finding bugs becomes more important, as specification becomes the restrictive factor in verification efforts. These specifications guide us to find out previously unknown bugs in large real world system. We found that this method is well-organized, both in provisions of machine resources and human resources. The result produced by our tool is understandable by human being easily, and also as accurate as what was generated by humans manually.