Task articulation in software maintenance: Integrating source code annotations with an issue tracking system

2008 ◽  
Author(s):  
John Anvik ◽  
Margaret-Anne Storey
Keyword(s):  
Software Maintenance ◽  
Tracking System ◽  
Source Code ◽  
Code Annotations ◽  
Issue Tracking System

scholarly journals Are coupled file changes suggestions useful?

2016 ◽  
Author(s):  
Jasmin Ramadani ◽  
Stefan Wagner
Keyword(s):  
Software Maintenance ◽  
Tracking System ◽  
New Members ◽  
Team Members ◽  
The Past ◽  
Project Documentation ◽  
Using Data ◽  
The Impact ◽  
Issue Tracking System ◽  
Important Activity

Background. Software maintenance is an important activity in the process of software engineering where over time maintenance team members leave and new members join. The identification of files being changes together frequently has been proposed several times. Yet, existing studies about these file changes ignore the feedback from developers as well as the impact on the performance of maintenance and rely on the analysis findings and expert evaluation. Methods. We conducted an experiment with the goal to investigate the usefulness of coupled file changes during maintenance tasks when developers are inexperienced in programming or when they are new on the project. Using data mining on software repositories we can identify files that changed most frequently together in the past. We extract coupled file changes from the Git repository of a Java software system and join them with corresponding attributes from the versioning and issue tracking system and the project documentation. We present a controlled experiment involving 36 student participants where we investigate if coupled file change suggestions influence the correctness of the task solutions and the time to complete them. Results. The results show that coupled file change suggestions significantly increase the correctness of the solutions. However, there is only a small effect on the time to complete the tasks. We also derived a set of the most useful attributes based on the developers feedback. Discussion. Coupled file changes and a limited number of the proposed attributes are useful for inexperienced developers working on maintenance tasks whereby although the developers using these suggestions solved more tasks, they still need time to organize and understand and implement this information.

scholarly journals Documenting architectural rationale using source code annotations: An exploratory study

10.29007/f5md ◽  
2019 ◽  
Author(s):  
Santiago Hyun Dorado ◽  
Julio Ariel Hurtado
Keyword(s):  
Software Maintenance ◽  
Research Question ◽  
Source Code ◽  
Maintenance Phase ◽  
Maintenance Time ◽  
Efficiency And Effectiveness ◽  
Develop Software ◽  
Software Engineers ◽  
Code Annotations ◽  
Quasi Experiment

The architectural rationale is the documentation of the reasons why certain software design decisions are made that satisfy quality needs in a system. On many occasions this rationale is implicitly found in precise sentences of the system's documentation or the same source code, making it difficult to understand and make decisions on the maintenance phase, leading to a deviation and erosion of the architecture and therefore aging of the software. In this paper, we discuss the utility of a tool based on code annotations as an alternative to document the architectural rationale with the source code. For this, a quasi-experiment with local industry software engineers is done, in order to answer the research question: Does the source code annotations, with information about the architectural rationale, improves the software maintenance? The quasi-experiment is done with software engineers who know Java language and notions of software architectures. It included 3 tasks that involve changes to the architecture and its documentation. After the results were analyzed using the t-student test, concluding that the participants who use the annotations with information of the Architectural Rationale achieve a better understanding of the architecture and its Rationale than those using a traditional way for documenting the rationale(documents). However, the efficiency and effectiveness of maintenance time do not depend on the Rationale specification. With the same problem, the variation was due to the ability of individuals to develop software, but the documentation of the architecture, in general, was very important to be able to make the changes within the limits.

scholarly journals Are coupled file changes suggestions useful?

2016 ◽  
Author(s):  
Jasmin Ramadani ◽  
Stefan Wagner
Keyword(s):  
Software Maintenance ◽  
Tracking System ◽  
New Members ◽  
Team Members ◽  
The Past ◽  
Project Documentation ◽  
Using Data ◽  
The Impact ◽  
Issue Tracking System ◽  
Important Activity

Background. Software maintenance is an important activity in the process of software engineering where over time maintenance team members leave and new members join. The identification of files being changes together frequently has been proposed several times. Yet, existing studies about these file changes ignore the feedback from developers as well as the impact on the performance of maintenance and rely on the analysis findings and expert evaluation. Methods. We conducted an experiment with the goal to investigate the usefulness of coupled file changes during maintenance tasks when developers are inexperienced in programming or when they are new on the project. Using data mining on software repositories we can identify files that changed most frequently together in the past. We extract coupled file changes from the Git repository of a Java software system and join them with corresponding attributes from the versioning and issue tracking system and the project documentation. We present a controlled experiment involving 36 student participants where we investigate if coupled file change suggestions influence the correctness of the task solutions and the time to complete them. Results. The results show that coupled file change suggestions significantly increase the correctness of the solutions. However, there is only a small effect on the time to complete the tasks. We also derived a set of the most useful attributes based on the developers feedback. Discussion. Coupled file changes and a limited number of the proposed attributes are useful for inexperienced developers working on maintenance tasks whereby although the developers using these suggestions solved more tasks, they still need time to organize and understand and implement this information.

scholarly journals Enhanced Bug Prediction in JavaScript Programs with Hybrid Call-Graph Based Invocation Metrics

Technologies ◽  
2020 ◽  
Vol 9 (1) ◽  
pp. 3
Author(s):  
Gábor Antal ◽  
Zoltán Tóth ◽  
Péter Hegedűs ◽  
Rudolf Ferenc
Keyword(s):  
Software Maintenance ◽  
Positive Impact ◽  
Source Code ◽  
Code Analysis ◽  
Static Source ◽  
Static Code Analysis ◽  
Function Calls ◽  
Hybrid Code ◽  
Code Metrics ◽  
Scripting Language

Bug prediction aims at finding source code elements in a software system that are likely to contain defects. Being aware of the most error-prone parts of the program, one can efficiently allocate the limited amount of testing and code review resources. Therefore, bug prediction can support software maintenance and evolution to a great extent. In this paper, we propose a function level JavaScript bug prediction model based on static source code metrics with the addition of a hybrid (static and dynamic) code analysis based metric of the number of incoming and outgoing function calls (HNII and HNOI). Our motivation for this is that JavaScript is a highly dynamic scripting language for which static code analysis might be very imprecise; therefore, using a purely static source code features for bug prediction might not be enough. Based on a study where we extracted 824 buggy and 1943 non-buggy functions from the publicly available BugsJS dataset for the ESLint JavaScript project, we can confirm the positive impact of hybrid code metrics on the prediction performance of the ML models. Depending on the ML algorithm, applied hyper-parameters, and target measures we consider, hybrid invocation metrics bring a 2–10% increase in model performances (i.e., precision, recall, F-measure). Interestingly, replacing static NOI and NII metrics with their hybrid counterparts HNOI and HNII in itself improves model performances; however, using them all together yields the best results.

scholarly journals Partially observable Markov Decision Process to prioritize software defects

2021 ◽  
Author(s):  
Shirin Akbarinasaji
Keyword(s):  
Markov Decision Process ◽  
Decision Process ◽  
Tracking System ◽  
Dependency Graph ◽  
Relative Importance ◽  
Bug Reports ◽  
Markov Decision ◽  
Partially Observable Markov ◽  
Partially Observable ◽  
Issue Tracking System

Background: Bug tracking systems receive many bug reports daily. Although the software quality team aims to identify and resolve these bugs, they are never able to fix all of the reported bugs in the issue tracking system before the release deadline. However, postponing the bug fixing may have some consequences. Prioritization of bug reports will help the software manager decide which bugs to fix and which bugs to postpone. Typically, bug reports are prioritized based on the severity, priority, time and effort for fixing, customer pressure, etc. Aim: Previous studies have shown that these factors may not be appropriate for prioritization. Therefore, relying on them to automate bug prioritization might be misleading. In this dissertation, we aim to prioritize bug reports with respect to the consequence of not fixing the bugs in terms of their relative importance in the issue tracking system. Method: In order to measure the relative importance of bugs in the issue tracking system, we propose the construction of a dependency graph based on the reported dependency-blocking information in the issue tracking system. Two metrics, namely depth and degree, are used to measure the relative importance of the bugs. However, there is uncertainty in the dependency graph structure as the dependency information is discovered manually and gradually. Owing to this uncertainty, prioritization of bugs in the descending order of depth and degree may be misleading. To handle the uncertainty, we propose a novel approach of a partially observable Markov decision process (POMDP) and partially observable Monte Carlo planning (POMCP). Result: To check the feasibility of the proposed approach, we analyzed seven years of data from an open source project, Firefox, and a commercial project. We compared the proposed policy with the developer policy, maximum policy, and random policy. Conclusion: The results suggest that software practitioners do not consider the relative importance of bugs in their current practice. The proposed framework can be combined with practitioners’ expertise to prioritize bugs more effectively and take the depth and degree of bugs into account. In practice, the POMDP framework with the POMCP planner can help practitioners sequentially select bugs to minimize the connectivity of the dependency graph.

Ontology Augmented Software Engineering

2013 ◽  
pp. 406-413
Author(s):  
Qazi Mudassar Ilyas
Keyword(s):  
Software Engineering ◽  
Semantic Web ◽  
System Integration ◽  
Software Maintenance ◽  
Domain Knowledge ◽  
System Development ◽  
Tracking System ◽  
Software Artifacts ◽  
Natural Choice ◽  
Development Life Cycle

Semantic Web was proposed to make the content machine-understandable by developing ontologies to capture domain knowledge and annotating content with this domain knowledge. Although, the original idea of semantic web was to make content on the World Wide Web machine-understandable, with recent advancements and awareness about these technologies, researchers have applied ontologies in many interesting domains. Many phases in software engineering are dependent on availability of knowledge, and the use of ontologies to capture and process this knowledge is a natural choice. This chapter discusses how ontologies can be used in various stages of the system development life cycle. Ontologies can be used to support requirements engineering phase in identifying and fixing inconsistent, incomplete, and ambiguous requirement. They can also be used to model the requirements and assist in requirements management and validation. During software design and development stages, ontologies can help software engineers in finding suitable components, managing documentation of APIs, and coding support. Ontologies can help in system integration and evolution process by aligning various databases with the help of ontologies capturing knowledge about database schema and aligning them with concepts in ontology. Ontologies can also be used in software maintenance by developing a bug tracking system based upon ontological knowledge of software artifacts and roles of developers involved in software maintenance task.

Sign in / Sign up

Export Citation Format

Share Document