Search

It is common to have various clones from cross-seedlings or unintended planting by the farmers in a tea plantation. Since each tea clone has distinctive features such as quality, resistance to diseases, etc., visual inspections are usually conducted on the plantations to segment areas with different tea clones within the plantation to produce crops with consistent quality. However, this would be costly and time-consuming. In this work, we apply machine learning and develop an application to recognize tea clones automatically. We propose a convolutional variational autoencoder-based feature learning algorithm to produce robust features against data distortions. There are two main advantages of using this algorithm for feature learning. First, there is no need to design complex handcrafted features for classifications, usually conducted in machine learning. Second, the resulting features are more robust when tested with data taken from unideal conditions. The proposed method is evaluated using the original and the distorted image. Our proposed method achieves the best performance of 0.83 (83%) for the original image test, 0.75 (75%) for the gaussian blur image test, and 0.78 (78%) for the median blur image test. This is a much more robust result than VGGNet16, a popular supervised deep convolutional neural network.

If a developer uses trademarked content from other game such as images and music, it will be illegal. But it is fine for the developer to copy the gameplay and make innovative changes to improve the game. This is a good practice that boosts innovation in the video game industry that relies on creativity. The problem is when a developer decided to use the legality to simply copy other works with no spirit of innovation. This act of legal plagiarism is called video game clone. We need to have a more understanding of Indonesia game developer’s perception toward game cloning and plagiarism. Based on the survey, it can be concluded that Indonesia game developer, in general, has no problem with the act of game cloning. Although, more effort and focus could be given to protecting both creators and consumers from the negative intent of using game clone legality

With the rapid development of Internet technology, network attacks have become more frequent and complex, and intrusion detection has also played an increasingly important role in network security. Intrusion detection is real-time and proactive, and it is an indispensable technology under the diversified trend of network security issues. In terms of network security, neural networks have the characteristics of self-learning, self-adaptation, and parallel computing, which are very important in intrusion detection. This paper combines back propagation neural network (BPNN) and elite clone artificial bee colony (ECABC) to propose a new ECABC-BPNN, which updates and optimizes the settings of traditional BPNN weights and thresholds. Then, apply ECABC-BPNN to network intrusion detection. Use the attack data samples of KDD CUP 99 and water pipe for attack classification experiments using GA-BPNN, PSO-BPNN, and ECABC-BPNN. The results show that the ECABC-BPNN proposed in this paper has an accuracy rate of 98.08% on KDD 99 and 99.76% on water pipe data. ECABC-BPNN effectively improves the accuracy of network intrusion classification and reduces classification errors. In addition, the time complexity of using ECABC-BPNN to classify network attacks is relatively low. Therefore, ECABC-BPNN has superior performance in network intrusion detection and classification.

In recent years, more and more researchers have paid attention to the three-dimensional target coverage of environmental monitoring wireless sensor networks (EMWSNs) under real environmental conditions. However, the target coverage method studied in the traditional two-dimensional plane is full of loopholes when applied in the real three-dimensional physical world. Most coverage algorithms usually only optimize for a single problem of target coverage or network energy consumption and cannot reduce network energy consumption while improving coverage. This paper proposes a novel binary adaptive clone shuffled leapfrog algorithm (BACSFLA) suitable for EMWSNs. BACSFLA has an excellent performance in the coverage of three-dimensional nodes, which can significantly reduce the network energy consumption of ENWSNs in the coverage process, and greatly improve the coverage of nodes. Through simulation experiments, BACSFLA was compared with simulated annealing (SA) and genetic algorithm (GA) in the same conditional parameters. The coverage rate of BACSFLA in EMWSNs is 3.9 % higher than that of GA and 5.4 % higher than that of SA. The network energy consumption of BACSFLA is 36.0 % lower than GA and 35.9 % lower than SA. Moreover, BACSFLA can significantly reduce the calculation time and get better results in a shorter time.

With the continuous development of computer and network technology, the large-scale and clustered operations of drones have gradually become a reality. How to realize the reasonable allocation of UAV cluster combat tasks and realize the intelligent optimization control of UAV cluster is one of the most challenging difficulties in UAV cluster combat. Solving the task allocation problem and finding the optimal solution have been proven to be an NP-hard problem. This paper proposes a CSA-based approach to simultaneously optimize four objectives in multi-UAV task allocation, i.e., maximizing the number of successfully allocated tasks, maximizing the benefits of executing tasks, minimizing resource costs, and minimizing time costs. Experimental results show that, compared with the genetic algorithm, the proposed method has better performance on solving the UAV task allocation problem with multiple objectives.

Code cloning, which reuses a fragment of source code via copy-and-paste with or without modifications, is a common way for code reuse and software prototyping. However, the duplicated code fragments often affect software quality, resulting in high maintenance cost. The existing clone detectors using shallow textual or syntactical features to identify code similarity are still ineffective in accurately finding sophisticated functional code clones in real-world code bases. This article proposes functional code clone detector using attention ( FCCA ), a deep-learning-based code clone detection approach on top of a hybrid code representation by preserving multiple code features, including unstructured (code in the form of sequential tokens) and structured (code in the form of abstract syntax trees and control-flow graphs) information. Multiple code features are fused into a hybrid representation, which is equipped with an attention mechanism that pays attention to important code parts and features that contribute to the final detection accuracy. We have implemented and evaluated FCCA using 275 777 real-world code clone pairs written in Java. The experimental results show that FCCA outperforms several state-of-the-art approaches for detecting functional code clones in terms of accuracy, recall, and F1 score.

Online code clones are code fragments that are copied from software projects or online sources to Stack Overflow as examples. Due to an absence of a checking mechanism after the code has been copied to Stack Overflow, they can become toxic code snippets, e.g., they suffer from being outdated or violating the original software license. We present a study of online code clones on Stack Overflow and their toxicity by incorporating two developer surveys and a large-scale code clone detection. A survey of 201 high-reputation Stack Overflow answerers (33% response rate) showed that 131 participants (65%) have ever been notified of outdated code and 26 of them (20%) rarely or never fix the code. 138 answerers (69%) never check for licensing conflicts between their copied code snippets and Stack Overflow's CC BY-SA 3.0. A survey of 87 Stack Overflow visitors shows that they experienced several issues from Stack Overflow answers: mismatched solutions, outdated solutions, incorrect solutions, and buggy code. 85% of them are not aware of CC BY-SA 3.0 license enforced by Stack Overflow, and 66% never check for license conflicts when reusing code snippets. Our clone detection found online clone pairs between 72,365 Java code snippets on Stack Overflow and 111 open source projects in the curated Qualitas corpus. We analysed 2,289 non-trivial online clone candidates. Our investigation revealed strong evidence that 153 clones have been copied from a Qualitas project to Stack Overflow. We found 100 of them (66%) to be outdated, of which 10 were buggy and harmful for reuse. Furthermore, we found 214 code snippets that could potentially violate the license of their original software and appear 7,112 times in 2,427 GitHub projects., IEEE Transactions on Software Engineering (Early Access)

Making logical copies, or clones, of files and directories is critical to many real-world applications and workflows, including backups, virtual machines, and containers. An ideal clone implementation meets the following performance goals: (1) creating the clone has low latency; (2) reads are fast in all versions (i.e., spatial locality is always maintained, even after modifications); (3) writes are fast in all versions; (4) the overall system is space efficient. Implementing a clone operation that realizes all four properties, which we call a nimble clone , is a long-standing open problem. This article describes nimble clones in B-ϵ-tree File System (BetrFS), an open-source, full-path-indexed, and write-optimized file system. The key observation behind our work is that standard copy-on-write heuristics can be too coarse to be space efficient, or too fine-grained to preserve locality. On the other hand, a write-optimized key-value store, such as a Bε-tree or an log-structured merge-tree (LSM)-tree, can decouple the logical application of updates from the granularity at which data is physically copied. In our write-optimized clone implementation, data sharing among clones is only broken when a clone has changed enough to warrant making a copy, a policy we call copy-on-abundant-write . We demonstrate that the algorithmic work needed to batch and amortize the cost of BetrFS clone operations does not erode the performance advantages of baseline BetrFS; BetrFS performance even improves in a few cases. BetrFS cloning is efficient; for example, when using the clone operation for container creation, BetrFS outperforms a simple recursive copy by up to two orders-of-magnitude and outperforms file systems that have specialized Linux Containers (LXC) backends by 3--4×.

There can be many reasons for anyone to make a digital copy (clone) of own decision-making behavior. This enables virtual presence of a professional decision-maker simultaneously in many places and processes of Industry 4.0. Such clone can be used as one’s responsible representative when the human is not available. Pi-Mind (“Patented Intelligence”) is a technology, which enables “cloning” cognitive skills of humans using adversarial machine learning. In this paper, we present a cyber-physical environment as an adversarial learning ecosystem for cloning image classification skills. The physical component of the environment is provided by the logistic laboratory with camera-surveillance over the conveyors. The digital component of the environment contains special modifications of Generative Adversarial Networks, which include a human-operator as a trainer, an autonomous Pi-Mind clone as a trainee (a discriminator) and a smart digital adversary as a challenger (generator of sophisticated decision situations, emergencies and attacks, which supposedly catalyzes the cloning process).

Internet of Things (IoT) is a term associated with the use of IP (Internet Protocol) address sensors. It can connect to the internet and collect sensor data. The information is analyzed and a decision is made automatically. With an IoT medical device, your doctor can monitor the patient's health, health, and well-being. Physiological medical devices and methods can be easily traced. Timely monitoring of the patient's physiological parameters can be helpful to avoid early health problems. Security issues identified in medical IoT communication can be weak due to the reliability or vulnerability of the system. We later suggested filtering for anonymity. It is known for its features such as anonymous sensors, sensor traceability, playback, and ensuring that clone attacks are carried out. The proposed authentication system would be useful for IoT application distribution.

For software engineering, if two code fragments are closely similar with minor modifications or even identical due to a copy-paste behavior, that is called software/code clone. Code clones can cause trouble in software maintenance and debugging process because identifying all copied compromised code fragments in other locations is time-consuming. Researchers have been working on code clone detection issues for a long time, and the discussion mainly focuses on software engineering management and system maintenance. Another considerable issue is that code cloning provides an easy way to attackers for malicious code injection. A thorough survey work of code clone identification/detection from the security perspective is indispensable for providing a comprehensive review of existing related works and proposing future potential research directions. This paper can satisfy above requirements. We review and introduce existing security-related works following three different classifications and various comparison criteria. We then discuss three further research directions, (i) deep learning-based code clone vulnerability detection, (ii) vulnerable code clone detection for 5G-Internet of Things devices, and (iii) real-time detection methods for more efficiently detecting clone attacks. These methods are more advanced and adaptive to technological development than current technologies, and still have enough research space for future studies.

Code clones are frequent in use because they can be created fast with little effort and expense. Especially for malware writers, it is easier to create a clone of the original than writing a new malware. According to the recent Symantec threat reports, Android continues to be the most targeted mobile platform, and the number of new mobile malware clones grew by 54%. There is a need to develop techniques and tools to stop this attack of Android malware clones. To stop this attack, we propose DroidClone that exposes code clones (segments of code that are similar) in Android applications to help detect malware. DroidClone is the first such effort uses specific control flow patterns for reducing the effect of obfuscations and detect clones that are syntactically different but semantically similar up to a threshold. DroidClone is independent of the programming language of the code clones. When evaluated with real malware and benign Android applications, DroidClone obtained a detection rate of 94.2% and false positive rate of 5.6%. DroidClone, when tested against various obfuscations, was able to successfully provide resistance against all the trivial (Renaming methods, parameters, and nop insertion, etc) and some non-trivial (Call graph manipulation and function indirection, etc.) obfuscations.

Rehearsal-based interfaces are designed to encourage a transition from novice to expert, but many users fail to make this transition. Most of these interfaces activate novice mode after a short delay, between 150 and 500 ms. We investigate the impact of delay time on expert usage and learning in three crowdsourced experiments. The first experiment examines an 8-item marking menu with delay times from 200 ms to 2 s. Results show longer delays increase successful expert selections. The second and third experiments generalise this result to a different rehearsal-based menu, a desktop clone of FastTap with 8 items and 15 items. Together, our results show that expert use correlates positively with increased delay time, but can increase errors since users are less risk averse. We also find imperceptible delays of 200 ms can harm long-term retention of menu items. Designers should consider longer delays in rehearsal-based interfaces to encourage a transition to expert usage.

Code clones are identical or similar code segments. The wide existence of code clones can increase the cost of maintenance and jeopardise the quality of software. The research community has developed many techniques to detect code clones, however, there is little evidence of how these techniques may perform in industrial use cases. In this paper, we aim to uncover the differences when such techniques are applied in industrial use cases. We conducted large scale experimental research on the performance of two state-of-the-art code clone detection techniques, SourcererCC and AutoenCODE, on both open source projects and an industrial project written in the Scala language. Our results reveal that both algorithms perform differently on the industrial project, with the largest drop in precision being 30.7\%, and the largest increase in recall being 32.4\%. By manually labelling samples of the industrial project by its developers, we discovered that there are substantially less Type-3 clones in the aforementioned project than that in the open source projects., Comment: Presented at IWSC SANER 2020

Internet of things (IoT) technologies have recently gained much interest from numerous industries, where devices, machines, sensors, or simply things are linked with each other over open communication networks. However, such an operation environment brings new security threats and technology challenges in securing and stabilizing such large systems in the IoT world. Device identity in such an environment is an essential security requirement as a secure anchor for most applications towards clone-resistant resilient operational security. This paper analyzes different contemporary authenticated identification techniques and discusses possible future technologies for physically clone-resistant IoT units. Two categories of identification techniques to counteract cloning IoT units are discussed. The first category is inherently cloneable and includes the classical identification mechanisms based on secret and public key cryptography. Such techniques deploy mainly secret keys stored permanently somewhere in the IoT devices as classical means to make units clone-resistant. However, such techniques are inherently cloneable as the manufacturer or device personalizers can clone them by re-using the same secret key (which must be known to somebody) or reveal keys to third parties to create cloned entities. In contrast, the second, more resilient category is inherently unclonable because it deploys unknown and hard to predict born analog modules such as physical unclonable functions (PUFs) or mutated digital modules and so-called secret unknown ciphers (SUCs). Both techniques are DNA-like identities and hard to predict and clone even by the manufacturer itself. Born PUFs were introduced two decades ago, however, PUFs as analog functions failed to serve as practically usable unclonable electronic identities due to being costly, unstable/inconsistent, and non-practical for mass application. To overcome the drawbacks of analog PUFs, SUCs techniques were introduced a decade ago. SUCs, as mutated modules, are highly consistent, being digital modules. However, as self-mutated digital modules, they offer only clone-resistant identities. Therefore, the SUC technique is proposed as a promising clone-resistant technology embedded in emerging IoT units in non-volatile self-reconfiguring devices. The main threats and expected security requirements in the emerging IoT applications are postulated. Finally, the presented techniques are analyzed, classified, and compared considering security, performance, and complexity given future expected IoT security features and requirements.

In software, clones are syntactically or semantically identical of two code fragments. Cloning by either deliberately or by coincidence. Cloning has pros and cons in software development. Bug propagation may be caused by cloning from original to copied segments. Cloning may lead to difficulties in software maintenance. Cloning is helpful in many functions like code reusability, inheritance, and libraries. Software developers before scripting the code design the model for it. Cloning can exist at any stage either at the design or coding phase, which influences on development, quality, and maintenance of the software. All software has constraints like budget and time are associated. In software development, life cycle budget and time constraints depend on irregularity and risk. These irregularities and risks can be minimized by identifying clones. There are different kinds of clones in Code and Model. In this paper, we present a concise summary of design and coding phase clone detection of these irregularities and risk as well as their for's and against of code clone detection and model clone detection.

Code reuse is a frequent practice in mal ware development and finding code similar to known mal ware can thus be a promising strategy for mal ware detection. In this paper, we analyze the use of the clone detector StoneDetector for finding Android malware. To this end, signatures of known malware are generated and used to look for suspicious code fragments in Android APK packages. Feasibility of the approach is shown for a case study on samples of the FinSpy mal ware family.

Managing clones proactively is one of the hot research areas under Software Cloning domain. Researchers of the Clone Research Community argue that it is better to avoid clones rather than to refact...

Developers frequently introduce code clones into software through the copy-and-paste operations during the software development phase in order to shorten development time. Not all such clone creations are beneficial to software maintenance, as they may introduce extra effort at the software maintenance phase, where additional care is needed to ensure consistent change among these clones; i.e., changes made to a piece of code may need to be propagated to other clones. Failure in doing so may risk introducing bugs into software, which are usually called consistent defect. In response to the rampant maintenance cost caused by the introduction of new clones, some researchers have advocated the use of machine-learning approach to predict the likelihood of consistent change requirement when clones are freshly introduced. Leading in this approach is the work by Wang et al., which uses Bayesian Network to model maintenance-consistency of newly introduced clones. In this work, we leverage the success of the above-mentioned work by providing a revised set of attributes that has been shown to strengthen the predictive power of the Bayesian network model, as determined more quantitatively by the precision and recall levels. We firstly provide the definition of clone consistency-maintenance requirement, which can help transfer this problem to a classification problem. Then, based on collecting all clone creation operations through traversing clone genealogies, we redesign the attribute sets for representing clone creation with more information in code and context perspective. We evaluate the effectiveness of our approach on four open source projects with more quantitative analysis, and the experimental results show that our approach possesses a powerful ability in predicting clone consistency. To transfer this work into practice, we develop an Eclipse plug-in tool of this prediction to aid developers in software development and maintenance.

The recent state of the art innovations in technology enables the development of low-cost sensor nodes with processing and communication capabilities. The unique characteristics of these low-cost sensor nodes such as limited resources in terms of processing, memory, battery, and lack of tamper resistance hardware make them susceptible to clone node or node replication attack. The deployment of WSNs in the remote and harsh environment helps the adversary to capture the legitimate node and extract the stored credential information such as ID which can be easily re-programmed and replicated. Thus, the adversary would be able to control the whole network internally and carry out the same functions as that of the legitimate nodes. This is the main motivation of researchers to design enhanced detection protocols for clone attacks. Hence, in this paper, we have presented a systematic literature review of existing clone node detection schemes. We have also provided the theoretical and analytical survey of the existing centralized and distributed schemes for the detection of clone nodes in static WSNs with their drawbacks and challenges.

To detect large-variance code clones (i.e. clones with many modifications) in large-scale code repositories is difficult because most current tools can only detect almost identical or very similar clones. It has an important impact on downstream software applications such as bug detection, code completion, software analysis, etc. Recently, CCAligner made an attempt to detect the code clones with insertions or deletions in one place, which were called large-gap clones . Our contribution is to develop a novel and effective detection approach of large-variance clones to more general cases for not only the concentrated code modifications but also the scattered code modifications. A detector named LVMapper is proposed, borrowing and changing the approach of sequencing alignment in bioinformatics which can find two similar sequences with more differences. The ability of LVMapper was tested on 8 open source projects datasets, and the results show that LVMapper detected more than 5 times of large-variance clones compared with other state-of-the-art tools including CCAligner. Furthermore, our new tool also presents comparable recall for general Type-1, Type-2 and Type-3 clones with precision of 88.5% on the widely used benchmarking dataset BigCloneBench.

To assist developers refactored code and to enable improvements to software quality when numbers of clones are found in software programs, we require an approach to advise developers on what a clone needs to refactor and what type of refactoring is needed. This paper suggests a unique learning method that automatically extracts features from the detected code clones and trains models to advise developers on what type needs to be refactored. Our approach differs from others, which specifies types of refactored clones as classes and creates a model for detecting the types of refactored clones and the clones which are anonymous. We introduce a new method by which to convert refactoring clone type outliers into Unknown clone set to improve classification results. We present an extensive comparative study and an evaluation of the efficacy of our suggested idea by using state-of-the-art classification models.

Software clone detection is an emerging research area in the field of software engineering. Software systems are subjected to continuous modifications in source code to improve the performance of the software, which may lead to code redundancy. Duplicate code/code clone is a piece of code reworked several times in software programs due to copy paste activity or reusability of existing software. Code clone is a prime subject in software evolution. Detection of software clones at the time of software evolution may improve the performance of software and reduce the maintenance cost and effort. This paper proposes metric based methods to detect code clones, as software clone is a universal problem in large scale programming environment. This paper introduces two metric based approaches to detect code clones by comparing (i) Control Statement Features (ii) Program Features like different types of statements, operators and operands. In order to demonstrate the effectiveness of the proposed approaches, extensive experiments are conducted on two datasets, C projects of Bellon's benchmark dataset and student lab programs (SLP).The methods efficiently identify similar functional clones. Proposed models only find similarity of whole programs but intelligent enough to highlight similar code segments across program files.

This final paper of the series discusses implications of various aspects of using clones in forestry. Benefits from using clones are considerable. A large benefit arises from the ability to deploy genetic gain much sooner than is possible through conventional seed orchards. This benefit applies even to the use of clones to implement family forestry, even though the clones themselves are not tested. The requirement for genetic diversity at both the stand and landscape levels requires active management to ensure that diversity is conserved. This is achieved partly through the management of breeding populations, as well as by managing the genetic diversity and number of genotypes deployed in clone mixtures. A numerical example is given comparing diversity of clone and seed orchard deployment over time. Many aspects of managing concerns about using clones are about communication to clarify public perceptions and establishing a code of practice.

Mobile robots have shown the capability to address difficult challenges ranging from disaster response to autonomous delivery of goods. However, the robots designed for one environment are often unable to perform effectively in other settings, and frequently require reconfiguration on software and/or hardware levels. Therefore, authors have designed a new immunity-based arbitration scheme to dynamically reconfigure mobile robots during their activity in unknown environments. The technique continuously selects the most suitable modules from its library e.g. sensor-configuration and navigation approach, on the basis of immunological mechanism of clonal selection. The technique successfully arbitrates different robot-configurations because of its ability to clone, mutate and select the suitable antibodies as well as to dynamically change the antibody concentrations. Moreover, maintenance of low inflammation levels alongside low collision count and slow battery drainage clearly illustrates the effectiveness of the presented technique.

With the era of big data approaching, the number of software systems, their dependencies, as well as the complexity of the individual system is becoming larger and more intricate. Understanding these evolving software systems is thus a primary challenge for cost-effective software management and maintenance. In this paper we perform a case study with evolving code clones. The programmers often need to manually analyze the co-evolution of clone fragments to decide about refactoring, tracking, and bug removal. However, manual analysis is time consuming, and nearly infeasible for a large number of clones, e.g., with millions of similarity pairs, where clones are evolving over hundreds of software revisions.We propose an interactive visual analytics system, Clone-World, which leverages big data visualization approach to manage code clones in large software systems. Clone-World, gives an intuitive yet powerful solution to the clone analytic problems. Clone-World combines multiple information-linked zoomable views, where users can explore and analyze clones through interactive exploration in real time. User studies and experts’ reviews suggest that Clone-World may assist developers in many real-life software development and maintenance scenarios. We believe that Clone-World will ease the management and maintenance of clones, and inspire future innovation to adapt visual analytics to manage big software systems. Keywords: Visual analytics, Software clones, Multivariate networks

Wireless sensor network (WSN) is implemented using low priced sensor nodes. These nodes are constrained in terms or memory, battery life, and computations. WSNs can monitor environmental conditions and are typically deployed in places that cannot be attended by humans like forests. The sensor nodes can be attacked in many ways and are vulnerable where a clone attack is one of the most dangerous attacks. In a clone attack, the sensor nodes are captured and clone where many sensors have the same ID. Secret information like credentials and keys are shared and deployed in other networks. Since, identifying a clone node is difficult, the attacker exploits these situation and uses it as the base for several dangerous attacks like black hole. Thus, detecting such loose points in a WSN is a challenging activity. This paper reviews different types of attacks on WSNs and existing detection mechanisms. This review can help in understanding the minimum elements required while designing a generic defense wall against node replication attacks.

Automated production systems (aPS) are highly customized systems that consist of hardware and software. Such aPS are controlled by a programmable logic controller (PLC), often in accordance with the IEC 61131-3 standard that divides system implementation into so-called program organization units (POUs) as the smallest software unit and is comprised of multiple textual and graphical programming languages that can be arbitrarily nested. A common practice during the development of such systems is reusing implementation artifacts by copying, pasting, and then modifying code. This approach is referred to as code cloning. It is used on a fine-granular level where a POU is cloned within a system variant. It is also applied on the coarse-granular system level, where the entire system is cloned and adapted to create a system variant, for example for another customer. This ad hoc practice for the development of variants is commonly referred to as clone-and-own. It allows the fast development of variants to meet varying customer requirements or altered regulatory guidelines. However, clone-and-own is a non-sustainable approach and does not scale with an increasing number of variants. It has a detrimental effect on the overall quality of a software system, such as the propagation of bugs to other variants, which harms maintenance. In order to support the effective development and maintenance of such systems, a detailed code clone analysis is required. On the one hand, an analysis of code clones within a variant (i.e., clone detection in the classical sense) supports experts in refactoring respective code into library components. On the other hand, an analysis of commonalities and differences between cloned variants (i.e., variability analysis) supports the maintenance and further reuse and facilitates the migration of variants into a software product line (SPL)., JSS: Special Issue on Clone Detection

This paper describes a hardware lab where computer science students build a computer from scratch on a breadboard. The design is inspired by hobbyist-built 1970s computers, such as the Altair, and the finished computer runs the original Altair BASIC. The lab uses mostly period-appropriate but easily obtainable components, and is accompanied by a detailed writeup that takes the students step-by-step through construction. The lab was assigned to a History of Computing elective class, and every student, regardless of previous hardware experience, successfully completed it.

In the automation domain programs are written by engineers. Available programming languages are normally standard IEC 61131-3 or vendor specific visual language. Programming requires domain knowledge and programming skills. Reusing programs is often simple copy / clone a working solution. There are different kinds of solutions done to effective produce programs. In Metso Automation application programs are first modeled and second systematically reused. The principles are applicable to be used in other context.

One of the attacks in the RPL protocol is the Clone ID attack, that the attacker clones the node’s ID in the network. In this research, a Clone ID detection system is designed for the Internet of Things (IoT), implemented in Contiki operating system, and evaluated using the Cooja emulator. Our evaluation shows that the proposed method has desirable performance in terms of energy consumption overhead, true positive rate, and detection speed. The overhead cost of the proposed method is low enough that it can be deployed in limited-resource nodes. The proposed method in each node has two phases, which are the steps of gathering information and attack detection. In the proposed scheme, each node detects this type of attack using control packets received from its neighbors and their information such as IP, rank, Path ETX, and RSSI, as well as the use of a routing table. The design of this system will contribute to the security of the IoT network.

Research in automatic program repair has shown that real bugs can be automatically fixed. However, there are several challenges involved in such a task that are not yet fully addressed. As an example, consider that a test-suite-based repair tool performs a change in a program to fix a bug spotted by a failing test case, but then the same or another test case fails. This could mean that the change is a partial fix for the bug or that another bug was manifested. However, the repair tool discards the change and possibly performs other repair attempts. One might wonder if the applied change should be also applied in other locations in the program so that the bug is fully fixed. In this paper, we are interested in investigating the extent of bug fix changes being cloned by developers within patches. Our goal is to investigate the need of multi-location repair by using identical or similar changes in identical or similar contexts. To do so, we analyzed 3,049 multi-hunk patches from the ManySStuBs4J dataset, which is a large dataset of single statement bug fix changes. We found out that 68 % of the multi-hunk patches contain at least one change clone group. Moreover, most of these patches (70 %) are strictly-cloned ones, which are patches fully composed of changes belonging to one single change clone group. Finally, most of the strictly-cloned patches (89 %) contain change clones with identical changes, independently of their contexts. We conclude that automated solutions for creating patches composed of identical or similar changes can be useful for fixing bugs.

At present, assignment plagiarism is common in higher education at home and abroad especially in the coursework of computer majors. How to detect code plagiarism in programming course assignments effectively is a significant problem. The classic methods of code plagiarism detection mainly use the attribute or structure information to measure the similarity of source codes. In this dissertation, the definition and general process of clone plagiarism detection, different code clone detection technologies and the related tools are introduced.

Code clone is a common phenomenon in the rapid development of the software ecosystem and open source community, which can improve efficiency, while leading to many negative effects on software maintenance at the same time. In this paper, we propose CCEyes, an effective tool for code clone detection on GitHub. We build a semantic vector representations corpora database of large-scale open sourse codes by the deep learning-based method that can automatically learn program features to address the resource challenge. CCEyes returns the detection results according to the user's input, including similar clone code fragments, similarity analysis and repository address on GitHub. Among which the Recursive Autoencoder is designed to learn code representation and then the comparator network is employed for similarity evaluation. We conduct comprehensive experiments on the ability of the detection method, the effectiveness of database storage. Besides, we also compare CCEyes with other application tools and conduct a user study. The evalution results in that CCEyes outperforms state-of-the-art.

Software clones are code fragments with similar or nearly similar functionality or structures. These clones are introduced in a project either accidentally or deliberately during software development or maintenance process. The presence of clones poses a significant threat to the maintenance of software systems and is on the top of the list of code smell types. Clones can be simple (fine-grained) or high-level (coarse-grained), depending on the chosen granularity of code for the clone detection. Simple clones are generally viewed at the lines/statements level, whereas high-level clones have granularity as a block, method, class, or file. High-level clones are said to be composed of multiple simple clones. This study aims to detect high-level conceptual code clones (having granularity as java methods) in java-based projects, which is extendable to the projects developed in other languages as well. Conceptual code clones are the ones implementing a similar higher-level abstraction such as an Abstract Data Type (ADT) list. Based on the assumption that “similar documentation implies similar methods”, the proposed mechanism uses “documentation” associated with methods to identify method-level concept clones. As complete documentation does not contribute to the method’s semantics, we extracted only the description part of the method’s documentation, which led to two benefits: increased efficiency and reduced text corpus size. Further, we used Latent Semantic Indexing (LSI) with different combinations of weight and similarity measures to identify similar descriptions in the text corpus. To show the efficacy of the proposed approach, we validated it using three java open source systems of sufficient length. The findings suggest that the proposed mechanism can detect methods implementing similar high-level concepts with improved recall values.

Code clones are identical or similar code in software projects. On one hand, developers clone code to achieve higher productivity and thus clones inherently exist; on the other hand, code clones demand extra effort to maintain the consistency between clone instances and may introduce bugs, and thus are often considered harmful for software maintenance and quality. We believe that not all code clones have the same level of harmfulness. A systematic way of assessing the harmfulness level of cloned code would facilitate informed decisions on how to deal with clones. We propose a model for clone harmfulness level assessment with four quantitative indicators that can be extracted from the evolution history of the clones. Specifically, we gather information, such as code clone changes and bug- fixes related to clone divergence and re-synchronization, to find objective evidence that a clone harms the software quality or brings potential risks even if no bugs are found. The assessment model consists of four harmfulness levels of clones determined by the four indicators. We also derive three harmfulness factors from the intrinsic properties of clones that potentially affect the harmfulness of clones. We conduct a large-scale empirical study with five open-source and three industry systems and find that 61.0-84.7% of the clones are not harmful in terms of consistent maintenance overhead. We find evidence in the evolution history that several factors, such as spread of clone instances, number of clone instances, and number of developers, have non-trivial correlation with clone harmfulness levels. We also propose six counter measures for clone harmfulness mitigation based on the observation of the harmfulness factors, and have collected useful feedback from industrial software architects and senior developers through an interview meeting.

Clone node attack is one of the major security issues in wireless sensor networks. Basically wireless sensor network is the combination of several sensor nodes which is deployed in some hostile environment to monitor that environment. There are various specific use of this network like system monitoring and analysing different properties of environment, household monitoring and it ranges up to military application also. The researchers are also facing lot of difficulties in the detection of clone node. Detection of a cloned node intruder in Homogenous Wireless Sensor Networks has many useful application in terms that they can be deployed in war zones for detecting intruder (enemies) and uniquely identify them which helps in preventing any harmful situation they can create when they continue to exist inside the system. This intrusion detection system is used to identify the mismatched, malicious, non-orient able nodes and false committing nodes. For demonstrating our work we have taken into account detection intrusion in a Heterogeneous network. For this we have taken into account Single –capability sensor detection and Multiple – capabilities sensor detection in heterogeneous connected wireless network.

Scarless genome editing is an important tool for the accurate recapitulation of genetic variation in human disease models. Various CRISPR/Cas9-based scarless editing methods have been reported. However, some of these methods have low editing efficiency (1-5%) and require manual selection of hundreds of clones to reach the desired number. Other protocols use large selection cassettes with laborious vector assembly and specialized reagents and equipment, or have poorly understood off-target effects. To address these limitations, we developed a simple, highly efficient scarless editing strategy to edit DNA sequences in induced pluripotent stem cells, which we call CRISPR Del/Rei. This novel editing strategy consists of a two-step deletion-reinsertion strategy that produces isogenic clones in ~8 weeks using accessible, user-friendly reagents. The editing efficiency ranges from ~15-100% for Step 1 and ~5-20% for Step 2 after selection, which greatly reduces the amount of required manual clone isolation. Screening the transfected bulk cells and the individual clones is rapid and simple, consisting of PCR and gel electrophoresis. Despite the two editing steps, off-target effects are rare. Additionally, the experiment is well-controlled because the same protocol generates isogenic clones carrying all variant alleles. In this way, CRISPR Del/Rei serves as a valuable addition to the evolving CRISPR/Cas9 gene-editing toolset.

Music is one of the most appreciated forms of art, and generating songs has become a popular subject in the artificial intelligence community. There are various networks that can produce pleasant sounding music, but no model has been able to produce music that duplicates the style of a specific artist or artists. In this paper, we extend a previous single-instrument model: the Deep Composer-a model we believe to be capable of achieving this. Deep Composer originates from the Deep Segment Hash Learning (DSHL) single instrument model and is designed to learn how a specific artist would place individual segments of music together rather than create music similar to a specific genre. To the best of our knowledge, no other network has been designed to achieve this. For these reasons, we introduce a new field of study, Intelligence Duplication (ID). AI research generally focuses on developing techniques to mimic universal intelligence. Intelligence Duplication (ID) research focuses on techniques to artificially duplicate or clone a specific mind such as Mozart. Additionally, we present a new retrieval algorithm, Segment Barrier Retrieval (SBR), to improve retrieval accuracy within the hash-space as opposed to a more traditionally used feature-space. SBR prevents retrieval branches from entering areas of low-density within the hash-space, a phenomena we identify and label as segment sparsity. To test our Deep Composer and the effectiveness of SBR, we evaluate various models with different SBR threshold values and conduct qualitative surveys for each model. The survey results indicate that our Deep Composer model is capable of learning music generation from multiple composers. Our extended Deep Composer model provides a more suitable platform for Intelligence Duplication. Future work can apply this platform to duplicate great composers such as Mozart or allow them to collaborate in the virtual space.

This will be one of the shortest chapters in this book. You will test-drive your Linux virtual machines (VMs) to interact with the IOS router, R1, via Telnet. You will learn to create a new GNS3 project, run a quick file transfer testing lab using simple Cisco configurations, and then finally make a clone of the GNS3 project. You are making progressive steps toward Python network automation.

In this chapter, you will be downloading the latest Ubuntu Server 20 bootable image to install and create a virtual machine on your VMware Workstation instance. Ubuntu is a Debian Linux–derivative distro and provides one of the best user experiences on Linux. For most Windows users, Ubuntu Desktop would be the first Linux entry point. However, for this book, we will be using Ubuntu Server 20 instead with a little twist: we will choose to install a UI to add more flexibility to our lab. At the end of this chapter, you will be able to create a Ubuntu Server virtual machine from the ground up, customize selective settings on the operating system, take a snapshot of a virtual machine, and clone a virtual machine

Clones are one of the most widespread code smells, known to negatively affect the evolution of software systems. While there is a large body of research on detecting, managing, and refactoring clones in production code, clones in test code are often neglected in today's literature. In this paper we provide empirical evidence that further research on clones in test code is warranted. By analysing the clones in five representative open-source systems and comparing production code clones to test code clones, we observe that test code contains twice as many clones as production code. A detailed analysis reveals that most test clones are of Type II and Type III, and that many tests are duplicated multiple times with slight modifications. Moreover, current clone detection tools suffer from false negatives, and that this occurs more frequently in test code than in production code (NiCad = 76%, CPD = 90%, iClones = 12%). So even from a tools perspective, specific fine-tuning for test code is needed. (C) 2021 Elsevier Inc. All rights reserved.

Due to code reuse among software packages, vulnerabilities can propagate from one software package to another. Current code clone detection techniques are useful for preventing and managing such vulnerability propagation. When the source code for a software package is not available, such as when working with proprietary or custom software distributions, binary code clone detection can be used to examine software for flaws. However, existing binary code clone detectors have scalability issues, or are limited in their accurate detection of vulnerable code clones.

Similarities are common in software. We observe them at all levels, from software requirements, to design, to program code and to other software artifacts such as models or test cases. Similar program parts are termed code clones. Detection of clones in code, as well as methods to achieve non-redundancy in programs have been an active area of research for last decades. In this chapter, I discuss sources of redundancies, variety of forms of their manifestation, software productivity benefits that can be gained by avoiding clones, and difficulties to realize these benefits with conventional programming languages and design techniques. I point to generative techniques as a promising approach to tap the benefits of non-redundancy. Research so far has mainly focused on detection of similar code fragments, so-called simple clones. The knowledge and possible unification of simple clones can help in maintenance. Still, further gains can be obtained by elevating the level of software similarity analysis to the design-level, larger granularity similar program structures, such as recurring architecture-level patterns of collaborating components. Recurring patterns of simple clones often indicate the presence of interesting higher-level similarities that we call structural clones. Detection of structural clones can help in understanding the design of a system for quality assessment, better maintenance and re-engineering, opening new options for design recovery (reverse engineering) which has been an active area of research for last 25 years, with only limited impact on software practice. In this paper, I broadly discuss the landscape of clone research, with particular emphasis on structural clones (This study was supported by the grant of WZ/WI-IIT/3/2020 from Bialystok University of Technology and founded from the resources for research by Ministry of Science and Higher Education, Poland.)

Code clones are defined as identical or similar program structures that are created by copy-paste or modifying existing codes. They are acquainted with software systems due to the lack of programming skills, time restrictions, and other different constraints on the system as well as on the programming languages. Detection of code clones has many benefits in software development such as decreased maintenance cost, improved software quality, and simple settlements of new changes. In this paper, we have explored different code clone detection techniques and figure out their pros and cons. It assists in understanding the clone detection process and choosing appropriate techniques for detecting possible types of clones whose detection can help in the refactoring and maintenance processes.

With recent advancements in the field of code clone detection, researchers have made it possible to scale large datasets. The scope of scalable and accurate clone detection, however, was limited to Type-1, Type-2, and near-miss Type-3 clones. Most clone detectors fail to detect clones beyond the near-miss Type-3 category as it becomes hard to detect such clones in a scalable manner. There are two main challenges in identifying clones beyond the Type-3 category: (1) Syntactical similarity is low between such complex clones and (2) comparing code snippets leads to prohibitive quadratic comparisons, which causes candidate explosion and leads to scalability issues. Oreo introduces a novel semantic filter named Action filter which filters out a large number of code pairs that do not share semantic similarities, thereby addressing the candidate explosion issue. Moreover, the candidates that pass this filter have high semantic similarity which leads to the detection of complex and semantically similar clones. As many semantically similar candidates may not be clones, Oreo uses a deep learning model to validate the structural similarity between the semantically similar candidates, which leads to greater accuracy in clone detection. Oreo demonstrated broader range of clone detection, high recall, precision, speed, and ability to scale to a large inter-project repository (250MLOC) using a standard workstation. This chapter aims to describe the design decisions and concepts which enabled Oreo to take scalable and accurate clone detection beyond the near-miss clones.

Clone detection is an active area of research. However, there is a marked lack in clone detectors that scale to very large repositories of source code, in particular for detecting near-miss clones where significant editing activities may take place in the cloned code. SourcererCC was developed as an attempt to fill this gap. It is a widely used token-based clone detector that targets three clone types, and exploits an index to achieve scalability to large inter-project repositories using a standard workstation. SourcererCC uses an optimized inverted-index to quickly query the potential clones of a given code block. Filtering heuristics based on token ordering are used to significantly reduce the size of the index, the number of code-block comparisons needed to detect the clones, as well as the number of required token-comparisons needed to judge a potential clone. In the evaluation experiments, SourcererCC demonstrated both high recall and precision, and the ability to scale to a large inter-project repository (250MLOC) even using a standard workstation. This chapter reflects on some of the principle design decisions behind the success of SourcererCC and also presents an architecture to scale it horizontally.

Programmers tend to write code clones unintentionally, which can be easily avoided. Clone change management is a crucial issue in open-source software (OSS) and industrial software development (e.g., development of social infrastructure, financial systems, and medical equipment). When industrial software developers have to fix a defect, they must find the code clones corresponding to the code fragment, including it. To date, several studies have been conducted on the analysis of clone evolution using OSS. However, only a few studies have reported on the application of a clone change notification system to the industrial software development process of our knowledge. In this chapter, first, we introduce a system that notifies about the creation of code clones. Then, we report on our experience with the system after a 40-day long application of it in a corporation’s software development process. In the industrial application, a developer successfully identified ten unintentionally created clones that should be merged. Moreover, we introduce the improvements that were made since we released the initial version of the notification system. Besides, we demonstrate a usage scenario of the current version. The current version of Clone Notifier and its video are available at: https://github.com/s-tokui/CloneNotifier.

Code segments are similar or identical to each other by copy-paste the original code at different locations with or without modifications are called code clones. Code clones are either by intentional or unintentional. In software development reprocess, the original code is most common. If any bug exists in original code segment, the bug remains in all the cloned code. As a result, bug propagation in cloning process affects in software maintenance. Detection and corrections are required. Code clone detection appears as an ongoing research area to solve these issues. In this paper, we carried out literature survey of 43 studies to summarize techniques and tools utilized for code clone detection. Six code clone detection techniques are based on text, token, tree, metric, graph, and hybrid to detect type-1, type-2, type-3, and type-4 clones. Our study is concluded with several studies that exist to detect the types 1–4 clones. There is a requirement of novel approach to develop to detect all four types of clones together. In addition, need to develop more approaches to simplify to create program dependency graph for type-4 clone detection.

Eventually, you want to learn Python so you can write code to automate mundane tasks at work. After writing your code and developing your scripted application, you will want to run the scripts without you being in attendance. There is the Windows Task Scheduler on Windows systems, and on Linux, you have cron to help you schedule your script to run at 2 a.m. or to run periodically until you tell your Linux system to stop. You can write and schedule scripts to run automatically once you get comfortable with Python and Linux. You will also want to explore more about how Python works with SNMP so your company can consider SNMP monitoring using an in-house script; you may want to find out how Python interacts with SNMP in general. By the end of this chapter, you will be able to clone the GNS3 project, use cron to schedule tasks on Linux, and interact with routers and switches using SNMPv3. Along the way, we will borrow a Python community member’s publicly shared code to explore SNMPv3 with Python and learn what it can do for us. This chapter aims to give you more exposure to different scenarios while practically applying Python to network automation scenarios.