scholarly journals On the Analysis of Human and Automatic Summaries of Source Code

2012 ◽  
Vol 15 (2) ◽  
Author(s):  
Laura Moreno ◽  
Jairo Aponte
Keyword(s):  
Software Engineering ◽  
Empirical Study ◽  
Source Code ◽  
Initial Step ◽  
Text Retrieval ◽  
Internal Quality ◽  
Automatic Summarization ◽  
Software Artifacts ◽  
Automatic Methods

Within the software engineering field, researchers have investigated whether it is pos- sible and useful to summarize software artifacts, in order to provide developers with concise representations of the content of the original artifacts. As an initial step to- wards automatic summarization of source code, we conducted an empirical study where a group of Java developers provided manually written summaries for a variety of source code elements. Such summaries were analyzed and used to evaluate some summarization techniques based on Text Retrieval. This paper describes what are the main features of the summaries written by developers, what kind of information should be (ideally) included in automatically generated sum- maries, and the internal quality of the summaries generated by some automatic methods.

scholarly journals Understanding the Causes of Architecture Changes Using OSS Mailing Lists

2015 ◽  
Vol 25 (09n10) ◽  
pp. 1633-1651 ◽  
Author(s):  
Wei Ding ◽  
Peng Liang ◽  
Antony Tang ◽  
Hans van Vliet
Keyword(s):  
Grounded Theory ◽  
Empirical Study ◽  
Open Source ◽  
Open Source Software ◽  
Source Code ◽  
Internal Quality ◽  
Functional Requirement ◽  
Quality Requirement ◽  
External Quality ◽  
Mailing Lists

The causes of architecture changes can tell about why architecture changes, and this knowledge can be captured to prevent architecture knowledge vaporization and architecture degeneration. But the causes are not always known, especially in open source software (OSS) development. This makes it very hard to understand the underlying reasons for the architecture changes and design appropriate modifications. Architecture information is communicated in development mailing lists of OSS projects. To explore the possibility of identifying and understanding the causes of architecture changes, we conducted an empirical study to analyze architecture information (i.e. architectural threads) communicated in the development mailing lists of two popular OSS projects: Hibernate and ArgoUML, verified architecture changes with source code, and identified the causes of architecture changes from the communicated architecture information. The main findings of this study are: (1) architecture information communicated in OSS mailing lists does lead to architecture changes in code; (2) the major cause for architecture changes in both Hibernate and ArgoUML is preventative changes, and the causes of architecture changes are further classified to functional requirement, external quality requirement, and internal quality requirement using the coding techniques of grounded theory; (3) more than 45% of architecture changes in both projects happened before the first stable version was released.

scholarly journals Using git metrics to measure students' and teams' code contributions in software development projects

2021 ◽  
Vol 24 (2) ◽  
Author(s):  
Sivana Hamer ◽  
Christian Quesada-López ◽  
Alexandra Martínez ◽  
Marcelo Jenkins
Keyword(s):  
Software Engineering ◽  
Software Development ◽  
Source Code ◽  
Version Control ◽  
Individual Student ◽  
Development Projects ◽  
Project Development ◽  
Inequality Measures ◽  
Software Artifacts ◽  
Development Processes

Many software engineering courses are centered around team-based project development. Analyzing the source code contributions during the projects’ development could provide both instructors and students with constant feedback to identify common trends and behaviors that can be improved during the courses. Evaluating course projects is a challenge due to the difficulty of measuring individual student contributions versus team contributions during the development. The adoption of distributed version control sys-tems like git enable the measurement of students’ and teams’ contributions to the project.In this work, we analyze the contributions within eight software development projects,with 150 students in total, from undergraduate courses that used project-based learning.We generate visualizations of aggregated git metrics using inequality measures and the contribution per module, which offer insights into the practices and processes followed by students and teams throughout the project development. This approach allowed us to identify inequality among students’ contributions, the modules where students con-tributed, development processes with a non-steady pace, and integration practices render-ing a useful feedback tool for instructors and students during the project’s development.Further studies can be conducted to assess the quality, complexity, and ownership of the contributions by analyzing software artifacts. 

Supporting Requirements to Code Traceability Creation by Code Comments

2021 ◽  
Vol 31 (08) ◽  
pp. 1099-1118
Author(s):  
Guohua Shen ◽  
Haijuan Wang ◽  
Zhiqiu Huang ◽  
YaoShen Yu ◽  
Kai Chen
Keyword(s):  
Empirical Study ◽  
Software Maintenance ◽  
Source Code ◽  
The Other ◽  
Different Types ◽  
The Creation ◽  
The Impact ◽  
Code Tracing

Requirements-to-code tracing is an important and costly task that creates trace links from requirements to source code. These trace links help engineers reduce the time and complexity of software maintenance. Code comments play an important role in software maintenance tasks. However, few studies have focused intensively on the impact of code comments on requirements-to-code trace links creation. Different types of comments have different purposes, so how different types of code comments provide different improvements for requirements-to-code trace links creation? We focus on learning whether code comments and different types of comments can improve the quality of trace links creation. This paper presents a study to evaluate the contribution of code comments and different types of code comments to the creation of trace links. More specifically, this paper first experimentally evaluates the impact of code comments on requirements-to-code trace links creation, and then divides code comments into six categories to evaluate its impact on trace links creation. The results show that the precision increases by an average of 15% (based on the same recall) after adding code comments (even for different trace links creation techniques), and the type of Purpose comments contributes more to the tracing task than the other five. This empirical study provides evidence that code comments are effective in tracing links creation, and different types of code comments contribute differently. Purpose comments can be used to improve the accuracy of requirements-to-code trace links creation.

Exploration and Exploitation of Developers' Sentimental Variations in Software Engineering

2016 ◽  
Vol 4 (4) ◽  
pp. 35-55 ◽  
Author(s):  
Md Rakibul Islam ◽  
Minhaz F. Zibran
Keyword(s):  
Software Engineering ◽  
Empirical Study ◽  
Software Development ◽  
Open Source ◽  
Emotional Awareness ◽  
Exploration And Exploitation ◽  
Software Artifacts ◽  
Bug Fixing ◽  
Different Types

Software development is highly dependent on human efforts and collaborations, which are immensely affected by emotions. This paper presents a quantitative empirical study of the emotional variations in different types of development activities (e.g., bug-fixing tasks), development periods (i.e., days and times) and in projects of different sizes involving teams of variant sizes. The study also includes an in-depth investigation of emotions' impacts on software artifacts (i.e., commit messages) and exploration of scopes for exploiting emotional variations in software engineering activities. This work is based on careful analyses of emotions in more than 490 thousand commit comments across 50 open-source projects. The findings from this work add to our understanding of the role of emotions in software development, and expose scopes for exploitation of emotional awareness in improved task assignments and collaborations.

Exploration and Exploitation of Developers' Sentimental Variations in Software Engineering

2021 ◽  
pp. 1889-1910
Author(s):  
Md Rakibul Islam ◽  
Minhaz F. Zibran
Keyword(s):  
Software Engineering ◽  
Empirical Study ◽  
Software Development ◽  
Open Source ◽  
Emotional Awareness ◽  
Exploration And Exploitation ◽  
Software Artifacts ◽  
Bug Fixing ◽  
Different Types

Software development is highly dependent on human efforts and collaborations, which are immensely affected by emotions. This paper presents a quantitative empirical study of the emotional variations in different types of development activities (e.g., bug-fixing tasks), development periods (i.e., days and times) and in projects of different sizes involving teams of variant sizes. The study also includes an in-depth investigation of emotions' impacts on software artifacts (i.e., commit messages) and exploration of scopes for exploiting emotional variations in software engineering activities. This work is based on careful analyses of emotions in more than 490 thousand commit comments across 50 open-source projects. The findings from this work add to our understanding of the role of emotions in software development, and expose scopes for exploitation of emotional awareness in improved task assignments and collaborations.

scholarly journals Empirical Analysis of Re-Factoring Techniques

2021 ◽  
Vol 9 (11) ◽  
pp. 1274-1280
Author(s):  
Dendi Naishika Reddy
Keyword(s):  
Comparative Analysis ◽  
Empirical Study ◽  
Empirical Analysis ◽  
Source Code ◽  
Software Project ◽  
Functional Attributes ◽  
Complete Knowledge ◽  
Negative Impacts ◽  
Internal Architecture

Abstract: The process or technique of Code Re-factoring is restructuring the existing source code by making changes in factoring without any changes in external behaviour. The main intention of re-factoring is to improve non-functional attributes of the software. The advantages include improving the code readability and reducing the complexity of any given source code, and these can overall enhance code maintainability and produce a much more elaborated internal architecture or objectoriented model to boost the extensibility of the code. The effect that re-factoring has on any software project is analysable and customisable. But, before customising the factoring techniques, it is essential to have a complete knowledge of all possible refactoring techniques, and all its possible effects. Our main focus will be on few main re-factoring techniques like Red-Green refactoring, preparatory re-factoring, Abstraction re-factoring, composing methods re-factoring etc. Every software project has both internal and external attributes, that highly influence the software’s maintainability, reusability, understandability, flexibility, testability, extensibility, reliability, efficiency, modularity, complexity and composition. The research mainly focuses on the effect of re-factoring on them. Study of researched data will give us comparative analysis, pointing out both the positive and negative impacts, re-factoring can have. Overall, the project aims to perform an empirical study to find out the impacts of refactoring techniques. The research aims to explore the change in the quality of the code after re-factoring. Improvement, decrement and stability are analysed. Study is also done to find the possibilities of applying more than one re-factoring techniques, independently or in an aggregation. Keywords: maintainability; extensibility; reliability; modularity

JAVASCRIPT ASYNCHRONOUS PROGRAMMING

2019 ◽  
Vol 128 (2B) ◽  
pp. 5-16
Author(s):  
Tran Thanh Luong ◽  
Le My Canh
Keyword(s):  
Design Patterns ◽  
Source Code ◽  
Object Oriented ◽  
Exception Handling ◽  
Code Smells ◽  
Asynchronous Programming ◽  
Event Driven ◽  
Programming Patterns ◽  
The Impact

JavaScript has become more and more popular in recent years because its wealthy features as being dynamic, interpreted and object-oriented with first-class functions. Furthermore, JavaScript is designed with event-driven and I/O non-blocking model that boosts the performance of overall application especially in the case of Node.js. To take advantage of these characteristics, many design patterns that implement asynchronous programming for JavaScript were proposed. However, choosing a right pattern and implementing a good asynchronous source code is a challenge and thus easily lead into less robust application and low quality source code. Extended from our previous works on exception handling code smells in JavaScript and exception handling code smells in JavaScript asynchronous programming with promise, this research aims at studying the impact of three JavaScript asynchronous programming patterns on quality of source code and application.

Sign in / Sign up

Export Citation Format

Share Document