Reusing and converting code clones to aspects - An algorithmic approach

Abstract: In terms of software, continuous of the software is the best quality assurance. Continuous development requires either the original developer to continue development, or the next generation of developers to take over the development. It has been noted that when the original developer has used a development paradigm in which the source code is kept open to all, highly motivated and competent developers will participate in development. This makes it easier for a project to survive. However, at the same time, when the source code is opened to a broad audience a in the source code tends to occur. When this happens, those with a high level of competence and motivation abandon the development and go their separate ways. In such a situation, it is difficult for a project to survive. In the case of Denshin 8 go, a guardian for the source code was appointed, and the original developer and the guardians avoided this dilemma. Richard Stallman of the GNU project and Linus Torvalds of Linux project act as legitimate guardians to avoid fork.Keywords: software development, open source, fork, buried source code, legitimate guardian, Denshin 8 goIntroductionFor software, continuous of the software is the best quality assurance (Ikuine 8s Fujita, 2013). Continuous development requires either the original developer to continue development or others to take over (Fujita 8s Ikuine, 2013b). When other developers take over, the original developer must share the source code with others. Open Source is a paradigm wherein the source code is shared and made broadly available to others. It has been noted that the project adopting open source can attract competent and highly motivated developers. Thus, some claim that developers can readily ensure the survival of software development projects when the source code is open.However, opening the source code to a broad audience can cause heterogeneity in the source code, even when people continue the development based on the original source code, a phenomenon known as fork (forking). In the case of open source software (hereinafter, OSS), literally anyone can obtain the source code and modify it to develop new software and start up new projects. Therefore, forks often occur in the OSS project, and the impact of forking has been studied for very long (Dibona, Ockman, 8s Stone, 1999; Kogut 8s Metiu, 2001; Nyman 8s Lindman, 2013; Nyman, Mikkonen, Lindman, 8s Fougere, 2012; Raymond, 1997, 1999). Moreover, some studies have focused on how to maintain forked projects, under the assumption that forking will inevitably occur (Gamalielesson 8s Lundell, 2013; Ray 8s Kim, 2012; Ray, Wiley, Kim, 2012).When forking does occur, competent and motivated developers start to abandon the project and go their separate ways, which may affect the survival of these projects. In other words, sharing the source code comes with a dilemma. If one loosens restrictions and shares the source code broadly, that project may survive; however, if the project is forked, competent successors with strong skills and desires will end up working on their own, or perhaps inter-project competition may lead to vying for competent successors. On the other hand, while establishing strict conditions and sharing the source code only with a select few may make the source code easy to control and reduce the possibility of forking, it may become more difficult to find competent successors willing to participate under those conditions. This puts the survival of the project at risk. Ensuring the survival of a project requires that one avoid this dilemma of source code sharing.Research on avoiding the has heretofore focused on developer motivation, licenses, and project governance (Ernst, Easterbrook, 8s Mylopoulos, 2010; Neville-Neil, 2011; Nyman 8s Mikkonen, 2011; Robles 8s Gonzalez-Barahona, 2012; Viseur, 2012). However, forking is a phenomenon not limited to OSS, and examples can be seen in Unix as well (Takahashi 8s Takamatsu, 2002, 2013). …

A code clone is a code fragment identical or similar to another code fragment in source code. Some of code clones are considered as a factor of bug replications and make it more difficult to maintain software. Various code clone detection tools have been proposed so far. However, in most algorithms adopted by existing clone detection tools, if program statements are reordered, they are not detected as code clones. In this research, we examined how clone detection results change by rearranging the order of program statements. We performed preprocessing to rearranging the order of program statements using program dependency graph (PDG). We compared clone detection results with and without preprocessing. As a result, by rearranging the order of program statements, the number of detected code clones is almost the same in most projects. We classified newly detected or disappeared clones manually. From our experimental results, we show that there is no newly detected clone whose statements are reordered and that there are four disappeared clones whose statements are reordered. We think three out of the four clones occurred by copy-and-paste operations. Therefore, we conclude that rearranging the order of program statements is not effective to detect reordered code clones.

Many WCET analysis tools developed in academia integrate WCET analysis into program compilation, either to transform flow information extracted from the source code level to the object code level, or to perform flow analysis on a special intermediate representation. This integration increases analysis complexity, forces software developers to use a special compiler, and thus, strongly limits the usability of the tools in practice. Motivated by this limitation in the existing flow analysis approaches, this paper presents a more efficient approach, that performs flow analysis on the intermediate source code (ISC), transformed from the original source code. ISC retains the functional behavior and executability of the original source code but has a structure close to the object code. This low level structure facilitates the transformation of the flow facts, extracted from the ISC, down to the object code level. In the whole approach, no modification of standard tools is needed.

So far, a lot of techniques have been developed on the detection of code clones (i.e., duplicated code) in large-scale source code. Currently, the code clone research community is gradually shifting its focus of attention from the detection to the management (e.g., clone refactoring). During clone management, developers need to understand how and why code clones are scattered in source code, and then decide how to handle those code clones. In this paper, we present a clone analysis tool with tag cloud visualization. This tool is aimed at helping to understand why code clone are concentrated in a part of a software system by generating tag clouds from a collection of identifier names in source code.

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.

소프트웨어 산업은 21세기 정보화 사회의 발전에 있어서도 중요한 역할을 하고 있다. 소프트웨어 소스 코드의 소유권 분쟁이 발생 시 소유권을 증명하기 위해서는 원본의 소프트웨어 소스코드를 판별해야만 하는 문제점을 갖고 있다. 본 논문에서는 소프트웨어 소스코드의 원본 판별을 지원하기 위한 소프트웨어 소스코드의 디지털 라이센스는 소스코드의 예약어를 파싱하여 계층구조를 갖는 XML 파일로 표현하며, 복잡한 소스코드 대신에 소프트웨어 소스코드의 노드 패턴과 아키텍처 패턴인 트리 구조 형태로 표현할 수 있다. 그리고 디지털 라이센스에 의한 소스코드의 분류 가능성에 대한 시뮬레이션과 크립텍스 모델을 제안한다. The software industry is so important to the 21C information society Not only the digital content control but the technology of software source code for the intellectual property is so much mean to international competition. On occurring disputation property of software source code, we have to prove the fact, there is a problem to discriminate the original software source code. In this paper, we make a study of the digital licence prototype for discriminate the original source code. Reserved words of software source code by parsing express to XML file that have hierarchical structure. Then, we can express node pattern and architecture pattern of software source code by tree structure form instead of complex software source code. And we make a simulation of discrimination possibility of digital license and propose CRYPTEX model.

The lack of compatibility of High‐Performance Fortran (HPF) between vender implementations has been disheartening scientific application users so as to hinder the development of portable programs. Thus parallel computing is still unpopular in the computational science community, even though parallel programming is common to the computer science community. As users would like to run the same source code on parallel machines with different architectures as fast as possible, we have investigated the compatibility of source codes for Japanese HPF compilers (NEC, Fujitsu and Hitachi) with two real‐world applications: a 3D fluid code and a 2D particle code. We have found that the source‐level compatibility between Japanese HPF compilers is almost preserved, but more effort will be needed to sustain complete compatibility. We have also evaluated parallel performance and found that HPF can achieve good performance for the 3D fluid code with almost the same source code. For the 2D particle code, good results have also been obtained with a small number of processors, but some changes in the original source code and the addition of interface blocks is required. Copyright © 2002 John Wiley & Sons, Ltd.

The widespread availability of Large Language Models (LLMs) has significantly lowered the barrier to committing code plagiarism. However, most existing anti-plagiarism tools remain vulnerable to modern evasion strategies, including syntactic transformations and generative code rewriting. Prior work shows that such transformations can effectively bypass clone detectors that rely on syntactic or semantic representations. While binary optimization is a known technique in malware obfuscation, its potential for plagiarism detection has been largely overlooked. We introduce a hybrid detection method that combines source-level syntactic analysis with binary-level comparison, leveraging both standard compilation outputs and binaries generated with optimization flags. These optimizations act as a reverse filter, eliminating syntactic manipulations added to code artifacts and revealing structural similarities with the original binary. Our empirical evaluation confirms that optimized binaries exhibit patterns that correlate strongly with their original source code. The proposed method demonstrates high effectiveness in detecting plagiarism, even when the source code has undergone aggressive syntactic transformations. This technique serves as a robust and complementary extension to existing syntactic anti-plagiarism systems, offering deeper insight into semantic and structural code similarity.

This report documents the program and the outcomes of Dagstuhl Seminar 12071 ``Software Clone Management Towards Industrial Application''. Software clones are identical or similar pieces of code or design. A lot of research has been devoted to software clones. Unlike previous research, this seminar put a particular emphasis on industrial application of software clone management methods and tools and aimed at gathering concrete usage scenarios of clone management in industry, which will help to identify new industrially relevant aspects in order to shape the future research. Talks were presented by industrial participants and working groups were formed to discuss issues in clone detection, presentation, and refactoring. In addition we developed a unified conceptual model to capture clone information required to support a common notion of clone data and for interoperability to foster exchange of data among researchers and tools in practice. The main focus of current research is clones in source code -- therefore, we also looked into ways of extending our research to other types of software artifacts. Last but not least, we discussed how clone management activities may be integrated into the process of software development.

Increasing clone maintenance support by unifying clone detection and refactoring activities

Web services are being embraced by IT industry in the recent past to enable rapid development of distributed systems with optimal cost. Web services in SOA are self-adaptable to context, which makes SOA widely recognized in IT system as the technology, which has the potential of improving the receptiveness of both business and IT organizations. Web services help in building Service Based Systems (SBS) like Paytm, Amazon, Paypal, e-bay etc. which evolves frequently to fit the new user requirements which impacts the evolvability and quality of software design. Similar to software systems built using other paradigms, Service based systems also suffer from bad or poor design choices as in anti-pattern, code smells etc. Anti-patterns are explicit structures in the design that indicates violation of fundamental design principles and negatively impact the design quality. Anti-patterns have obstructive influence on the maintainability and perception of software systems. Thus there is a rising need for the early prediction of anti-patterns and refactoring them to improve the software quality in terms of execution cost, maintenance cost and memory consumption. In this work, a frame work is proposed for significant feature selection from source code metrics which includes Wilcoxon signed rank test, Univariate logistic regression analysis and Cross-correlation analysis. Then the different sets of features from various steps along with the original source code metrics are considered and are used for anti-pattern detection using 13 machine learning algorithms. Experimental results show the approximation capability of different classifiers and data balancing techniques with the features selected from the various steps of feature validation framework in addition to the original features for developing anti-pattern prediction model. The results also shows that the prediction model built with by the ensemble techniques using the features obtained from proposed feature selection framework outperforms other techniques.KeywordsSoftware engineeringAnti-patternWeb serviceImbalanced dataService oriented architectureMachine learningPredictionSource code metric

Federated Learning (FL) is a learning paradigm where multiple nodes collaboratively train a model by only exchanging updates or parameters. This enables to keep data locally, therefore enhancing privacy - statement requiring nuance, e.g. memorization of training data in language models. Depending on the application, the number of samples that each node contains can be very different, which can impact the training and the final performance. This work studies the impact of the per-node sample size distribution on the mean squared error (MSE) of the one-shot federated estimator. We focus on one-shot aggregation of statistical estimations made across disjoint, independent and identically distributed (i.i.d.) data sources, in the context of empirical risk minimization. In distributed learning, it is well-known that for a total number of m nodes, each node should contain at least m samples to equal the performance of centralized training. In a federated scenario, this result remains true, but now applies to the mean of the per-node sample size distribution. The demo enables to visualize this effect as well as to compare the behavior of the FESC (Federated Estimation with Statistical Correction) algorithm - a weighting scheme which depends on the local sample size - with respect to the classical federated estimator and the centralized one, for a large collection of distributions, number of nodes, and features space dimension. **This is an MLBriefs article, the source code has not been reviewed!**<br> **The original source code is [[available here|https://github.com/gonzaq94/one-shot-fed-learning]] (last checked 2023/02/12).**

Program transformations have been advocated as a method for accomplishing reverse engineering. The hypothesis is that the original source code can be progressively transformed into alternative forms, but with the same semantics. At the end of the process, an equivalent program is acquired, but one which is much easier to understand and more maintainable. We have been undertaking an extensive programme of research over twelve years into the design and development of transformations for the support of software maintenance. The paper very briefly explains the theory, practice and tool support for transformational systems, but does not present new theoretical results. The main results are on an analysis of the strengths and weaknesses of the approach, based on experience with case studies and industrial applications. The evaluation framework used (called DERE) is that presented in Bennett and Munro (1998). It is hoped that the results will be of benefit to industry, who might be considering using the technology; and to other researchers, interested in addressing the open problems. The overall conclusion is that transformations can help in the bottom-up analysis and manipulation of source code at approximately the 3GL level, and have proved successful in code migration, but need to be complemented by other top-down techniques to be useful at higher levels of abstraction or in more ambitious re-engineering projects.

Chapter 1 - Introduction

Source code cloning does not happen within a single system only. It can also occur between one system and another. We use the term code sibling to refer to a code clone that evolves in a different system than the code from which it originates. Code siblings can only occur when the source code copyright owner allows it and when the conditions imposed by such license are not incompatible with the license of the destination system. In some situations copying of source code fragments are allowed—legally—in one direction, but not in the other. In this paper, we use clone detection, license mining and classification, and change history techniques to understand how code siblings—under different licenses—flow in one direction or the other between Linux and two BSD Unixes, FreeBSD and OpenBSD. Our results show that, in most cases, this migration appears to happen according to the terms of the license of the original code being copied, favoring always copying from less restrictive licenses towards more restrictive ones. We also discovered that sometimes code is inserted to the kernels from an outside source.