This document describes a method for modifying code clones using refactoring techniques. It discusses using the CloneManager tool to detect clones and then applying three refactoring patterns (extract method, move method, pull up method) to modify the clones. The approach is implemented as an enhancement to the CloneManager tool, allowing it to both detect clones and modify them using refactoring. The enhanced tool is tested on open source projects and results are compared to other clone detection tools.
Method-Level Code Clone Modification using Refactoring Techniques for Clone M...acijjournal
Researchers focused on activities such as clone maintenance to assist the programmers. Refactoring is a well-known process to improve the maintainability of the software. Program refactoring is a technique to improve readability, structure, performance, abstraction, maintainability, or other characteristics by transforming a program. This paper contributes to a more unified approach for the phases of clone maintenance with a focus on clone modification. This approach uses the refactoring technique for clone modification. To detect the clones ‘CloneManager’ tool has been used. This approach is implemented as an enhancement to the existing tool CloneManager. The enhanced tool is tested with the open source projects and the results are compared with the performance of other three existing tools.
This document describes the Hermes tool for creating representative benchmark corpora for evaluating code analyses. Hermes uses feature queries to identify the relevant technical features present in projects, and then selects a minimal subset of projects that maximally covers these features. This optimized corpus is more manageable for development and testing while still being comprehensive. The document provides examples of feature queries and how Hermes was used to reduce the corpus size for one evaluation from 100 to 5 projects, speeding up the evaluation significantly with only a small loss of coverage.
GENERIC CODE CLONING METHOD FOR DETECTION OF CLONE CODE IN SOFTWARE DEVELOPMENT IAEME Publication
The major part of risk the development of software orprograms is existence ofduplicate code that can affect the software maintainability. The main aim of Clone
identification technique is to search and detect the parts of the software code which is
identical. In the passed there are various techniques that are used to identify andreflect the code identity and code fragments.Code cloning reduces the time and effort of the softwaredeveloper but it alsodecreases the quality of the software like readability, changeability and increasesmaintainability. So, code clone has to be detected to reducethe cost of maintenance tosome extent. In this paper, a new Generic technique is purposed to detect code clone
from various input source codes (from web, disk and etc.,) by segmenting the code intonumber of sub-programs or modules or functions. I propose a technique that candetect 1-type,2type, 3-type and 4-type clones efficiently.
IRJET- Code Cloning using Abstract Syntax TreeIRJET Journal
The document presents an approach to detect code clones using abstract syntax trees (AST). Code cloning occurs when code is duplicated through copy-paste, increasing maintenance costs and the risk of bugs. The proposed approach first parses code into an AST, then applies algorithms to find identical and near-identical subtrees, code sequences, and more complex clones. Detecting clones using the AST approach allows identifying exact and near-miss clones in a way that is simpler than previous techniques but still powerful. Benefits of detecting and removing clones include reduced defects, maintenance costs, and improved code quality.
Improving modularity and reusability are two key objectives in object-oriented programming. These
objectives are achieved by applying several key concepts, such as data encapsulation and inheritance. A
class in an object-oriented system is the basic unit of design. Assessing the quality of an object-oriented
class may require flattening the class and representing it as it really is, including all accessible inherited
class members. Thus, class flattening helps in exploring the impact of inheritance on improving code
quality. This paper explains how to flatten Java classes and discusses the relationship between class
flattening and some applications of interest to software practitioners, such as refactoring and indicating
external quality attributes.
Open Problems in Automatically Refactoring Legacy Java Software to use New Fe...Raffi Khatchadourian
Java 8 is one of the largest upgrades to the popular language and framework in over a decade. In this talk, I will first overview several new, key features of Java 8 that can help make programs easier to read, write, and maintain, especially in regards to collections. These features include Lambda Expressions, the Stream API, and enhanced interfaces, many of which help bridge the gap between functional and imperative programming paradigms and allow for succinct concurrency implementations. Next, I will discuss several open issues related to automatically migrating (refactoring) legacy Java software to use such features correctly, efficiently, and as completely as possible. Solving these problems will help developers to maximally understand and adopt these new features thus improving their software.
Automated Refactoring of Legacy Java Software to Default Methods Talk at GMURaffi Khatchadourian
Java 8 default methods, which allow interfaces to contain (instance) method implementations, are useful for the skeletal implementation software design pattern. However, it is not easy to transform existing software to exploit default methods. In this talk, I discuss an efficient, fully-automated, type constraint-based refactoring approach that assists developers in taking advantage of enhanced interfaces for their legacy Java software.
- Java is a high-level programming language originally developed by Sun Microsystems and released in 1995. It runs on a variety of platforms such as Windows, Mac OS, and UNIX.
- The Java Virtual Machine (JVM) allows Java code to run on different platforms, as the bytecode is interpreted by the JVM rather than being compiled into platform-specific machine code.
- Some key features of Java include being object-oriented, platform independent, robust, interpreted, and multi-threaded.
Method-Level Code Clone Modification using Refactoring Techniques for Clone M...acijjournal
Researchers focused on activities such as clone maintenance to assist the programmers. Refactoring is a well-known process to improve the maintainability of the software. Program refactoring is a technique to improve readability, structure, performance, abstraction, maintainability, or other characteristics by transforming a program. This paper contributes to a more unified approach for the phases of clone maintenance with a focus on clone modification. This approach uses the refactoring technique for clone modification. To detect the clones ‘CloneManager’ tool has been used. This approach is implemented as an enhancement to the existing tool CloneManager. The enhanced tool is tested with the open source projects and the results are compared with the performance of other three existing tools.
This document describes the Hermes tool for creating representative benchmark corpora for evaluating code analyses. Hermes uses feature queries to identify the relevant technical features present in projects, and then selects a minimal subset of projects that maximally covers these features. This optimized corpus is more manageable for development and testing while still being comprehensive. The document provides examples of feature queries and how Hermes was used to reduce the corpus size for one evaluation from 100 to 5 projects, speeding up the evaluation significantly with only a small loss of coverage.
GENERIC CODE CLONING METHOD FOR DETECTION OF CLONE CODE IN SOFTWARE DEVELOPMENT IAEME Publication
The major part of risk the development of software orprograms is existence ofduplicate code that can affect the software maintainability. The main aim of Clone
identification technique is to search and detect the parts of the software code which is
identical. In the passed there are various techniques that are used to identify andreflect the code identity and code fragments.Code cloning reduces the time and effort of the softwaredeveloper but it alsodecreases the quality of the software like readability, changeability and increasesmaintainability. So, code clone has to be detected to reducethe cost of maintenance tosome extent. In this paper, a new Generic technique is purposed to detect code clone
from various input source codes (from web, disk and etc.,) by segmenting the code intonumber of sub-programs or modules or functions. I propose a technique that candetect 1-type,2type, 3-type and 4-type clones efficiently.
IRJET- Code Cloning using Abstract Syntax TreeIRJET Journal
The document presents an approach to detect code clones using abstract syntax trees (AST). Code cloning occurs when code is duplicated through copy-paste, increasing maintenance costs and the risk of bugs. The proposed approach first parses code into an AST, then applies algorithms to find identical and near-identical subtrees, code sequences, and more complex clones. Detecting clones using the AST approach allows identifying exact and near-miss clones in a way that is simpler than previous techniques but still powerful. Benefits of detecting and removing clones include reduced defects, maintenance costs, and improved code quality.
Improving modularity and reusability are two key objectives in object-oriented programming. These
objectives are achieved by applying several key concepts, such as data encapsulation and inheritance. A
class in an object-oriented system is the basic unit of design. Assessing the quality of an object-oriented
class may require flattening the class and representing it as it really is, including all accessible inherited
class members. Thus, class flattening helps in exploring the impact of inheritance on improving code
quality. This paper explains how to flatten Java classes and discusses the relationship between class
flattening and some applications of interest to software practitioners, such as refactoring and indicating
external quality attributes.
Open Problems in Automatically Refactoring Legacy Java Software to use New Fe...Raffi Khatchadourian
Java 8 is one of the largest upgrades to the popular language and framework in over a decade. In this talk, I will first overview several new, key features of Java 8 that can help make programs easier to read, write, and maintain, especially in regards to collections. These features include Lambda Expressions, the Stream API, and enhanced interfaces, many of which help bridge the gap between functional and imperative programming paradigms and allow for succinct concurrency implementations. Next, I will discuss several open issues related to automatically migrating (refactoring) legacy Java software to use such features correctly, efficiently, and as completely as possible. Solving these problems will help developers to maximally understand and adopt these new features thus improving their software.
Automated Refactoring of Legacy Java Software to Default Methods Talk at GMURaffi Khatchadourian
Java 8 default methods, which allow interfaces to contain (instance) method implementations, are useful for the skeletal implementation software design pattern. However, it is not easy to transform existing software to exploit default methods. In this talk, I discuss an efficient, fully-automated, type constraint-based refactoring approach that assists developers in taking advantage of enhanced interfaces for their legacy Java software.
- Java is a high-level programming language originally developed by Sun Microsystems and released in 1995. It runs on a variety of platforms such as Windows, Mac OS, and UNIX.
- The Java Virtual Machine (JVM) allows Java code to run on different platforms, as the bytecode is interpreted by the JVM rather than being compiled into platform-specific machine code.
- Some key features of Java include being object-oriented, platform independent, robust, interpreted, and multi-threaded.
The document discusses object oriented programming concepts related to packages, interfaces, and their implementation in Java. It defines what packages and interfaces are, how to create and access packages, differences between classes and interfaces, how to define and implement interfaces, and examples of applying packages and interfaces in Java code.
Java 8 is one of the largest upgrades to the popular language and framework in over a decade. This talk will detail several new key features of Java 8 that can help make programs easier to read, write, and maintain. Java 8 comes with many features, especially related to collection libraries. We will cover such new features as Lambda Expressions, the Stream API, enhanced interfaces, and more.
Defaultification Refactoring: A Tool for Automatically Converting Java Method...Raffi Khatchadourian
Enabling interfaces to declare (instance) method
implementations, Java 8 default methods can be used as a
substitute for the ubiquitous skeletal implementation software design
pattern. Performing this transformation on legacy software
manually, though, may be non-trivial. The refactoring requires
analyzing complex type hierarchies, resolving multiple implementation
inheritance issues, reconciling differences between class
and interface methods, and analyzing tie-breakers (dispatch
precedence) with overriding class methods. All of this is necessary
to preserve type-correctness and confirm semantics preservation.
We demonstrate an automated refactoring tool called MIGRATE
SKELETAL IMPLEMENTATION TO INTERFACE for transforming
legacy Java code to use the new default construct. The tool,
implemented as an Eclipse plug-in, is driven by an efficient,
fully-automated, type constraint-based refactoring approach. It
features an extensive ruleset covering various corner-cases
where default methods cannot be used. The resulting code is
semantically equivalent to the original, more succinct, easier to
comprehend, less complex, and exhibits increased modularity. A
demonstration can be found at http://youtu.be/YZHIy0yePh8.
An Empirical Study of Refactorings and Technical Debt in Machine Learning Sys...Raffi Khatchadourian
Machine Learning (ML), including Deep Learning (DL), systems, i.e., those with ML capabilities, are pervasive in today’s data-driven society. Such systems are complex; they are comprised of ML models and many subsystems that support learning processes. As with other complex systems, ML systems are prone to classic technical debt issues, especially when such systems are long-lived, but they also exhibit debt specific to these systems. Unfortunately, there is a gap of knowledge in how ML systems actually evolve and are maintained. In this paper, we fill this gap by studying refactorings, i.e., source-to-source semantics-preserving program transformations, performed in real-world, open-source software, and the technical debt issues they alleviate. We analyzed 26 projects, consisting of 4.2 MLOC, along with 327 manually examined code patches. The results indicate that developers refactor these systems for a variety of reasons, both specific and tangential to ML, some refactorings correspond to established technical debt categories, while others do not, and code duplication is a major cross-cutting theme that particularly involved ML configuration and model code, which was also the most refactored. We also introduce 14 and 7 new ML-specific refactorings and technical debt categories, respectively, and put forth several recommendations, best practices, and anti-patterns. The results can potentially assist practitioners, tool developers, and educators in facilitating long-term ML system usefulness.
20 most important java programming interview questionsGradeup
The document discusses 20 important Java programming interview questions. It covers topics such as the differences between interfaces and abstract classes, when to use abstract classes versus interfaces, what the Serializable interface does, how to force garbage collection, the differences between StringBuffer and StringBuilder, checked and unchecked exceptions, how Java allocates stack and heap memory, Java reflection, the Java Virtual Machine, the differences between JDK and JRE, and more.
A hybrid model to detect malicious executablesUltraUploader
This document presents a hybrid model for detecting malicious executables that uses three types of features: binary n-grams extracted from executable files, assembly n-grams extracted from disassembled executables, and DLL function calls extracted from program headers. A classifier like SVM is trained on the combined "hybrid feature set" to distinguish between benign and malicious executables. The model achieves high detection accuracy and low false positive rates compared to other feature-based approaches.
Laleh M. Eshkevari defended her Ph.D dissertation on developing techniques for the automatic detection and classification of identifier renamings in software projects. Her dissertation outlined a taxonomy of renamings, described approaches for renaming detection based on line mapping, entity mapping and data flow analysis, and discussed methods for classifying renamings based on their form and semantic changes. Evaluation of the approaches on several open source projects showed high precision and recall for renaming detection and identified trends in how renamings are used in practice.
Specification-based Verification of Incomplete ProgramsIDES Editor
Recently, formal methods like model checking or
theorem proving have been considered efficient tools for
software verification. However, when practically applied, those
techniques suffer high complexity cost. Combining static
analysis with dynamic checking to deal with this problem has
been becoming an emerging trend, which results in the
introduction of concolic testing technique and its variations.
However, the analysis-based verification techniques always
assume the availability of full source code of the verified
program, which does not always hold in real life contexts. In
this paper, we propose an approach to tackle this problem,
where our contributed ideas are (i) combining function
specification with control flow analysis to deal with sourcemissing
function; (ii) generating self-complete programs from
incomplete programs by means of concrete execution, thus
making them fully verifiable by model checking; and (iii)
developing a constraint-based test-case generation technique
to significantly reduce the complexity. Our solution has been
proved viable when successfully deployed for checking
programming work of students.
EEE oops Vth semester viva questions with answerJeba Moses
1. An object is the basic unit of object-oriented programming and represents an instance of a class. Objects have unique names and can hold their own data.
2. A class defines a collection of similar objects. Instances are objects created from classes through a process called instantiation.
3. Object-oriented programming organizes programs around objects and a set of well-defined interfaces to access object data. Data is encapsulated within classes and accessed through member functions.
Design and Implementation of Hybrid Test Automation Framework for Web Based A...AM Publications
There many ways to create Web application UI Test Automation Framework. This paper elaborates the creation of the Hybrid Test Automation Framework, and explains the architecture and design of the framework. This Framework is easy to use and incorporate the use of high level programming language allowing object oriented design, permits low level access to the UL components and recover quickly for UI changes in the application under test. The architecture of the framework as multi layer design which isolates the browser UI compounds and test scripts. This Framework Architecture is a merged combination of Library and Data Driven Test Automation Framework. This Framework contents multi packages with classes which isolates the reusable functions and involves the external database on fetching the data. In this framework we can execute the same test case repeatedly in a loop to handle different test input which is retrieved from the database.
Mining Fix Patterns for FindBugs ViolationsDongsun Kim
Several static analysis tools, such as Splint or FindBugs, have been proposed to the software development community to help detect security vulnerabilities or bad programming practices. However, the adoption of these tools is hindered by their high false positive rates. If the false positive rate is too high, developers may get acclimated to violation reports from these tools, causing concrete and severe bugs being overlooked. Fortunately, some violations are actually addressed and resolved by developers. We claim that those violations that are recurrently fixed are likely to be true positives, and an automated approach can learn to repair similar unseen violations. However, there is lack of a systematic way to investigate the distributions on existing violations and fixed ones in the wild, that can provide insights into prioritizing violations for developers, and an effective way to mine code and fix patterns which can help developers easily understand the reasons of leading violations and how to fix them.
In this paper, we first collect and track a large number of fixed and unfixed violations across revisions of software. The empirical analyses reveal that there are discrepancies in the distributions of violations that are detected and those that are fixed, in terms of occurrences, spread and categories, which can provide insights into prioritizing violations. To automatically identify patterns in violations and their fixes, we propose an approach that utilizes convolutional neural networks to learn features and clustering to regroup similar instances. We then evaluate the usefulness of the identified fix patterns by applying them to unfixed violations. The results show that developers will accept and merge a majority (69/116) of fixes generated from the inferred fix patterns. It is also noteworthy that the yielded patterns are applicable to four real bugs in the Defects4J major benchmark for software testing and automated repair.
Top 10 Interview Questions for Java watch this PPT and you will find out the most frequently asked questions in the technical interviews.
Call Now For Catia Training, Projects and Report :- 95698-06826, 0172-4183134
Website:- www.emetechnologies.com
Java Training in Mohali | Chandigarh
6 Months Java Industrial Training in Mohali | Chandigarh
Java Summer Training in Mohali | Chandigarh
This document discusses primitive data types, variables, classes, methods, constructors, and interfaces in Java. It provides details on the different primitive data types including their sizes and ranges. It describes how variables store values of a particular type. It outlines the syntax for class declarations including fields, methods, and constructors. It also covers method overloading, overriding, and parameter passing. Finally, it summarizes interfaces and how they define requirements for classes to implement.
Offline Handwritten Thai Character Recognition Using Single Tier Classifier a...Ferdin Joe John Joseph PhD
1) The document presents a methodology for offline handwritten Thai character recognition using local binary pattern (LBP) features and shape matrices.
2) An experiment was conducted using 4,400 handwritten Thai character images from 44 classes to test different LBP types and shape matrix sizes.
3) The results found that uniform rotation invariant LBP achieved the highest accuracy of 68.96% and a shape matrix size of 12x12 bits performed best.
Bug fixing is a time-consuming and tedious task. To reduce the manual efforts in bug fixing, researchers have pre- sented automated approaches to software repair. Unfortunately, recent studies have shown that the state-of-the-art techniques in automated repair tend to generate patches only for a small number of bugs even with quality issues (e.g., incorrect behavior and nonsensical changes). To improve automated program repair (APR) techniques, the community should deepen its knowledge on repair actions from real-world patches since most of the techniques rely on patches written by human developers. Previous investigations on real-world patches are limited to statement level that is not sufficiently fine-grained to build this knowledge. In this work, we contribute to building this knowledge via a systematic and fine-grained study of 16,450 bug fix commits from seven Java open-source projects. We find that there are opportunities for APR techniques to improve their effectiveness by looking at code elements that have not yet been investigated. We also discuss nine insights into tuning automated repair tools. For example, a small number of statement and expression types are recurrently impacted by real-world patches, and expression-level granularity could reduce search space of finding fix ingredients, where previous studies never explored.
FUNCTIONAL OVER-RELATED CLASSES BAD SMELL DETECTION AND REFACTORING SUGGESTIONSijseajournal
Bad phenomena about functional over-related classes and confused inheritances in programs will cause difficulty in programs comprehension, extension and maintenance. In this paper it is defined as a new bad smell Functional over-Related Classes. After the analysis, the characteristics of this new smell are transformed to the large number of entities dependency relationships between classes. So after entities dependency information collection and analysis, the bad smell is detected in programs, and corresponding refactoring suggestions are provided based on detection results. The experiments results of open source programs show that the proposed bad smell cannot be detected by current detection methods. The proposed
detection method in this paper behaves well on refactoring evaluation, and the refactoring suggestions improve the quality of programs.
Poster on Automated Refactoring of Legacy Java Software to Default MethodsRaffi Khatchadourian
The document describes an automated refactoring approach that uses type constraints to migrate legacy Java code using the skeletal implementation pattern to default methods. It presents a motivating example and describes how type constraints are used to determine if a migration will be valid. An evaluation on 19 open source projects found the tool was able to refactor over 19% of candidate methods. A preliminary study submitting pull requests found some were merged but others were rejected due to supporting older clients.
Automated Evolution of Feature Logging Statement Levels Using Git Histories a...Raffi Khatchadourian
This document describes an approach to automatically evolve the logging statement levels of features in software based on degree of interest over time. It extracts feature logging statements and their levels from code, manipulates a degree of interest model based on code changes from Git histories, and identifies mismatches between current levels and predicted levels to suggest level changes. The goal is to reduce information overload by bringing more relevant feature logs to the foreground and less relevant ones to the background based on recent development activity. Security implications regarding side-channel attacks are also mentioned.
Multi step automated refactoring for code smelleSAT Journals
Abstract
Brain MR Image can detect many abnormalities like tumor, cysts, bleeding, infection etc. Analysis of brain MRI using image
processing techniques has been an active research in the field of medical imaging. In this work, it is shown that MR image of brain
represent a multi fractal system which is described a continuous spectrum of exponents rather than a single exponent (fractal
dimension). Multi fractal analysis has been performed on number of images from OASIS database are analyzed. The properties of
multi fractal spectrum of a system have been exploited to prove the results. Multi fractal spectra are determined using the modified
box-counting method of fractal dimension estimation.
Keywords: Brain MR Image, Multi fractal, Box-counting
IJRET : International Journal of Research in Engineering and Technology is an international peer reviewed, online journal published by eSAT Publishing House for the enhancement of research in various disciplines of Engineering and Technology. The aim and scope of the journal is to provide an academic medium and an important reference for the advancement and dissemination of research results that support high-level learning, teaching and research in the fields of Engineering and Technology. We bring together Scientists, Academician, Field Engineers, Scholars and Students of related fields of Engineering and Technology
A Model To Compare The Degree Of Refactoring Opportunities Of Three Projects ...acijjournal
Refactoring is applied to the software artifacts so as to improve its internal structure, while preserving its
external behavior. Refactoring is an uncertain process and it is difficult to give some units for
measurement. The amount to refactoring that can be applied to the source-code depends upon the skills of
the developer. In this research, we have perceived refactoring as a quantified object on an ordinal scale of
measurement. We have a proposed a model for determining the degree of refactoring opportunities in the
given source-code. The model is applied on the three projects collected from a company. UML diagrams
are drawn for each project. The values for source-code metrics, that are useful in determining the quality of
code, are calculated for each UML of the projects. Based on the nominal values of metrics, each relevant
UML is represented on an ordinal scale. A machine learning tool, weka, is used to analyze the dataset,
imported in the form of arff file, produced by the three projects
The document discusses object oriented programming concepts related to packages, interfaces, and their implementation in Java. It defines what packages and interfaces are, how to create and access packages, differences between classes and interfaces, how to define and implement interfaces, and examples of applying packages and interfaces in Java code.
Java 8 is one of the largest upgrades to the popular language and framework in over a decade. This talk will detail several new key features of Java 8 that can help make programs easier to read, write, and maintain. Java 8 comes with many features, especially related to collection libraries. We will cover such new features as Lambda Expressions, the Stream API, enhanced interfaces, and more.
Defaultification Refactoring: A Tool for Automatically Converting Java Method...Raffi Khatchadourian
Enabling interfaces to declare (instance) method
implementations, Java 8 default methods can be used as a
substitute for the ubiquitous skeletal implementation software design
pattern. Performing this transformation on legacy software
manually, though, may be non-trivial. The refactoring requires
analyzing complex type hierarchies, resolving multiple implementation
inheritance issues, reconciling differences between class
and interface methods, and analyzing tie-breakers (dispatch
precedence) with overriding class methods. All of this is necessary
to preserve type-correctness and confirm semantics preservation.
We demonstrate an automated refactoring tool called MIGRATE
SKELETAL IMPLEMENTATION TO INTERFACE for transforming
legacy Java code to use the new default construct. The tool,
implemented as an Eclipse plug-in, is driven by an efficient,
fully-automated, type constraint-based refactoring approach. It
features an extensive ruleset covering various corner-cases
where default methods cannot be used. The resulting code is
semantically equivalent to the original, more succinct, easier to
comprehend, less complex, and exhibits increased modularity. A
demonstration can be found at http://youtu.be/YZHIy0yePh8.
An Empirical Study of Refactorings and Technical Debt in Machine Learning Sys...Raffi Khatchadourian
Machine Learning (ML), including Deep Learning (DL), systems, i.e., those with ML capabilities, are pervasive in today’s data-driven society. Such systems are complex; they are comprised of ML models and many subsystems that support learning processes. As with other complex systems, ML systems are prone to classic technical debt issues, especially when such systems are long-lived, but they also exhibit debt specific to these systems. Unfortunately, there is a gap of knowledge in how ML systems actually evolve and are maintained. In this paper, we fill this gap by studying refactorings, i.e., source-to-source semantics-preserving program transformations, performed in real-world, open-source software, and the technical debt issues they alleviate. We analyzed 26 projects, consisting of 4.2 MLOC, along with 327 manually examined code patches. The results indicate that developers refactor these systems for a variety of reasons, both specific and tangential to ML, some refactorings correspond to established technical debt categories, while others do not, and code duplication is a major cross-cutting theme that particularly involved ML configuration and model code, which was also the most refactored. We also introduce 14 and 7 new ML-specific refactorings and technical debt categories, respectively, and put forth several recommendations, best practices, and anti-patterns. The results can potentially assist practitioners, tool developers, and educators in facilitating long-term ML system usefulness.
20 most important java programming interview questionsGradeup
The document discusses 20 important Java programming interview questions. It covers topics such as the differences between interfaces and abstract classes, when to use abstract classes versus interfaces, what the Serializable interface does, how to force garbage collection, the differences between StringBuffer and StringBuilder, checked and unchecked exceptions, how Java allocates stack and heap memory, Java reflection, the Java Virtual Machine, the differences between JDK and JRE, and more.
A hybrid model to detect malicious executablesUltraUploader
This document presents a hybrid model for detecting malicious executables that uses three types of features: binary n-grams extracted from executable files, assembly n-grams extracted from disassembled executables, and DLL function calls extracted from program headers. A classifier like SVM is trained on the combined "hybrid feature set" to distinguish between benign and malicious executables. The model achieves high detection accuracy and low false positive rates compared to other feature-based approaches.
Laleh M. Eshkevari defended her Ph.D dissertation on developing techniques for the automatic detection and classification of identifier renamings in software projects. Her dissertation outlined a taxonomy of renamings, described approaches for renaming detection based on line mapping, entity mapping and data flow analysis, and discussed methods for classifying renamings based on their form and semantic changes. Evaluation of the approaches on several open source projects showed high precision and recall for renaming detection and identified trends in how renamings are used in practice.
Specification-based Verification of Incomplete ProgramsIDES Editor
Recently, formal methods like model checking or
theorem proving have been considered efficient tools for
software verification. However, when practically applied, those
techniques suffer high complexity cost. Combining static
analysis with dynamic checking to deal with this problem has
been becoming an emerging trend, which results in the
introduction of concolic testing technique and its variations.
However, the analysis-based verification techniques always
assume the availability of full source code of the verified
program, which does not always hold in real life contexts. In
this paper, we propose an approach to tackle this problem,
where our contributed ideas are (i) combining function
specification with control flow analysis to deal with sourcemissing
function; (ii) generating self-complete programs from
incomplete programs by means of concrete execution, thus
making them fully verifiable by model checking; and (iii)
developing a constraint-based test-case generation technique
to significantly reduce the complexity. Our solution has been
proved viable when successfully deployed for checking
programming work of students.
EEE oops Vth semester viva questions with answerJeba Moses
1. An object is the basic unit of object-oriented programming and represents an instance of a class. Objects have unique names and can hold their own data.
2. A class defines a collection of similar objects. Instances are objects created from classes through a process called instantiation.
3. Object-oriented programming organizes programs around objects and a set of well-defined interfaces to access object data. Data is encapsulated within classes and accessed through member functions.
Design and Implementation of Hybrid Test Automation Framework for Web Based A...AM Publications
There many ways to create Web application UI Test Automation Framework. This paper elaborates the creation of the Hybrid Test Automation Framework, and explains the architecture and design of the framework. This Framework is easy to use and incorporate the use of high level programming language allowing object oriented design, permits low level access to the UL components and recover quickly for UI changes in the application under test. The architecture of the framework as multi layer design which isolates the browser UI compounds and test scripts. This Framework Architecture is a merged combination of Library and Data Driven Test Automation Framework. This Framework contents multi packages with classes which isolates the reusable functions and involves the external database on fetching the data. In this framework we can execute the same test case repeatedly in a loop to handle different test input which is retrieved from the database.
Mining Fix Patterns for FindBugs ViolationsDongsun Kim
Several static analysis tools, such as Splint or FindBugs, have been proposed to the software development community to help detect security vulnerabilities or bad programming practices. However, the adoption of these tools is hindered by their high false positive rates. If the false positive rate is too high, developers may get acclimated to violation reports from these tools, causing concrete and severe bugs being overlooked. Fortunately, some violations are actually addressed and resolved by developers. We claim that those violations that are recurrently fixed are likely to be true positives, and an automated approach can learn to repair similar unseen violations. However, there is lack of a systematic way to investigate the distributions on existing violations and fixed ones in the wild, that can provide insights into prioritizing violations for developers, and an effective way to mine code and fix patterns which can help developers easily understand the reasons of leading violations and how to fix them.
In this paper, we first collect and track a large number of fixed and unfixed violations across revisions of software. The empirical analyses reveal that there are discrepancies in the distributions of violations that are detected and those that are fixed, in terms of occurrences, spread and categories, which can provide insights into prioritizing violations. To automatically identify patterns in violations and their fixes, we propose an approach that utilizes convolutional neural networks to learn features and clustering to regroup similar instances. We then evaluate the usefulness of the identified fix patterns by applying them to unfixed violations. The results show that developers will accept and merge a majority (69/116) of fixes generated from the inferred fix patterns. It is also noteworthy that the yielded patterns are applicable to four real bugs in the Defects4J major benchmark for software testing and automated repair.
Top 10 Interview Questions for Java watch this PPT and you will find out the most frequently asked questions in the technical interviews.
Call Now For Catia Training, Projects and Report :- 95698-06826, 0172-4183134
Website:- www.emetechnologies.com
Java Training in Mohali | Chandigarh
6 Months Java Industrial Training in Mohali | Chandigarh
Java Summer Training in Mohali | Chandigarh
This document discusses primitive data types, variables, classes, methods, constructors, and interfaces in Java. It provides details on the different primitive data types including their sizes and ranges. It describes how variables store values of a particular type. It outlines the syntax for class declarations including fields, methods, and constructors. It also covers method overloading, overriding, and parameter passing. Finally, it summarizes interfaces and how they define requirements for classes to implement.
Offline Handwritten Thai Character Recognition Using Single Tier Classifier a...Ferdin Joe John Joseph PhD
1) The document presents a methodology for offline handwritten Thai character recognition using local binary pattern (LBP) features and shape matrices.
2) An experiment was conducted using 4,400 handwritten Thai character images from 44 classes to test different LBP types and shape matrix sizes.
3) The results found that uniform rotation invariant LBP achieved the highest accuracy of 68.96% and a shape matrix size of 12x12 bits performed best.
Bug fixing is a time-consuming and tedious task. To reduce the manual efforts in bug fixing, researchers have pre- sented automated approaches to software repair. Unfortunately, recent studies have shown that the state-of-the-art techniques in automated repair tend to generate patches only for a small number of bugs even with quality issues (e.g., incorrect behavior and nonsensical changes). To improve automated program repair (APR) techniques, the community should deepen its knowledge on repair actions from real-world patches since most of the techniques rely on patches written by human developers. Previous investigations on real-world patches are limited to statement level that is not sufficiently fine-grained to build this knowledge. In this work, we contribute to building this knowledge via a systematic and fine-grained study of 16,450 bug fix commits from seven Java open-source projects. We find that there are opportunities for APR techniques to improve their effectiveness by looking at code elements that have not yet been investigated. We also discuss nine insights into tuning automated repair tools. For example, a small number of statement and expression types are recurrently impacted by real-world patches, and expression-level granularity could reduce search space of finding fix ingredients, where previous studies never explored.
FUNCTIONAL OVER-RELATED CLASSES BAD SMELL DETECTION AND REFACTORING SUGGESTIONSijseajournal
Bad phenomena about functional over-related classes and confused inheritances in programs will cause difficulty in programs comprehension, extension and maintenance. In this paper it is defined as a new bad smell Functional over-Related Classes. After the analysis, the characteristics of this new smell are transformed to the large number of entities dependency relationships between classes. So after entities dependency information collection and analysis, the bad smell is detected in programs, and corresponding refactoring suggestions are provided based on detection results. The experiments results of open source programs show that the proposed bad smell cannot be detected by current detection methods. The proposed
detection method in this paper behaves well on refactoring evaluation, and the refactoring suggestions improve the quality of programs.
Poster on Automated Refactoring of Legacy Java Software to Default MethodsRaffi Khatchadourian
The document describes an automated refactoring approach that uses type constraints to migrate legacy Java code using the skeletal implementation pattern to default methods. It presents a motivating example and describes how type constraints are used to determine if a migration will be valid. An evaluation on 19 open source projects found the tool was able to refactor over 19% of candidate methods. A preliminary study submitting pull requests found some were merged but others were rejected due to supporting older clients.
Automated Evolution of Feature Logging Statement Levels Using Git Histories a...Raffi Khatchadourian
This document describes an approach to automatically evolve the logging statement levels of features in software based on degree of interest over time. It extracts feature logging statements and their levels from code, manipulates a degree of interest model based on code changes from Git histories, and identifies mismatches between current levels and predicted levels to suggest level changes. The goal is to reduce information overload by bringing more relevant feature logs to the foreground and less relevant ones to the background based on recent development activity. Security implications regarding side-channel attacks are also mentioned.
Multi step automated refactoring for code smelleSAT Journals
Abstract
Brain MR Image can detect many abnormalities like tumor, cysts, bleeding, infection etc. Analysis of brain MRI using image
processing techniques has been an active research in the field of medical imaging. In this work, it is shown that MR image of brain
represent a multi fractal system which is described a continuous spectrum of exponents rather than a single exponent (fractal
dimension). Multi fractal analysis has been performed on number of images from OASIS database are analyzed. The properties of
multi fractal spectrum of a system have been exploited to prove the results. Multi fractal spectra are determined using the modified
box-counting method of fractal dimension estimation.
Keywords: Brain MR Image, Multi fractal, Box-counting
IJRET : International Journal of Research in Engineering and Technology is an international peer reviewed, online journal published by eSAT Publishing House for the enhancement of research in various disciplines of Engineering and Technology. The aim and scope of the journal is to provide an academic medium and an important reference for the advancement and dissemination of research results that support high-level learning, teaching and research in the fields of Engineering and Technology. We bring together Scientists, Academician, Field Engineers, Scholars and Students of related fields of Engineering and Technology
A Model To Compare The Degree Of Refactoring Opportunities Of Three Projects ...acijjournal
Refactoring is applied to the software artifacts so as to improve its internal structure, while preserving its
external behavior. Refactoring is an uncertain process and it is difficult to give some units for
measurement. The amount to refactoring that can be applied to the source-code depends upon the skills of
the developer. In this research, we have perceived refactoring as a quantified object on an ordinal scale of
measurement. We have a proposed a model for determining the degree of refactoring opportunities in the
given source-code. The model is applied on the three projects collected from a company. UML diagrams
are drawn for each project. The values for source-code metrics, that are useful in determining the quality of
code, are calculated for each UML of the projects. Based on the nominal values of metrics, each relevant
UML is represented on an ordinal scale. A machine learning tool, weka, is used to analyze the dataset,
imported in the form of arff file, produced by the three projects
A MODEL TO COMPARE THE DEGREE OF REFACTORING OPPORTUNITIES OF THREE PROJECTS ...acijjournal
This document presents a model for quantifying and comparing the degree of refactoring opportunities in three software projects. The model involves drawing UML diagrams for the projects, calculating source code metrics for each UML diagram, representing the diagrams on an ordinal scale based on the metrics, and using a machine learning tool (Weka) to analyze the resulting dataset. The tool uses a Naive Bayesian classifier to generate a confusion matrix for each project, allowing evaluation of the model's performance at classifying refactoring opportunities as low, medium, or high. The model is applied to three projects from a company to test its ability to measure and compare refactoring opportunities in code.
Implementation of reducing features to improve code change based bug predicti...eSAT Journals
Abstract Today, we are getting plenty of bugs in the software because of variations in the software and hardware technologies. Bugs are nothing but Software faults, existing a severe challenge for system reliability and dependability. To identify the bugs from the software bug prediction is convenient approach. To visualize the presence of a bug in a source code file, recently, Machine learning classifiers approach is developed. Because of a huge number of machine learned features current classifier-based bug prediction have two major problems i) inadequate precision for practical usage ii) measured prediction time. In this paper we used two techniques first, cos-triage algorithm which have a go to enhance the accuracy and also lower the price of bug prediction and second, feature selection methods which eliminate less significant features. Reducing features get better the quality of knowledge extracted and also boost the speed of computation. Keywords: Efficiency, Bug Prediction, Classification, Feature Selection, Accuracy
A novel approach for clone group mappingijseajournal
Clone group mapping has a very important significance in the evolution of code clone. The topic modeling
techniques were applied into code clone firstly and a new clone group mapping method was proposed. The
method is very effective for not only Type-1 and Type-2 clone but also Type-3 clone .By making full use of
the source text and structure information, topic modeling techniques transform the mapping problem of
high-dimensional code space into a low-dimensional topic space, the goal of clone group mapping was
indirectly reached by mapping clone group topics. Experiments on four open source software show that the
recall and precision are up to 0.99, thus the method can effectively and accurately reach the goal of clone
group mapping.
A Novel Approach for Code Clone Detection Using Hybrid TechniqueINFOGAIN PUBLICATION
Code clones have been studied for long, and there is strong evidence that they are a major source of software faults. The copying of code has been studied within software engineering mostly in the area of clone analysis. Software clones are regions of source code which are highly similar; these regions of similarity are called clones, clone classes, or clone pairs In this paper a hybrid approach using metric based technique with the combination of text based technique for detection and reporting of clones is proposed. The Proposed work is divided into two stages selection of potential clones and comparing of potential clones using textual comparison. The proposed technique detects exact clones on the basis of metric match and then by text match.
A Methodology To Manage Victim Components Using Cbo Measureijseajournal
This document presents a methodology for managing victim components using coupling between object (CBO) measure. It defines several measures of software component reusability, including weighted component measure and depth of inheritance tree measure. These measures are calculated for components in a human resources (HR) portal application. The document identifies the business tier component as a potential victim component based on its low reuse count. It proposes using CBO measure to identify highly cohesive components that need reconfiguration to improve reusability. Reconfiguring such components would make them less cohesive and easier to reuse in other applications.
Detecting the High Level Similarities in Software Implementation Process Usin...IOSR Journals
1) The document discusses detecting higher-level structural clones in software, beyond just simple code clones. Structural clones show larger patterns of similarity than simple clones alone.
2) It proposes a technique called Clone Miner to detect structural clones using data mining. Clone Miner formulates the structural clone concept and applies data mining to detect these similarities.
3) Detecting structural clones can help with tasks like software maintenance, reengineering for reuse, and understanding the overall design of a system.
SOURCE CODE RETRIEVAL USING SEQUENCE BASED SIMILARITYIJDKP
This document summarizes an approach to improve source code retrieval using structural information from source code. A lexical parser is developed to extract control statements and method identifiers from Java programs. A similarity measure is proposed that calculates the ratio of fully matching statements to partially matching statements in a sequence. Experiments show the retrieval model using this measure improves retrieval performance over other models by up to 90.9% relative to the number of retrieved methods.
Reusability Metrics for Object-Oriented System: An Alternative ApproachWaqas Tariq
Object-oriented metrics plays an import role in ensuring the desired quality and have widely been applied to practical software projects. The benefits of object-oriented software development increasing leading to development of new measurement techniques. Assessing the reusability is more and more of a necessity. Reusability is the key element to reduce the cost and improve the quality of the software. Generic programming helps us to achieve the concept of reusability through C++ Templates which helps in developing reusable software modules and also identify effectiveness of this reuse strategy. The advantage of defining metrics for templates is the possibility to measure the reusability of software component and to identify the most effective reuse strategy. The need for such metrics is particularly useful when an organization is adopting a new technology, for which established practices have yet to be developed. Many researchers have done research on reusability metrics [2, 9, 3, 4]. In this paper we have proposed four new independent metrics Number of Template Children (NTC), Depth of Template Tree (DTT) Method Template Inheritance Factor (MTIF) and Attribute Template Inheritance Factor (ATIF), to measure the reusability for object-oriented systems.
Study on Different Code-Clone Detection Techniques & Approaches to MitigateCo...IRJET Journal
This document summarizes two techniques for code clone detection - Pyclone and a machine learning-based technique. Pyclone generates code clones based on mutating the abstract syntax tree of input python code. The machine learning technique uses a decision tree classifier and 19 clone metrics to filter out false positive clone classes identified by a clone detection tool. It improved clone detection precision on a python project from 0.94 to 0.98. The document also discusses types of clones, issues with code cloning like vulnerabilities, and approaches to mitigate code reuse attacks through techniques like code randomization and optimization. It notes limitations in detecting type 3 and 4 clones and the need for more data and sophisticated models.
Study on Different Code-Clone Detection Techniques & Approaches to MitigateCo...IRJET Journal
This document summarizes two techniques for code clone detection - Pyclone and a machine learning-based technique. Pyclone generates code clones based on mutating the abstract syntax tree of input python code. The machine learning technique uses a decision tree classifier and 19 clone metrics to filter out false positive clone classes identified by a clone detection tool. It improved clone detection precision on a python project from 0.94 to 0.98. The document also discusses types of clones, issues with code cloning like vulnerabilities, and approaches to mitigate code reuse attacks through techniques like code randomization and optimization. It notes that while type 1-3 clones are easier to detect, type 4 clones remain a challenge requiring future work.
Software Engineering with Objects (M363) Final Revision By Kuwait10Kuwait10
This document provides an overview of software engineering concepts covered in various course units. It begins with introductions to approaches to software development, requirements concepts, and modeling. Key topics covered include the software development life cycle, requirements elicitation and analysis techniques, types of requirements (functional and non-functional), modeling languages like UML, and risks and traceability in software projects. The document also lists contents for each of the 14 course units.
A FRAMEWORK STUDIO FOR COMPONENT REUSABILITYcscpconf
The deployment of a software product requires considerable amount of time and effort. In order
to increase the productivity of the software products, reusability strategies were proposed in the
literature. However effective reuse is still a challenging issue. This paper presents a framework
studio for effective components reusability which provides the selection of components from framework studio and generation of source code based on stakeholders needs. The framework studio is implemented using swings which are integrated onto the Net Beans IDE which help in faster generation of the source code.
Ranking The Refactoring Techniques Based on The External Quality AttributesIJRES Journal
The selection of appropriate decisions is a significant issue that might lead to more satisfactory results. The difficulty comes when there are several alternatives and when all of them have the same chance of being selected. It is important, therefore, to find the kinds of priorities among all of these alternatives in order to choose the most appropriate one. The analytic hierarchy process (AHP) is capable of structuring decision problems and finding mathematically determined judgments built on knowledge and experience. This suggests that AHP should prove useful in agile software development where complex decisions occur routinely. This paper presents an example of using the AHP to rank the refactoring techniques based on the external code quality attributes. XP encourages applying the refactoring where the code smells bad. However, refactoring may consume more time and efforts. Therefore, to maximize the benefits of the refactoring in less time and effort, AHP has been applied to achieve this purpose. It was found that ranking the refactoring techniques helped the XP team to focus on the technique that improve the code and the XP development process in general. :
Migration strategies for object oriented system to component based systemijfcstjournal
Migration of object oriented system to component based System is not an easy task, not only technically a
lot of changes needs to be done but also numerous other issues needs to be kept in mind. However Component based Software development has been gaining its popularity from the past few years and has higher reusability scope. Programs built using CBSE approach are confirmed to be suitable to new environments. These days it’s a universal practice to reuse components in project to achieve better quality and to save time. So moving to CBSE from object oriented seems wise decision. Number of approaches has been introduced to implement this and each one of them has its own pros and cons. The paper focuses on the brief review on works of different authors in this area from the year 2000 to 2014.
The paper proposes an approach called Suncode for automatically summarizing source code. Suncode generates summaries for each class and method in a software system. It uses static code analysis to extract information from source code and identifies rapid summary messages for each class and method. These messages are then combined to generate a natural language summary describing the class or method. The authors implemented Suncode and evaluated it on case studies, finding that it provided better contextual information than manually written summaries or other automated approaches. However, manually written summaries were more precise and concise. Future work will look to split identifier names and include comments in the summarization process.
Detecting and resolving feature envy through automated machine learning and m...IJECEIAES
Efficiently identifying and resolving code smells enhances software project quality. This paper presents a novel solution, utilizing automated machine learning (AutoML) techniques, to detect code smells and apply move method refactoring. By evaluating code metrics before and after refactoring, we assessed its impact on coupling, complexity, and cohesion. Key contributions of this research include a unique dataset for code smell classification and the development of models using AutoGluon for optimal performance. Furthermore, the study identifies the top 20 influential features in classifying feature envy, a well-known code smell, stemming from excessive reliance on external classes. We also explored how move method refactoring addresses feature envy, revealing reduced coupling and complexity, and improved cohesion, ultimately enhancing code quality. In summary, this research offers an empirical, data-driven approach, integrating AutoML and move method refactoring to optimize software project quality. Insights gained shed light on the benefits of refactoring on code quality and the significance of specific features in detecting feature envy. Future research can expand to explore additional refactoring techniques and a broader range of code metrics, advancing software engineering practices and standards.
Finding Bad Code Smells with Neural Network Models IJECEIAES
Code smell refers to any symptom introduced in design or implementation phases in the source code of a program. Such a code smell can potentially cause deeper and serious problems during software maintenance. The existing approaches to detect bad smells use detection rules or standards using a combination of different object-oriented metrics. Although a variety of software detection tools have been developed, they still have limitations and constraints in their capabilities. In this paper, a code smell detection system is presented with the neural network model that delivers the relationship between bad smells and object-oriented metrics by taking a corpus of Java projects as experimental dataset. The most well-known objectoriented metrics are considered to identify the presence of bad smells. The code smell detection system uses the twenty Java projects which are shared by many users in the GitHub repositories. The dataset of these Java projects is partitioned into mutually exclusive training and test sets. The training dataset is used to learn the network model which will predict smelly classes in this study. The optimized network model will be chosen to be evaluated on the test dataset. The experimental results show when the modelis highly trained with more dataset, the prediction outcomes are improved more and more. In addition, the accuracy of the model increases when it performs with higher epochs and many hidden layers.
Similar to Method-Level Code Clone Modification using Refactoring Techniques for Clone Maintenance (20)
Advanced Computing: An International Journal (ACIJ) is a peer-reviewed, open access peer-reviewed journal that publishes articles which contribute new results in all areas of the advanced computing. The journal focuses on all technical and practical aspects of high performance computing, green computing, pervasive computing, cloud computing etc. The goal of this journal is to bring together researchers and a practitioners from academia and industry to focus on understanding advances in computing and establishing new collaborations in these areas.
Authors are solicited to contribute to the journal by submitting articles that illustrate research results, projects, surveying works and industrial experiences that describe significant advances in the areas of computing.
Call for Papers - Advanced Computing An International Journal (ACIJ) (2).pdfacijjournal
Submit your Research Papers!!!
Advanced Computing: An International Journal ( ACIJ )
ISSN: 2229 -6727 [Online] ; 2229 - 726X [Print]
Webpage URL: http://airccse.org/journal/acij/acij.html
Submission URL: http://coneco2009.com/submissions/imagination/home.html
Submission Deadline : April 08, 2023
Here's where you can reach us : acijjournal@yahoo.com or acij@aircconline
Advanced Computing: An International Journal (ACIJ
)
is a bi monthly open access peer-reviewed journal that publishes articles which contribute new results in all areas of the advancedcomputing. The journal focuses on all technical and practical aspects of high performancecomputing, green computing, pervasive computing, cloud computing etc. The goal of this journalis to bring together researchers anda practitioners from academia and industry to focus onunderstanding advances in computing and establishing new collaborations in these areas
Submit your Research Papers!!!
Advanced Computing: An International Journal ( ACIJ )
ISSN: 2229 -6727 [Online] ; 2229 - 726X [Print]
Webpage URL: http://airccse.org/journal/acij/acij.html
Submission URL: http://coneco2009.com/submissions/imagination/home.html
Here's where you can reach us : acijjournal@yahoo.com or acij@aircconline.com
7thInternational Conference on Data Mining & Knowledge Management (DaKM 2022)acijjournal
7thInternational Conference on Data Mining & Knowledge Management (DaKM 2022)provides a forum for researchers who address this issue and to present their work in a peer-reviewed forum.
7thInternational Conference on Data Mining & Knowledge Management (DaKM 2022)acijjournal
7thInternational Conference on Data Mining & Knowledge Management (DaKM 2022)provides a forum for researchers who address this issue and to present their work in a peer-reviewed forum.
7thInternational Conference on Data Mining & Knowledge Management (DaKM 2022)acijjournal
7thInternational Conference on Data Mining & Knowledge Management (DaKM 2022)provides a forum for researchers who address this issue and to present their work in a peer-reviewed forum.
4thInternational Conference on Machine Learning & Applications (CMLA 2022)acijjournal
4thInternational Conference on Machine Learning & Applications (CMLA 2022)will provide an excellent international forum for sharing knowledge and results in theory, methodology and applications of on Machine Learning & Applications. The aim of the conference is to provide a platform to the researchers and practitioners from both academia as well as industry to meet and share cutting-edge development in the field.
7thInternational Conference on Data Mining & Knowledge Management (DaKM 2022)acijjournal
The 7th International Conference on Data Mining & Knowledge Management (DaKM 2022) will take place from July 30-31, 2022 in London, United Kingdom. The conference aims to provide a forum for researchers to present work on data mining and knowledge management. Authors are invited to submit papers by June 04, 2022 on topics related to data mining foundations, applications, and knowledge processing. Selected papers will be published in the conference proceedings and considered for publication in related journals. Important dates include the submission deadline of June 04 and notification of acceptance by June 18.
3rdInternational Conference on Natural Language Processingand Applications (N...acijjournal
3rdInternational Conference on Natural Language Processing and Applications (NLPA 2022)will provide an excellent international forum for sharing knowledge and results in theory, methodology and applications of Natural Language Computing and its applications. The Conference looks for significant contributions to all major fieldsof the Natural Language processing in theoretical and practical aspects.
4thInternational Conference on Machine Learning & Applications (CMLA 2022)acijjournal
4thInternational Conference on Machine Learning & Applications (CMLA 2022)will provide an excellent international forum for sharing knowledge and results in theory, methodology and applications of on Machine Learning & Applications. The aim of the conference is to provide a platform to the researchers and practitioners from both academia as well as industry to meet and share cutting-edge development in the field.
Graduate School Cyber Portfolio: The Innovative Menu For Sustainable Developmentacijjournal
In today’s milieu, new demands and trends emerge in the field of Education giving teachers of Higher Education Institutions (HEI’s) no choice but to be innovative to cope with the fast changing technology. To be naturally innovative, a graduate school teacher needs to be technologically and pedagogically competent. One of the ways to be on this level is by creating his cyber portfolio to support students’ eportfolio for lifelong learning. Cyber portfolio is an innovative menu for teachers who seek out strategies to integrate technology in their lessons. This paper presents a straightforward preparation on how to innovate a cyber portfolio that has its practical and breakthrough solution against expensive and inflexible vended software which often saddle many universities. Additionally, this cyber portfolio is free and it addresses the 21st century skills of graduate students blended with higher order thinking skills, multiple intelligence, technology and multimedia.
Genetic Algorithms and Programming - An Evolutionary Methodologyacijjournal
This document summarizes genetic programming, an evolutionary algorithm methodology inspired by biological evolution. Genetic programming starts with a random population of computer programs and uses genetic operators like crossover and mutation to generate new programs. It evaluates programs using a fitness function based on how well they perform a given task. The document discusses the history of genetic programming and machine learning, gives examples of genetic programming representations as tree structures, and explains key genetic programming components like genetic operators, population size, the fitness function, and the evolutionary process of breeding new populations.
Data Transformation Technique for Protecting Private Information in Privacy P...acijjournal
Data mining is the process of extracting patterns from data. Data mining is seen as an increasingly important tool by modern business to transform data into an informational advantage. Data
Mining can be utilized in any organization that needs to find patterns or relationships in their data. A group of techniques that find relationships that have not previously been discovered. In many situations, the extracted patterns are highly private and it should not be disclosed. In order to maintain the secrecy of data,
there is in need of several techniques and algorithms for modifying the original data in order to limit the extraction of confidential patterns. There have been two types of privacy in data mining. The first type of privacy is that the data is altered so that the mining result will preserve certain privacy. The second type of privacy is that the data is manipulated so that the mining result is not affected or minimally affected. The aim of privacy preserving data mining researchers is to develop data mining techniques that could be
applied on data bases without violating the privacy of individuals. Many techniques for privacy preserving data mining have come up over the last decade. Some of them are statistical, cryptographic, randomization methods, k-anonymity model, l-diversity and etc. In this work, we propose a new perturbative masking technique known as data transformation technique can be used for protecting the sensitive information. An
experimental result shows that the proposed technique gives the better result compared with the existing technique.
Advanced Computing: An International Journal (ACIJ) acijjournal
Advanced Computing: An International Journal (ACIJ) is a bi monthly open access peer-reviewed journal that publishes articles which contribute new results in all areas of the advanced computing. The journal focuses on all technical and practical aspects of high performance computing, green computing, pervasive computing, cloud computing etc. The goal of this journal is to bring together researchers and practitioners from academia and industry to focus on understanding advances in computing and establishing new collaborations in these areas.
E-Maintenance: Impact Over Industrial Processes, Its Dimensions & Principlesacijjournal
During the course of the industrial 4.0 era, companies have been exponentially developed and have
digitized almost the whole business system to stick to their performance targets and to keep or to even
enlarge their market share. Maintenance function has obviously followed the trend as it’s considered one
of the most important processes in every enterprise as it impacts a group of the most critical performance
indicators such as: cost, reliability, availability, safety and productivity. E-maintenance emerged in early
2000 and now is a common term in maintenance literature representing the digitalized side of maintenance
whereby assets are monitored and controlled over the internet. According to literature, e-maintenance has
a remarkable impact on maintenance KPIs and aims at ambitious objectives like zero-downtime.
10th International Conference on Software Engineering and Applications (SEAPP...acijjournal
10th International Conference on Software Engineering and Applications (SEAPP 2021) will provide an excellent international forum for sharing knowledge and results in theory, methodology and applications of Software Engineering and Applications. The goal of this Conference is to bring together researchers and practitioners from academia and industry to focus on understanding Modern software engineering concepts and establishing new collaborations in these areas.
10th International conference on Parallel, Distributed Computing and Applicat...acijjournal
The 10th International Conference on Parallel, Distributed Computing and Applications (IPDCA 2021) will take place April 24-25, 2021 in Copenhagen, Denmark. The conference aims to provide a forum for researchers and industry professionals to share knowledge on parallel and distributed computing. Authors are invited to submit original papers by April 3, 2021 on topics including algorithms, bioinformatics, computer networks, cyber security, and wireless networks. Accepted papers will be published in the conference proceedings and may also be published in related journals.
DETECTION OF FORGERY AND FABRICATION IN PASSPORTS AND VISAS USING CRYPTOGRAPH...acijjournal
In this paper, we present a novel solution to detect forgery and fabrication in passports and visas using
cryptography and QR codes. The solution requires that the passport and visa issuing authorities obtain a
cryptographic key pair and publish their public key on their website. Further they are required to encrypt
the passport or visa information with their private key, encode the ciphertext in a QR code and print it on
the passport or visa they issue to the applicant.
The issuing authorities are also required to create a mobile or desktop QR code scanning app and place it
for download on their website or Google Play Store and iPhone App Store. Any individual or immigration
authority that needs to check the passport or visa for forgery and fabrication can scan its QR code, which
will decrypt the ciphertext encoded in the QR code using the public key stored in the app memory and
displays the passport or visa information on the app screen. The details on the app screen can be
compared with the actual details printed on the passport or visa. Any mismatch between the two is a clear
indication of forgery or fabrication.
Discussed the need for a universal desktop and mobile app that can be used by immigration authorities and
consulates all over the world to enable fast checking of passports and visas at ports of entry for forgery
and fabrication.
Detection of Forgery and Fabrication in Passports and Visas Using Cryptograph...acijjournal
In this paper, wepresenta novel solution to detect forgery and fabrication in passports and visas using cryptography and QR codes. The solution requires that the passport and visa issuing authorities obtain a cryptographic key pair and publish their public key on their website. Further they are required to encrypt the passport or visa information with their private key, encode the ciphertext in a QR code and print it on the passport or visa they issue to the applicant.
The issuing authorities are also required to create a mobile or desktop QR code scanning app and place it for download on their website or Google Play Store and iPhone App Store. Any individual or immigration authority that needs to check the passport or visa for forgery and fabrication can scan its QR code, which will decrypt the ciphertext encoded in the QR code using the public key stored in the app memory and displays the passport or visa information on the app screen. The details on the app screen can be compared with the actual details printed on the passport or visa. Any mismatch between the two is a clear indication of forgery or fabrication.
Discussed the need for a universal desktop and mobile app that can be used by immigration authorities and consulates all over the world to enable fast checking of passports and visas at ports of entry for forgery and fabrication.
Main Java[All of the Base Concepts}.docxadhitya5119
This is part 1 of my Java Learning Journey. This Contains Custom methods, classes, constructors, packages, multithreading , try- catch block, finally block and more.
हिंदी वर्णमाला पीपीटी, hindi alphabet PPT presentation, hindi varnamala PPT, Hindi Varnamala pdf, हिंदी स्वर, हिंदी व्यंजन, sikhiye hindi varnmala, dr. mulla adam ali, hindi language and literature, hindi alphabet with drawing, hindi alphabet pdf, hindi varnamala for childrens, hindi language, hindi varnamala practice for kids, https://www.drmullaadamali.com
Beyond Degrees - Empowering the Workforce in the Context of Skills-First.pptxEduSkills OECD
Iván Bornacelly, Policy Analyst at the OECD Centre for Skills, OECD, presents at the webinar 'Tackling job market gaps with a skills-first approach' on 12 June 2024
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...PECB
Denis is a dynamic and results-driven Chief Information Officer (CIO) with a distinguished career spanning information systems analysis and technical project management. With a proven track record of spearheading the design and delivery of cutting-edge Information Management solutions, he has consistently elevated business operations, streamlined reporting functions, and maximized process efficiency.
Certified as an ISO/IEC 27001: Information Security Management Systems (ISMS) Lead Implementer, Data Protection Officer, and Cyber Risks Analyst, Denis brings a heightened focus on data security, privacy, and cyber resilience to every endeavor.
His expertise extends across a diverse spectrum of reporting, database, and web development applications, underpinned by an exceptional grasp of data storage and virtualization technologies. His proficiency in application testing, database administration, and data cleansing ensures seamless execution of complex projects.
What sets Denis apart is his comprehensive understanding of Business and Systems Analysis technologies, honed through involvement in all phases of the Software Development Lifecycle (SDLC). From meticulous requirements gathering to precise analysis, innovative design, rigorous development, thorough testing, and successful implementation, he has consistently delivered exceptional results.
Throughout his career, he has taken on multifaceted roles, from leading technical project management teams to owning solutions that drive operational excellence. His conscientious and proactive approach is unwavering, whether he is working independently or collaboratively within a team. His ability to connect with colleagues on a personal level underscores his commitment to fostering a harmonious and productive workplace environment.
Date: May 29, 2024
Tags: Information Security, ISO/IEC 27001, ISO/IEC 42001, Artificial Intelligence, GDPR
-------------------------------------------------------------------------------
Find out more about ISO training and certification services
Training: ISO/IEC 27001 Information Security Management System - EN | PECB
ISO/IEC 42001 Artificial Intelligence Management System - EN | PECB
General Data Protection Regulation (GDPR) - Training Courses - EN | PECB
Webinars: https://pecb.com/webinars
Article: https://pecb.com/article
-------------------------------------------------------------------------------
For more information about PECB:
Website: https://pecb.com/
LinkedIn: https://www.linkedin.com/company/pecb/
Facebook: https://www.facebook.com/PECBInternational/
Slideshare: http://www.slideshare.net/PECBCERTIFICATION
it describes the bony anatomy including the femoral head , acetabulum, labrum . also discusses the capsule , ligaments . muscle that act on the hip joint and the range of motion are outlined. factors affecting hip joint stability and weight transmission through the joint are summarized.
Chapter wise All Notes of First year Basic Civil Engineering.pptxDenish Jangid
Chapter wise All Notes of First year Basic Civil Engineering
Syllabus
Chapter-1
Introduction to objective, scope and outcome the subject
Chapter 2
Introduction: Scope and Specialization of Civil Engineering, Role of civil Engineer in Society, Impact of infrastructural development on economy of country.
Chapter 3
Surveying: Object Principles & Types of Surveying; Site Plans, Plans & Maps; Scales & Unit of different Measurements.
Linear Measurements: Instruments used. Linear Measurement by Tape, Ranging out Survey Lines and overcoming Obstructions; Measurements on sloping ground; Tape corrections, conventional symbols. Angular Measurements: Instruments used; Introduction to Compass Surveying, Bearings and Longitude & Latitude of a Line, Introduction to total station.
Levelling: Instrument used Object of levelling, Methods of levelling in brief, and Contour maps.
Chapter 4
Buildings: Selection of site for Buildings, Layout of Building Plan, Types of buildings, Plinth area, carpet area, floor space index, Introduction to building byelaws, concept of sun light & ventilation. Components of Buildings & their functions, Basic concept of R.C.C., Introduction to types of foundation
Chapter 5
Transportation: Introduction to Transportation Engineering; Traffic and Road Safety: Types and Characteristics of Various Modes of Transportation; Various Road Traffic Signs, Causes of Accidents and Road Safety Measures.
Chapter 6
Environmental Engineering: Environmental Pollution, Environmental Acts and Regulations, Functional Concepts of Ecology, Basics of Species, Biodiversity, Ecosystem, Hydrological Cycle; Chemical Cycles: Carbon, Nitrogen & Phosphorus; Energy Flow in Ecosystems.
Water Pollution: Water Quality standards, Introduction to Treatment & Disposal of Waste Water. Reuse and Saving of Water, Rain Water Harvesting. Solid Waste Management: Classification of Solid Waste, Collection, Transportation and Disposal of Solid. Recycling of Solid Waste: Energy Recovery, Sanitary Landfill, On-Site Sanitation. Air & Noise Pollution: Primary and Secondary air pollutants, Harmful effects of Air Pollution, Control of Air Pollution. . Noise Pollution Harmful Effects of noise pollution, control of noise pollution, Global warming & Climate Change, Ozone depletion, Greenhouse effect
Text Books:
1. Palancharmy, Basic Civil Engineering, McGraw Hill publishers.
2. Satheesh Gopi, Basic Civil Engineering, Pearson Publishers.
3. Ketki Rangwala Dalal, Essentials of Civil Engineering, Charotar Publishing House.
4. BCP, Surveying volume 1
How to Make a Field Mandatory in Odoo 17Celine George
In Odoo, making a field required can be done through both Python code and XML views. When you set the required attribute to True in Python code, it makes the field required across all views where it's used. Conversely, when you set the required attribute in XML views, it makes the field required only in the context of that particular view.
Method-Level Code Clone Modification using Refactoring Techniques for Clone Maintenance
1. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
DOI : 10.5121/acij.2013.4202 7
Method-Level Code Clone Modification using
Refactoring Techniques for Clone Maintenance
E. Kodhai1
, S. Kanmani2
1
Research Scholar, Department of CSE, Pondicherry Engineering College , Puducherry,
India.
kodhaiej@yahoo.co.in
2
Department of IT, Pondicherry Engineering College, Puducherry, India.
kanmani@pec.edu
ABSTRACT
Researchers focused on activities such as clone maintenance to assist the programmers. Refactoring is a
well-known process to improve the maintainability of the software. Program refactoring is a technique to
improve readability, structure, performance, abstraction, maintainability, or other characteristics by
transforming a program. This paper contributes to a more unified approach for the phases of clone
maintenance with a focus on clone modification. This approach uses the refactoring technique for clone
modification. To detect the clones ‘CloneManager’ tool has been used. This approach is implemented as an
enhancement to the existing tool CloneManager. The enhanced tool is tested with the open source projects
and the results are compared with the performance of other three existing tools.
KEYWORDS
Code clone, Refactoring, Software maintenance.
1. Introduction
It is generally said that code clone is one of the factors that make software maintenance
more difficult [6]. Code clone is a code fragment that is identical or similar to another. Code
clones are introduced for various reasons like reusing code by ‘copy-and-paste’. Code clone
detection techniques can be categorized based on the types of clones they can detect [4] [36].
Many clone detection approaches that can uncover duplication in large scale software systems
have been proposed [24- 28][30-31][37].
Information retrieval technique proposed in [18] is to detect trends and associations
among the clustered clone classes and determine if they provide further comprehension to assist
in the maintenance of clones. Nguyen et al. [20] have developed a clone management tool JSync
to notify developers change and its inconsistency of code clones in source files. Sandro et. al [23]
approach is to take into account detailed code clone analysis and classification as well as how the
analysis results are presented to the user in order to guide an interactive removal process.
One technique that helps to process the code clones is Refactoring. Refactoring is a
disciplined technique for restructuring an existing body of code, altering its internal structure
2. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
8
without changing its external behavior [6]. By making refactoring efforts on a set of code clones,
they can be merged into a method [5, 15], a component [7], or an aspect [9].
Program refactoring is not a very simple technique to apply. Firstly, it is often very
difficult to identify which part of the program should be refactored without understanding the
basic notion of software quality. Secondly, software in practice is so large in scale that developers
have to spend a decent amount of time to inspect the whole target software. Finally, program
refactoring potentially introduces a new bug in the source code because it does require a source
code modification.
Although, numerous techniques and tools have been proposed for code clone detection
[30] and [31], only little has been known about which detected code clones are appropriate for
refactoring and how to extract code clones for refactoring. Roy [22] proposed an Integrated
Development Environment (IDE) based clone management system to flexibly detects, manage,
and refactor both exact and near-miss code clones.
Rajlich [16] use different ways of restructuring functions to remove clones. Komondor
[32] and Liu [33] suggested approaches to extract a function from the clones, which is similar to
Extract Method. These works provide extensive mechanisms for function extraction in procedural
languages. Li and Thompson [34] proposed code clone removal for the functional language
Erlang. This technique is integrated within a refactoring environment for the language. The
detection process is limited to the associated detection tool for Erlang.
The refactoring functions are performed one at a time on each duplicate code detected.
Robert Tairas [19] conclude that sub-clone refactoring should be considered to augment
refactoring performed on the entire clone. Popular development environments such as Eclipse,
semi automatic refactorings [17] implementing Visual Studio or Squeak the programmer specifies
which refactoring patterns to be applied and where to be applied.
In this paper, we show that the existing refactoring patterns [6] can be used to modify
code clones and we propose an approach to support refactoring process by applying code clone
detection techniques. Furthermore, a tool CloneManager [38] is extended to support our proposed
approach. The functionality of this tool is to find certain code clones to which the refactoring
patterns can be applied.
Existing refactoring patterns has different levels of elements for identifying refactoring
opportunities such as field, method, class, objects, etc. As the detected clones by the
CloneManager tool are methods, we need to go for identifying the method level refactoring
opportunities. Moreover, as we are extending the CloneManager tool, it becomes capable of both
detection and modification of clones as by its name.
This paper is presented in four major sections. Section 2 presents the related work. Section 3
presents the basics of refactoring. Section 4 describes the existing CloneManager tool [38].
Section 5 describes the implementation of the proposed approach. Section 6 discusses the
results obtained using our proposed approach. Finally, section 7 concludes the paper.
3. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
9
2. Related Work
The tool Aries developed by Yoshiki et. al [3][10] supports removal of code clones from
source code. This tool applies the characterization of code clones by some metrics, which suggest
how to remove them. A refactoring support tool was developed by them to remove code clones.
This tool is developed for detecting only two types of refactoring patterns namely extract method
and pull up method. They have evaluated the tool with the open source software ant 1.6.0.
The RefactoringCrawler tool developed by Danny Dig et. al. [8] detects refactoring
pattern or performs refactoring during component evolution, by combining Shingles encoding
with traditional semantic analyses, and by iterating the analyses until a fixed point was
discovered. They detect over 85% of the refactoring opportunities. This is mainly useful for clone
evolution than maintenance.
The CeDAR which stands for Clone Detection, Analysis, and Refactoring is developed
by Robert Tairas [2]. A unified process where the phases of clone maintenance with a focus on
clone removal (i.e., detection, analysis, and refactoring) are streamlined together within the
programmer’s working environment. In this work, the extract method refactoring pattern alone
has been developed.
The existing refactoring tool RefactoringCrawler is developed for clone evolution and not
for clone maintenance. The tools Aries and CeDAR are tools developed for clone maintenance
but with limited refactoring patterns applied such as extract method and/or pull up method.
Whereas our proposal has applied three refactoring patterns such as extract method, move method
and pull up method.
3. Program refactoring
Refactoring is the process of changing the structure of a program while maintaining all of its
functionality. There are many types of refactoring patterns such as renaming a class, changing a
method signature, extracting some code. With each refactoring patterns, a number of steps are
carried out to keep the code consistent with the original code. Each refactoring patterns includes
both a description of a refactoring opportunity i.e., a set of code fragments that should be
refactored and the corresponding procedure to perform refactoring.
Martin Fowler et al.[6] introduced a catalog for refactoring patterns where they used a
standard format to represent frequently needed refactoring process. They initially introduced 72
refactoring patterns and later the number has been increased to 93[35]. In this work we apply only
3 refactoring patterns as our detected clones are methods. They are extract method, move method
and pull up method. The following subsections will explain each of the refactoring patterns in
detail.
3.1 Extract Method Refactoring
“Extract Method Refactoring” is intended for “a code fragment that can be grouped
together”[6]. Refactoring turns this fragment into a method whose name explains the purpose of
4. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
10
the method. The rationale is that if there is a very large method that does require some added
comments to understand its purpose, turning a fragment of code into method will increase the
understandability. Fowler also emphasizes the importance of selecting an appropriate short name
for the extracted method refactoring.
The “Extract Method” is classified into three types. They are as follows:
Clone sets that can be removed only by extracting them and making a new method in the
same class.
Clone sets that can be removed by extracting them and making a new method with setting
the externally defined variables as parameters of it because such variables are used in the
clone.
Clone sets that can be removed by extracting them and making a new method with setting
the externally defined variables as parameters of it and with adding parameters of return
statement to deliver the results to the variables used in the caller.
To put it plainly, “Extract Method” means extraction of a part of existing method as a
new method, and the extracted part is replaced by a new method caller shown in Figure 1. In
general, this pattern is applied to the case that there is a too long method. In applying the pattern
to code clones, a new method, that is a code fragment of code clone, is defined and the original
code clones are replaced by the new method caller. As a result, we can modify the code clones.
Figure 1. One Scenario for Extract Method Refactoring
3.2 Move Method Refactoring
A method is used or will be used by more features of another class than by its own. It can
be moved from one class to another. As one of the most elementary refactor operations, move
method aids the reduction of a system’s complexity by moving functionality from classes
suffering too much behavior or strong coupling. By moving methods around, it can make the
classes simpler and they end up being a crisper implementation of a set of responsibilities. An
illustration of move method refactoring is shown in Figure 2.
Void printTaxi( int amount){
String name =getTaxiName();
}
Void printBus(int amount){
String name=getBusName();
}
System.out.println(“name:” +name);
System.out.println(“amount:”
+amount);
System.out.println(“name:” +name);
System.out.println(“amount:” +amount);
Void printTaxi( int amount){
String name =getTaxiName();
print(name,amount);
}
Void printBus(int amount){
String name=getBusName();
print(name,amount);
}
Void print(string name, int amount) {
}
}
System.out.println(“name:” +name);
System.out.println(“amount:” +amount);
5. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
11
Moving a method actually consists of two actions: (1) removing the method from the original
class and (2) adding the removed method to the new class.
The move method from the source class to a target class is performed as follows:
1. The tag indicating to which class the method belongs is changed from source class to target
class.
2. The entity sets of all methods accessing the method are updated according to the new tag.
3. The entity sets of all attributes that are being accessed by the method are updated according to
the new tag.
4. The method is removed from the entity set of the source class.
5. The method is added to the entity set of the target class.
Figure 2. One Scenario for Move Method Refactoring
3.3 Pull Up Method Refactoring
“Pull Up Method Refactoring” means moving identical methods in derived classes to the
base class, so it is necessary that the derived classes have common base class. Therefore, we
measure the position and distance of clones in the class hierarchy. If the base class has several
derived classes and some of them have the same method (that is, code clone), pulling up the
method can modify the code clone.
The easiest case of using Pull Up Method Refactoring occurs when the methods have the
same body, implying there’s been a copy and paste. The two methods in different classes can be
parameterized in such a way they end up as essentially the same method. In that case the smallest
step is to parameterize each method separately and then generalizes them. A special case of the
6. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
12
need for Pull Up Method Refactoring occurs when there is a subclass method that overrides a
superclass method yet does the same thing.
If all or most of a class’s subclasses declare the same method, then it should be pulled up
into the base class. This way it is only defined once in a central location instead of being defined
multiple times. If many of the subclasses have the same method and it should not be pulled up
into the base class, then extract superclass can be used. Refer Figure 3.
Figure 3. One Scenario for Pull Up Method Refactoring
4. Clone Manager
The existing clone detection tool CloneManager [38] is used, to detect the clones. It is
well suited as it is a metric-based code clones because they can be the target of refactoring
operations in their entirety. The tool CloneManager is developed for clone detection to
effectively and accurately detect all four types of code clones at method level in C and Java
source codes through Lexical Analysis and Metrics. The tool is implemented in Java language.
The various types of clones detected by the tool must then be classified and clustered as
clone clusters and given as output. The granularity level for clone detection process of the tool
CloneManager are methods. It means that the tool detects the functions or the methods of the
software system as clones. The tool requires users to select the project containing the necessary
files that are to be analyzed. The user is also given the choice of selecting the types of clones that
he/she wants to be detected and analyzed.
The result of the code clone detection tool is given as clone pairs. Clone Pair (CP) is the
pair of code portions / fragments which is identical or similar to each other. Having detected the
clone pairs in each type, the results need to be given in a suitable form for review and analysis.
The cloned methods detected in each type are clustered into groups called clone clusters (CC).
Every clone pair is commutative and hence in a clone cluster all the members are associative, i.e.
every member of the clone cluster is a clone of every other member of the clone cluster. Thus the
detected clones and clusters are stored in the text files.
Employee
Employee
getName()
getName()
Engineer
getName()
getName()
Salesman
getName()
getName()
Salesman Engineer
7. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
13
4.1 Final Result Set And Coverage Output
i. Duplicates.txt: Contains list of all duplicates grouped by similarity which will be
very useful for a quick overview of results and in the selection of ‘similarity groups’
for closer review, etc. The duplicates are listed as in the clustered order for easier
verification. It also contains details of the no. of lines in the cloned method, cluster
no., etc.
ii. Duplicates_summary.txt: A summary version of the ‘Duplicates.txt’ containing
information about the clone pairs and clusters without any source code. The clusters
are represented as a set of cloned method names with the method name and line no.
in the file specified along with it.
5. Proposed approach
The detected code clones can be modified automatically using refactoring technique. The
refactoring process is performed as follows. The clones are detected using the tool
CloneManager[38] and the results are documented in a text file. To perform a refactoring
process, the element(s) selected are methods in the source code. The results of the CloneManager
are method-level clones which are appropriate for refactoring process. The three types of
refactoring discussed in section 3 are implemented by our approach. This approach has been used
to enhance the clone detection tool to extend the environment to realize the three refactoring
methods.
The main window has two parts. The original source code will be displayed in the left side part
and the results of the detected clones by CloneManager tool will be displayed in the right side
part. Figure 4 shows the overall system architecture.
The following are the steps to do clone modification by applying refactoring patterns in
the proposed approach.
Identify the possible refactoring opportunities and highlight those clones in the
right side window
This clone in the left side window will be highlighted automatically
Determine which refactoring pattern should be applied to the identified places
Apply the refactoring pattern
Assess the effect of refactoring process
If the developer wants to reflect the changes, then the changes are store
permanently in the original code itself. Otherwise, it will not reflect the changes
in the original code
8. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
14
Figure 4: Extended CloneManager System Architecture
The implementation of proposed approach is carried out in four phases as follows
1. Clone Collection
2. Applying refactoring patterns
3. Behavioral verification on refactoring process
4. Confirming refactoring process
5.1 Clone Collection
Using the existing combination of clone metrics proposed in [1][21], the clone clusters are
selected from the text file resulted from the tool CloneManager. These clone metrics helps us to
identify the clone clusters that are appropriate for refactoring process. After selection of clone
clusters, the exact locations of the clones in the source code are located using the string matcher
technique.
Clone metrics namely LEN(S), POP(S) and RNR(S) are used for this purpose. Each of them
characterize a clone cluster (i.e. an equivalent of code clone) S:
LEN(S) - The average number of token sequence of code clones in a clone cluster S
POP(S) - The number of code clones in a clone cluster S
RNR(S) - The ratio of non-repeated token sequence of code clone in a clone cluster S
The definition of LEN(S) and POP(S) are explicit as they are the simple count metrics.
Higher LEN(S) values mean that each code clone in a clone cluster S consists of more token
sequences. Clone Metric LEN(S) eliminates small size code clones detected.
Results of
CloneManager
Clone Collection
Highlighting the clones
Matching the
token
Source
Files
Splitting
Tokens
Apply Refactoring
Patterns
Behavioral verification
on refactoring process
Confirming refactoring
process
Extract
Method
Move
Method
Pull Up
Method
9. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
15
A clone cluster with a high value of POP(S) means that the code clones appears more
frequently in many places. A clone set who’s higher POP(S) apply good motivation for
refactoring to developers because to perform refactoring to code clones in a clone cluster appear
more frequently in software improves the maintainability.
The definition of RNR(S) metric is defined by Equation (1). If clone set S includes n code
clones, c1; c2 : : : ; cn, LOSwhole(ci) is the Length of the whole token Sequence of code clone ci.
LOSnon-repeated(ci) is the Length of non-repeated token Sequence of code clone ci, then,
n
∑ LOSnon-repeated (ci)
i=1
RNR(S) = __________________ x 100 (1)
n
∑ LOSwhole (ci)
i =1
Higher RNR(S) values mean that each code clone in a clone cluster S consists of more non-
repeated token sequences. It eliminates types of if (or if-else) blocks. It also eliminates language
dependent code clones.
The following combination of the clone metrics are used for identifying the clone cluster
1. Clone cluster whose LEN(S) and RNR(S) is the highest
2. Clone cluster whose LEN(S) and POP(S) is highest
3. Clone cluster whose RNR(S) and POP(S) is highest
4. Clone cluster whose LEN(S), RNR(S), and POP(S) is highest
These are the identified clone clusters for applying refactoring mechanisms. The clone
collector helps us to find the presence of code clones in the source code. The exact location of the
clones in the source code can be determined by clone collector. Using the string matcher
technique the clone collector matches the similarity between the source code and the cloned
codes.
After the above steps in the browser, the code clones are highlighted using a different
background color such as yellow to show the exact location and presence of the clones in the
original source code. The remaining part of the code is left with the white background color as
such. After highlighting the clones the clone files are integrated together into a single file. The
integrated file contains all the copies of the cloned codes from the source code. This type of clone
collection is used in future by the user. i.e programmer who refer to the clones can decide which
type of refactoring pattern will be made to the clones to correct them or to remove them. Figure 5
illustration of highlighting clones.
10. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
16
Figure 5. Illustration of Highlighting the Clone Clusters
5.2 Applying Refactoring Patterns
In this phase the refactoring patterns extract method, move method and pull up method for
modifying the clones are applied. The steps in each of the methods are explained in the following
subsections.
5.2.1 Extract method
Make a list of all methods in the selected clone cluster. For each method, count the lines of code
and the number of statements in the method’s body. If both of those counts exceed their
corresponding thresholds, then the method should probably be extracted into multiple smaller
methods. The statement count is important because it prevents false positives from methods with
statements that span many lines. For example, a method may have just a few statements, but one
of those statements can contain a conditional expression that spans one or more screens. The line
count is less important; however, it is useful for users those who want to enforce strict policies on
how many lines a method may span.
α:= 70,β := 50
for m methods[clone set] do
if lines-of-code[m] >= α ^|statements[m]| >= β then
report (“Extract Method”, m)
Figure 6. Algorithm for Extract Method
The Extract Method algorithm is based on the assumption that a method with a large
body can most likely be split up into smaller methods. This is done by extracting chunks of
functionality from the large method into separate small methods. This algorithm also makes the
assumption that the larger the method body is, the more likely it is to have multiple chunks of
code that are mostly independent of each other. Those independent chunks of code are easily
11. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
17
extracted. This is not always the case; sometimes a method is so interconnected and cohesive that
there is no multiple functionality. It cannot easily be extracted into separate methods.
5.2.2 Move Method
A data class is a class that holds data but does not make use of the data itself; it merely
holds the data for other classes to use. For each class or struct in the list, count the number of
attributes and methods declared. If there is a low ratio of methods to attributes, then the
assumption is that the class is a data class and targets it as a candidate class for move method.
Once a candidate class has been found, for each attribute in the class determine the set of
methods referencing the attribute by using the forward reference chains previously built. If a
foreign method makes too many references to a number of distinct fields, then move the method
or some of its functionality into the data class. The additional check on the number of distinct
attributes is needed since some methods may reference a single attribute many times, but in fact a
temporary variable could have been used to reference the attribute only once.
α := 0.40,β := 4, µ := 2
for c classes[program] do
if |fields[c]| > α·|methods[c]| then
for f fields[c] do
for r references[ f ] do
m := containing-method(r)
fields-referenced[m] := fields-referenced[m] ∪ { f }
total-references[m] := total-references[m]+1
for m fields-referenced do
if total-references[m] >= β^|fields-referenced[m]| >=µ then
report(“move method”,m,c)
delete fields-referenced, total-references
Figure 7.Algorithm for Move Method
If there are duplicated methods in different classes that have no common base class, it is
difficult to apply refactoring using class hierarchy to them. In such case, the “Move Method” is a
good solution for identifying refactoring opportunities for removing code clones as shown in
figure 2.
5.2.3 Pull Up Method
This algorithm makes the assumption that multiple instances of any method in a class
hierarchy with the same method signature will be used in very similar ways. It also assumes that
methods with the same method signature and roughly the same number of lines are more likely to
have a similar purpose.
β := 20
for m methods[clone set] do
common-methods-count[m] := common-methods-count[m]+1
12. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
18
if common-methods-max-lines[m] < lines-of-code[m] then
common-methods-max-lines[m] := lines-of-code[m]
if common-methods-min-lines[m] > lines-of-code[m] then
common-methods-min-lines[m] := lines-of-code[m]
for m common-methods-count do
if common-methods-max-lines[m]−common-methods-min-lines[m] <= β then
report(“pull up method”,m)
Figure 8: Algorithm for Pull Up Method
5.3 Behavioral Verification on Refactoring Process
The definition of behavior preservation states that, for the same set of input values, the
resulting set of output values should be the same before and after refactoring process. So, we need
to check the behavior of the system. For this the given input software are executed before and
after to check the output of the system. (i.e) to test the results are same after refactoring process.
The tool allows the user to test that the files in the project all compile correctly before a
refactoring process is performed. This is an essential feature since one of the assumptions made
by the tool is that the code compiles correctly. Thus it is automated to check the external
behavior.
The user can test whether refactoring patterns can be applied without actually applying the
refactoring patterns. The JavaCompiler interface from the framework is used to provide a method
for the user to compile files in the project. All files specified in the project are compiled
according to the various settings specified in the project file.
To check the external behavior, the refactored source code file is converted into executable
file. Hence the file can be run on a machine to produce output file. The code file is saved for the
future reference and for the case study that is done on the source code.
5.4 Confirming Refactoring Process
If, the refactored codes do preserve the same external behavior as before, then according
to the requirement of the software developer, the software can be made to change completely and
permanently in the original source code. The tool allows output conditions to be checked by
testing. If the conditions hold, apply the refactoring to the current source code. This confirms the
refactoring.
The user interface window has two options with button named doractoring and cancel. The
user is enabled to select the dorefactoring option, if the user selects that option the code is
modified as per refactoring process and it is replaced and saved as such. If the developers don’t
want to make any changes, then the changes will not be done in original source code. For this the
user has to select the cancel option.
The tool provides facilities for undoing changes made by refactoring process. However it
leaves the management of these changes up to the user so that they can be represented as desired.
13. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
19
It is necessary for the tool to use its own mechanisms to undo the refactoring process, for example
by storing a textual representation in its own structure.
6 Experiments and Results
6.1 Experimental Setup
The proposed method is implemented and experimented with seven Java Projects. We
have chosen the dataset which have been already evaluated in the literature, so that it will be
helpful for us to do comparison easier. We compared our results with three of the existing tools.
To measure the accuracy of our proposed work, we use precision and recall, two standard metrics.
Precision is the ratio of the number of relevant refactoring opportunities found to the total
number of irrelevant and relevant refactoring opportunities found.
Recall is the ratio of the number of relevant refactoring opportunities found to the total
number of actual refactoring opportunities in the component.
Ideally, precision and recall should be 100%. Finally, we also cross checked the results
by manual inspection of the open source projects.
6.2 Datasets
We have analyzed with a medium sized program called JHotDraw 5.3 which is for
structured drawing editors of approximately 27,000 lines and to the large size program called
Eclipse which is the java text editor along user interface with 352,000 lines. Table 1 lists the
features of open source projects which are taken for the performance analysis of our
CloneManager tool.
Table 1: Projects chosen as dataset for Clone modification using refactoring
In Table 1, the second column is the list of open source program names as the input project. The
third column is the version of the project. The fourth column is the no. of lines in the source code
in thousands. The fifth column is the no. of methods in each project. The last column is the no. of
classes in each project. Table 2 shows the results for all chosen dataset.
S.No Project version Size KLOC #Methods #Classes
1 Eclipse UI 3.0 352 15894 1735
2 Struts 1.2.4 97 6044 469
3 JHotDraw 5.3 27 2038 195
4 JFreeChart 1.0.10 76 1847 436
5 JEdit 4.2 51 5418 426
6 Ant 1.6.0 180 9947 994
7 Ant 1.7.0 67 4231 778
14. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
20
6.3 Results
In Table 2, the 2, 3 & 4 column shows the no. of refactoring opportunities identified and
refactoring patterns applied for clone modification. The last column shows the total no. of
refactoring opportunities.
From the results, we observed, that even though eclipse UI 3.0 is the largest open source in
size, the total of number of the refactoring opportunities is very less. Next, we observed that the
total no. of refactoring opportunities in ant 1.6.0 is 87, where as in ant 1.7.0 the number is only
62. This shows that the number of refactoring opportunities reduced a lot in the next version of
ant. Finally, we observed that the number of pull-up method is nearly 20 in average for all the
projects, where as the extract method and move method varies a lot among the projects.
Table 2. No. of refactoring opportunities detected for each project
Project Extract Method
Move
Method
Pull Up Method
Total
Refactoring
opportunities
Eclipse UI 3.0 3 10 12 25
Struts 1.2.4 6 21 1 28
JHotDraw 5.3 5 0 26 31
JFreeChart
1.0.10
65 58 21 144
JEdit 4.2 20 58 23 101
Ant 1.6.0 35 29 23 87
Ant 1.7.0 32 27 03 62
6.4 Evaluation of the tool
The table 3 shows the results produced for all the datasets to evaluate our tool. The column 3
holds [M] the number of manually detected refactoring opportunities for all the datasets. The
Column 4 holds [D] the number of refactoring opportunities detected by our tool CloneManager.
The column 5 holds [C] the number of refactoring opportunities detected correctly by our tool.
These values are used to calculate the two parameters precision and recall for evaluation. The
formula to calculate Precision = [C]/ [D] * 100 and Recall = [D]/ [M] * 100.
Table 3: Results produced for evaluation of the tool
Project
Refactoring
patterns
Manually
detected
Refactoring
opportunities
[M]
Detected
Refactoring
opportunities
[D]
Correctly
Detected
Refactoring
opportunities [C]
Eclipse UI
3.0
Extract Method 2 3 2
Move Method 10 10 9
Pull Up Method 12 12 12
Struts 1.2.4 Extract Method 6 6 5
15. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
21
Move Method 23 21 21
Pull Up Method 1 1 1
JHotDraw
5.3
Extract Method 5 5 5
Move Method 0 0 0
Pull Up Method 26 26 26
JFreeChart
1.0.10
Extract Method 66 65 65
Move Method 57 58 56
Pull Up Method 20 21 20
JEdit 4.2
Extract Method 19 20 19
Move Method 58 58 58
Pull Up Method 24 23 22
Ant 1.6.0
Extract Method 36 35 35
Move Method 31 29 29
Pull Up Method 23 23 22
Ant 1.7.0
Extract Method 32 32 32
Move Method 25 27 25
Pull Up Method 03 03 03
From the results produced, the precision and recall parameters are calculated for each
refactoring patterns for all the chosen datasets. We observed that the precision percentage is
above 85 for all the datasets. Even though it is not feasible to get 100 percent for all methods, we
had many 100% results. .
We also observed that there is more number of 100 percentages in recall than precision. Moreover
the minimum percent is 90 for recall. From this we come to know that our system performance is
even higher in recall when compared to precision. This shows that almost all refactoring
opportunities detected by our tool are correct. Thus our tool proves to provide high precision and
recall, which are the best parameters for the evaluation of code clones tools.
Table 4: Evaluation parameters for all the datasets
Project [D] [C] [A] Precision in % Recall in % Time in sec
Eclipse UI 3.0 25 26 25 92 100 98
Struts 1.2.4 28 29 30 97 93 15
JHotDraw 5.3 31 31 31 100 100 05
JfreeChart 1.0.10 144 147 145 98 99 51
Jedit 4.2 101 103 103 98 98 45
Ant 1.6.0 87 88 90 99 97 56
Ant 1.7.0 62 64 62 97 100 32
16. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
22
Figure 9. Precision values for all datasets. Figure 10. Recall values for all datasets.
The system is also evaluated with overall detected refactoring opportunities for all
datasets. The parameters precision, recall and time taken in seconds are given for all datasets. All
these values are tabulated in Table 4 respectively. The overall Precision and recall is above 90%.
Figure 9 & 10 shows the precision and recall values in graph for all datasets.
The maximum time taken is not even 2 minutes. This shows that our system is very fast.
Finally we are able to get results for the Eclipse UI system also which is larger in size. This
proves that our system is also scalable.
6.5 Comparison of the tool
Having computed the results for all three types of refactoring patterns and modified the
clones in all datasets, we compared our results with three of the existing tools. Table 5 list outs
the existing refactoring tool along with their data.
Table 5: Existing tools data considered for analysis
Tool Name Refactoring patterns Used Projects considered
Aries [3]
Extract Method
Ant 1.6.0
Pull Up method
RefactoringCrawler [8]
Move Method Eclipse UI 3.0
Pull Up Method
Struts 1.2.4
JHotDraw 5.3
CeDAR [2] Extract Method
JfreeChart 1.0.10
Jedit 4.2
Ant 1.7.0
a) The first tool considered for analysis is Aries for refactoring process. Aries developed by
Yoshiki et. al [3] supports extract method and pull up method for code clones. Yoshiki et.
al has tested the tool with only one open source program Ant 1.6.0.
88
90
92
94
96
98
100
92
97
100
98 98
99
97
Precision…
88
90
92
94
96
98
100
96
93
100 99
98
97
100
Recall in…
17. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
23
b) The second tool we considered for analysis is the RefactoringCrawler developed by
Danny Dig et. al. [8] an algorithm that detects refactorings opportunities performed
during component evolution.
c) The third tool we considered for analysis is the CeDAR which stands for Clone
Detection, Analysis, and Refactoring is developed by Robert Tairas [2] . The information
about a selected clone group can be forwarded to the Eclipse refactoring engine for the
purpose of refactoring process.
Table 6: comparison with the existing tool Aries for Ant 1.6.0
Refactoring
Patterns
No. of Refactoring Opportunities
Aries CloneManager Manual
Extract Method 32 35 36
Pull Up method 20 22 23
Total 52 57 59
Time in sec 120 56 -
From the table 6, we compared our tool results; which shows more no. of refactoring
opportunities identified in both refactoring patterns. This reveals that our tool is able to find and
do refactoring process better than Aries. The time taken to detect refactoring opportunities is also
lesser as shown in the table.
Table 7: Comparison with the existing tool RefactoringCrawler
Project
RefactoringCrawler CloneManager Manual
Move
Metho
d
Pull
Up
Metho
d
Tot
al
Move
Metho
d
Pull
Up
Metho
d
Tot
al
Move
Metho
d
Pull Up
Metho
d
Total
Eclipse UI
3.0
8 11 19 9 12 21 10 12 22
Struts 1.2.4 20 1 21 21 1 22 23 1 24
JHotDraw
5.3
0 26 26 0 26 26 0 26 26
Table 8: Comparison of the evaluation parameters with RefactoringCrawler
Project
RefactoringCrawler CloneManager
Precision% Recall% Time Precision% Recall% Time
Eclipse UI 3.0 90 86 16.38 92 96 1.38
Struts 1.2.4 100 86 4.55 97 93 0.15
JHotDraw 5.3 100 100 0.37 100 100 0.05
From table 7, we observed that the value in pull up method for struts 1.2.4 and the values
for JHotdraw 5.3 project are same. Other values are higher than the refactoringCrawler tool. This
shows that our tool is able to detect even more refactorings opportunities which are left by the
18. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
24
refactoringCrawler tool. The values given are correctly detected by our tool[c]. The last column
list outs the values detected manually for each project.
Moreover, the precision and recall for their tool is only above 85%, where as our tool is
above 90%.Finally, the last column in each tool gives the time taken in minutes and seconds. This
shows that our tool is faster than RafactoringCrawler.
Table 9: comparison with the existing tool CeDAR for Eixtract Method
Project
No. of refactoring patterns
CeDAR CloneManager Manual
JfreeChart 1.0.10 62 65 66
Jedit 4.2 20 19 19
Ant 1.7.0 28 32 32
The CeDAR tool detects for Extract method alone. The value for Jedit 4.2 is the same.
The remaining two projects JfreeChart 1.0.10 and Ant 1.7.0 detect more refactoring opportunities
than CeDAR. The last column list outs the values detected manually for each project.
7 Conclusion
Thus we have proposed a method for clone modification using refactoring technique, for
the existing clone detection tool CloneManager. This proposed method is implemented as an
added feature for CloneManager tool. We used the existing refactoring patterns for clone
modification. The refactoring patterns extract method, move method, pull up method are used as
given in the literature. We have shown that our system is higher in the precision and recall and in
terms of speed.
References
[1] Eunjong Choi, Norihiro Yoshida, Takashi Ishio, Katsuro Inoue, Tateki Sano, Extracting Code Clones
for Refactoring Using Combinations of Clone Metrics, International Workshop on Software Clones
(IWSC) – 2011.
[2] Robert Tairas, Representation, Analysis, and Refactoring Techniques to Support Code Clone
Maintenance, Ph.D. Thesis – 2010.
[3] ARIES: Refactoring Support Tool for Code Clone, Yoshiki Higo, Toshihiro Kamiya, Shinji
Kusumoto, Katsuro Inoue, Proceeding 3-WoSQ Proceedings of the third workshop on Software
quality, ACM New York, NY, USA.2005.
[4] Stefan Bellon, Rainer Koschke, Giuliano Antoniol, Jens Krinke, and Ettore Merlo, “Comparison and
Evaluation of Clone Detection Tools,” IEEE Transactions on Software Engineering, Volume 33,
Number 9, September 2007, pages 577 - 591.
[5] M. Balazinska, E. Merlo, M. Dagenais, B. Lag¨ue, and K. Kontogiannis. Advanced clone-analysis to
support object-oriented system refactoring. Proc. of the 7th IEEE International Working Conference
on Reverse Engineering, pages 98–107, Nov 2000.
[6] M. Fowler, Refactoring: improving the design of existing code, Addison Wesley, 1999.
[7] S. Jarzabek and L. Shubiao. Eliminating redundancies with a “composition with adaptation”
metaprogramming technique. Proc. of ESEC-FSE’03 European Software Engineering Conference and
ACM SIGSOFT Symposium on the Foundations of SoftwareEngineering, pages 237–246, Sep 2003.
19. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
25
[8] Danny Dig, Can Comertoglu, Darko Marinov, Ralph Johnson: "Automated Detection of Refactorings
in Evolving Components", Proceedings of European Conference on Object-Oriented Programming
(ECOOP'06), pp 404-428, Nantes, France.2006.
[9] M. Bruntink, A. V. Deursen, T. Tour´we, and R. V. Engelen. An evaluation of clone detection
techniques for identifying crosscutting concerns. In Proc. of the 20th IEEE International Conference
on Software Maintenance, pages 200–209, Sep 2004.
[10] Y. Higo, T. Kamiya, S. Kusumoto, and K. Inoue. Aries: Refactoring support environment based on
code clone analysis. In Proc. of 8th IASTED InternationalConference on Software Engineering and
Applications, pages 222–229, Nov 2004.
[11] Eclipse Java Development Tools, http://www.eclipse.org/jdt.
[12] jEdit, http://www.jedit.org.
[13] FreeChart, http://www.jfree.org/jfreechart.
[14] JHotDraw, http://www.jhotdraw.org.
[15] Apache Ant, http://ant.apache.org.
[16] Richard Fanta and Vaclav Rajilich, “Removing Clones from the Code,” Journal of Software
Maintenance and Evolution: Research and Practice, Volume 11, Number 4, August 1999, pages 223 -
243.
[17] Emerson Murphy-Hill and Andrew Black, “Refactoring Tools: Fitness for Purpose,” IEEE Computer,
Volume 25, Number 5, September/October 2008, pages 38 - 44.
[18] Robert Tairas and Jeff Gray, “An Information Retrieval Process to Aid in the Analysis of Code
Clones,” Empirical Software Engineering, Volume 14, Number 1, February 2009, pages 33 - 56.
[19] Robert Tairas and Jeff Gray, “Sub-clones: Considering the Part Rather than the Whole,” International
Conference on Software Engineering, Research,and Practice, Las Vegas, Nevada, July 2010.
[20] Hoan Nguyen, Tung Nguyen, Nam Pham, Jafar Al-Kofahi, Tien Nguyen, Clone Management for
Evolving Software, IEEE Transactions on Software Engineering, vol. 38, Issue:5, oct 2012, pages
1008-1026.
[21] Eunjong Choi, Norihiro Yoshida, Takashi Ishio, Katsuro Inoue, Tateki Sano, Finding Code Clones
for Refactoring with Clone Metrics: A Case Study of Open Source Software, IEICE Technical Report
– 2011.
[22] Minhaz Zibran, Chanchal K. Roy, Towards Flexible Code Clone Detection, Management, and
Refactoring in IDE, International Workshop on Software Clones (IWSC) – 2011.
[23] Sandro Schulze, Martin Kuhlemann, Advanced Analysis for Code Clone Removal, GI-Workshop on
Software Reengineering – 2009.
[24] R. Koschke, “Survey of research on software clones,” Dagstuhl seminar 06301. ISSN 1682–4405 -
Duplication, Redundancy, and Similarity in Software, 2006.
[25] C. K. Roy and J. R. Cordy, “A survey on software clone detection research,” Queen’s University,
Kingston, Canada, Technical Report. 2007-541, 2007.
[26] Z. Li, S. Lu, S. Myagmar, and Y. Zhou, “CP-Miner: Finding copy-paste and related bugs in large-
scale software code,” IEEE Transaction Software Engineering, vol. 32, no. 3, pp. 176–192, 2006.
[27] C. K. Roy and J. R. Cordy, “NICAD: Accurate detection of near-miss intentional clones using
flexible pretty-printing and code normalization,” The 16th IEEE International Conference on
Program Comprehension ’08, 2008.
[28] E. Juergens, F. Deissenboeck, and B. Hummel, “Clonedetective – a workbench for clone detection
research,” International Conference on Software Engineering ’09, 2009.
[29] Y. Higo, T. Kamiya, S. Kusumoto, and K. Inoue. Method and Implementation for Investigating Code
Clones in a Software System. Information and Software Technology, 49(9-10):985{998, 2007.
[30] L. Jiang, G. Misherghi, Z. Su, and S. Glondu, “DECKARD: Scalable and accurate tree-based
detection of code clones,” International Conference on Software Engineering ’07, 2007.
[31] T. Kamiya, S. Kusumoto, and K. Inoue, “CCFinder: a multilinguistic token-based code clone
detection system for large scale source code,” IEEE Transaction on Software Engineering, vol. 28, no.
7, pp. 654–670, 2002.
20. Advanced Computing: An International Journal ( ACIJ ), Vol.4, No.2, March 2013
26
[32] Raghavan Komondoor and Susan Horwitz, “Effective, Automatic Procedure Extraction,”
International Workshop on Program Comprehension, Portland, Oregon, May 2003, pages 33 - 42.
[33] Yidong Liu, “Semi Automatic Removal of Duplicated Code,” Diploma Thesis, University of
Stuttgart, Germany, 2004.
[34] Huiqing Li and Simon Thompson, “Clone Detection and Removal for Erlang/OTP within a
Refactoring Environment,” Workshop on Partial Evaluation and Semantics-Based Program
Manipulation, Savannah, Georgia, January 2009, pages 169 - 178.
[35] M. Fowler. Refactoring Catalog, http://refactoring.com/catalog/
[36] C. Roy, J. Cordy, and R. Koschke, “Comparison and evaluation of code clone detection techniques
and tools: A qualitative approach,” Science of Computer Programming, vol. 74, no. 7, pp. 470–495,
2009.
[37] N. Gode and R. Koschke, “Incremental clone detection”, 13th European Conference on Software
Maintenance and Reengineering ’09, 2009.
[38] E. Kodhai, S. Kanmani, A. Kamatchi, R. Radhika and B. Vijaya Saranya, CloneManager : A tool for
detection of type1 and type2 code clones, International Conference on Recent Trends in Business
Administration and Information Processing, Springer digital library, Trivandrum, Kerala, India,
March 26 & 27, 2010.