scholarly journals A study of code change patterns for adaptive maintenance with AST analysis

2020 ◽  
Vol 10 (3) ◽  
pp. 2719
Author(s):  
Omar Meqdadi ◽  
Shadi Aljawarneh
Keyword(s):  
Open Source ◽  
Software Evolution ◽  
Source Code ◽  
Transformation Rule ◽  
Primary Concern ◽  
Adaptive Changes ◽  
Code Change ◽  
History Of ◽  
Code Changes ◽  
Open Source Systems

Example-based transformational approaches to automate adaptive maintenance changes plays an important role in software research. One primary concern of those approaches is that a set of good qualified real examples of adaptive changes previously made in the history must be identified, or otherwise the adoption of such approaches will be put in question. Unfortunately, there is rarely enough detail to clearly direct transformation rule developers to overcome the barrier of finding qualified examples for adaptive changes. This work explores the histories of several open source systems to study the repetitiveness of adaptive changes in software evolution, and hence recognizing the source code change patterns that are strongly related with the adaptive maintenance. We collected the adaptive commits from the history of numerous open source systems, then we obtained the repetitiveness frequencies of source code changes based on the analysis of Abstract Syntax Tree (AST) edit actions within an adaptive commit. Using the prevalence of the most common adaptive changes, we suggested a set of change patterns that seem correlated with adaptive maintenance. It is observed that 76.93% of the undertaken adaptive changes were represented by 12 AST code differences. Moreover, only 9 change patterns covered 64.69% to 76.58% of the total adaptive change hunks in the examined projects. The most common individual patterns are related to initializing objects and method calls changes. A correlation analysis on examined projects shows that they have very similar frequencies of the patterns correlated with adaptive changes. The observed repeated adaptive changes could be useful examples for the construction of transformation approaches

scholarly journals Applying Information Measure for Predicting Release Time of Open Source Software

2017 ◽  
Vol 15 (1) ◽  
pp. 29-39
Author(s):  
Talat PARVEEN ◽  
Hari Darshan ARORA
Keyword(s):  
Regression Model ◽  
Open Source ◽  
Open Source Software ◽  
Goodness Of Fit ◽  
Source Code ◽  
Release Time ◽  
Entropy Measure ◽  
Frequent Change ◽  
Code Change ◽  
Code Changes

Open Source Software (OSS) is updated regularly to meet the requirements posed by the customers. The source code of OSS undergoes frequent change to diffuse new features and update existing features in the system, providing a user friendly interface. The source code changes for fixing bugs and meeting user end requirements again affects the complexity of the code change and creates bugs in the software which are accountable to the next release of software. In this paper, the complexity of code changes in various Bugzilla open source software releases, from version 2.0 on 19th Sep, 1998, to 5.0.1 on 10th Sep, 2015, bugs in each software version release, and the time of release of each software version are considered, and the data used to predict the next release time. The Shannon entropy measure is used to quantify the code change process in terms of entropy for each software release. Observed code changes are utilized to quantify them into entropy units and are further used to predict the next release time. A neural network-based regression model is used to predict the next release time. The performance is compared with the R measure calculated using the multi linear regression model, and a goodness of fit curve is produced.

Capturing Spotaneous Software Evolution in a Social Coding Platform With Project-as-a-City Concept

2020 ◽  
Vol 8 (3) ◽  
pp. 35-50
Author(s):  
Koji Toda ◽  
Haruaki Tamada ◽  
Masahide Nakamura ◽  
Kenichi Matsumoto
Keyword(s):  
Experimental Evaluation ◽  
Software Evolution ◽  
Source Code ◽  
The State ◽  
History Of ◽  
Collaborative Activities ◽  
Active Communities ◽  
Spontaneous Evolution

Social coding platforms (SCPs) have realized spontaneous software evolution, where new source code and ideas are spontaneously proposed by altruistic developers. Although there are many projects operated by active communities performing spontaneous evolution, it is yet unclear that how such successful projects and communities have been formed and governed. This article proposes a method that can investigate the history of every project in the SCP. Introducing the concept of project as a city, the authors consider every project in the SCP as a city, where a government and citizens develop a city through collaborative activities. This research then identifies essential attributes that characterize a state of a city. For each attribute, the authors develop metrics that quantify the state S(p; t) of a project p at time t. An experimental evaluation investigating GitHub projects of famous code editors shows that the proposed metrics well visualize the history of the projects from essential perspectives of a city.

scholarly journals Pre-trained deep learning models in automatic COVID-19 diagnosis

2021 ◽  
Vol 22 (3) ◽  
pp. 1540
Author(s):  
Ahmed Wasif Reza ◽  
Md Mahamudul Hasan ◽  
Nazla Nowrin ◽  
Mir Moynuddin Ahmed Shibly
Keyword(s):  
Deep Learning ◽  
Open Source ◽  
Healthcare Professionals ◽  
Automated System ◽  
Primary Concern ◽  
X Rays ◽  
Learning Models ◽  
Efficient System ◽  
Empirical Results ◽  
History Of

Coronavirus Disease (COVID-19) is a devastating pandemic in the history of mankind. It is a highly contagious flu that can spread from human to human without revealing any symptoms. For being so contagious, detecting patients with it and isolating them has become the primary concern for healthcare professionals. This study presented an alternative way to identify COVID-19 patients by doing an automatic examination of chest X-rays of the patients. To develop such an efficient system, six pre-trained deep learning models were used. Those models were: VGG16, InceptionV3, Xception, DenseNet201, InceptionResNetV2, and EfficientNetB4. Those models were developed on two open-source datasets that have chest X-rays of patients diagnosed with COVID-19. Among the models, EfficientNetB4 achieved better performances on both datasets with 96% and 97% of accuracies. The empirical results were also exemplary. This type of automated system can help us fight this dangerous virus outbreak.

scholarly journals The relevance of Open Source to hydroinformatics

2002 ◽  
Vol 4 (4) ◽  
pp. 219-234 ◽  
Author(s):  
Hamish Harvey ◽  
Dawei Han
Keyword(s):  
Operating System ◽  
Software Development ◽  
Open Source ◽  
Open Source Software ◽  
Rapid Development ◽  
Source Code ◽  
Web Server ◽  
High Profile ◽  
History Of ◽  
Closed Approach

Open Source, in which the source code to software is freely shared and improved upon, has recently risen to prominence as an alternative to the more usual closed approach to software development. A number of high profile projects, such as the Linux operating system kernel and the Apache web server, have demonstrated that Open Source can be technically effective, and companies such as Cygnus Solutions (now owned by Red Hat) and Zope Corporation have demonstrated that it is possible to build successful companies around open source software. Open Source could have significant benefits for hydroinformatics, encouraging widespread interoperability and rapid development. In this paper we present a brief history of Open Source, a summary of some reasons for its effectiveness, and we explore how and why Open Source is of particular interest in the field of hydroinformatics. We argue that for technical, scientific and business reasons, Open Source has a lot to offer.

Investigation of the Software Code Vulnerabilities' Impact on the Popularity of Open Source Software Projects

2021 ◽  
Vol 14 (3) ◽  
pp. 58-69
Author(s):  
Madanjit Singh ◽  
Munish Saini ◽  
Manevpreet Kaur
Keyword(s):  
Open Source ◽  
Open Source Software ◽  
Software Evolution ◽  
Source Code ◽  
Project Managers ◽  
Software Projects ◽  
Software Vulnerabilities ◽  
Software Code ◽  
Change Requests ◽  
Increasing Trends

This paper has statically investigated the source code of open source software (OSS) projects to uncover the presence of vulnerabilities in the code. The conducted research emphasizes that the presence of vulnerabilities has adverse effects on the overall software quality. The authors found the increasing trends in the vulnerabilities as the lines of code (LOC) increases during the software evolution. This signifies the fact that the addition of new features or change requests into the OSS project may cause an increase in vulnerability. Further, the relation between software vulnerabilities and popularity is also examined. This research does not find the existence of any relationship among software vulnerabilities and popularity. This research will provide significant implications to the developers and project managers to better understand the present state of the software.

scholarly journals Behaviour Preservation across Code Versions in Erlang

2018 ◽  
Vol 2018 ◽  
pp. 1-42 ◽  
Author(s):  
David Insa ◽  
Sergio Pérez ◽  
Josep Silva ◽  
Salvador Tamarit
Keyword(s):  
Open Source ◽  
Source Code ◽  
Test Suite ◽  
Test Case Generation ◽  
Test Case ◽  
Previous Version ◽  
Open Source Tool ◽  
Alternative Approach ◽  
Code Changes

In any alive and nontrivial program, the source code naturally evolves along the lifecycle for many reasons such as the implementation of new functionality, the optimization of a bottleneck, or the refactoring of an obscure function. Frequently, these code changes affect various different functions and modules, so it can be difficult to know whether the correct behaviour of the previous version has been preserved in the new version. In this paper, we face this problem in the context of the Erlang language, where most developers rely on a previously defined test suite to check the behaviour preservation. We propose an alternative approach to automatically obtain a test suite that specifically focusses on comparing the old and new versions of the code. Our test case generation is directed by a sophisticated combination of several already existing tools such as TypEr, CutEr, and PropEr; and it introduces novel ideas such as allowing the programmer to choose one or more expressions of interest that must preserve the behaviour, or the recording of the sequences of values to which those expressions are evaluated. All the presented work has been implemented in an open-source tool that is publicly available on GitHub.

scholarly journals Commit Message Generation for Source Code Changes

2019 ◽  
Author(s):  
Shengbin Xu ◽  
Yuan Yao ◽  
Feng Xu ◽  
Tianxiao Gu ◽  
Hanghang Tong ◽  
...  
Keyword(s):  
Software Evolution ◽  
State Of The Art ◽  
Source Code ◽  
Real Data ◽  
Program Comprehension ◽  
Sources Of Information ◽  
Structure Information ◽  
Code Structure ◽  
Code Changes ◽  
Source Code Changes

Commit messages, which summarize the source code changes in natural language, are essential for program comprehension and software evolution understanding. Unfortunately, due to the lack of direct motivation, commit messages are sometimes neglected by developers, making it necessary to automatically generate such messages. State-of-the-art adopts learning based approaches such as neural machine translation models for the commit message generation problem. However, they tend to ignore the code structure information and suffer from the out-of-vocabulary issue. In this paper, we propose CoDiSum to address the above two limitations. In particular, we first extract both code structure and code semantics from the source code changes, and then jointly model these two sources of information so as to better learn the representations of the code changes. Moreover, we augment the model with copying mechanism to further mitigate the out-of-vocabulary issue. Experimental evaluations on real data demonstrate that the proposed approach significantly outperforms the state-of-the-art in terms of accurately generating the commit messages.

Free and Open Source unmanned vehicles

2020 ◽  
Author(s):  
Luca Delucchi ◽  
Luca Bezzi
Keyword(s):  
Open Source ◽  
Unmanned Vehicles ◽  
The World ◽  
Different Types ◽  
History Of ◽  
Vehicle Technologies ◽  
Open Source Systems

<p>Unmanned Vehicles (UV) are used daily for different applications around the world. However, most of the software and technologies on which they are based are closed and proprietary systems. The presentation will start by introducing the history of Unmaned Vehicle technologies, with some unknown historical info, and the different types of Unmaned Vehicles that exist. The aim of the presentation is to demonstrate the integration of free and open source systems starting from the hardware, specially the autopilot component, through some payloads and finishing with the software solutions. Different software solutions for diverse aims will be showed and compared, i.e., first the different software used to configure the UV and manage the mission and later the possible software used to manage the outputs from the mission.</p>

Impact of Clone Refactoring on External Quality Attributes of Open Source Softwares

2018 ◽  
pp. 86-94
Author(s):  
Himanshi Vashisht ◽  
Sanjay Bharadwaj ◽  
Sushma Sharma
Keyword(s):  
Open Source ◽  
Internal Structure ◽  
Software Quality ◽  
Source Code ◽  
Quality Attributes ◽  
Software Component ◽  
External Quality ◽  
Code Refactoring ◽  
Observable Behaviour

Code refactoring is a “Process of restructuring an existing source code.”. It also helps in improving the internal structure of the code without really affecting its external behaviour”. It changes a source code in such a way that it does not alter the external behaviour yet still it improves its internal structure. It is a way to clean up code that minimizes the chances of introducing bugs. Refactoring is a change made to the internal structure of a software component to make it easier to understand and cheaper to modify, without changing the observable behaviour of that software component. Bad smells indicate that there is something wrong in the code that have to refactor. There are different tools that are available to identify and emove these bad smells. A software has two types of quality attributes- Internal and external. In this paper we will study the effect of clone refactoring on software quality attributes.

Sign in / Sign up

Export Citation Format

Share Document