Using Stack Overflow to Assess Technical Debt Identification on Software Projects

2020 ◽  
Author(s):  
Eliakim Gama ◽  
Sávio Freire ◽  
Manoel Mendonça ◽  
Rodrigo O. Spínola ◽  
Matheus Paixao ◽  
...  
Keyword(s):  
Technical Debt ◽  
Software Projects ◽  
Stack Overflow

scholarly journals A Taste of the Software Industry Perception of Technical Debt and its Management in Brazil

2019 ◽  
Vol 7 ◽  
pp. 1 ◽  
Author(s):  
Victor Machado Silva ◽  
Helvio Jeronimo Junior ◽  
Guilherme Horta Travassos
Keyword(s):  
Software Engineering ◽  
Small Group ◽  
Software Industry ◽  
Internal Quality ◽  
Primary Study ◽  
Communication Tool ◽  
Technical Debt ◽  
Software Projects ◽  
Considerable Fraction

Technical debt (TD) is receiving more and more attention to software engineering. Although it was initially used as a communication tool for technical and non-technical stakeholders, nowadays this concept supports the improvement of the software’s internal quality. Despite the increasing number of studies regarding TD and its management, only a few are concerned with the industry. Therefore, this primary study aims to characterize TD and its management under the perspective of Brazilian software organizations using their practitioners as proxies. A survey was performed with 62 practitioners, representing around 12 organizations and 30 software projects. The analysis of 40 valid questionnaires indicates that TD is still unknown to a considerable fraction of the participants, and only a small group of organizations adopt TD management activities in their projects. The survey package is available and can be used to support further investigations on TD management in software organizations.

scholarly journals Software Developers’ Work Habits and Expertise: Empirical Studies on Sketching, Code Plagiarism, and Expertise Development

2020 ◽  
pp. 47-60
Author(s):  
Sebastian Baltes
Keyword(s):  
Software Development ◽  
Specific Work ◽  
Expertise Development ◽  
Software Projects ◽  
Software Developers ◽  
Quantitative Research Methods ◽  
Stack Overflow ◽  
Daily Work ◽  
Work Habits ◽  
Novel Theory

AbstractAnalyzing and understanding software developers’ work habits and resulting needs is an essential prerequisite to improve software development practice. In our research, we utilize different qualitative and quantitative research methods to empirically investigate three underexplored aspects of software development: First, we analyze how software developers use sketches and diagrams in their daily work and derive requirements for better tool support. Then, we explore to what degree developers copy code from the popular online platform Stack Overflow without adhering to license requirements and motivate why this behavior may lead to legal issues for affected open source software projects. Finally, we describe a novel theory of software development expertise and identify factors fostering or hindering the formation of such expertise. Besides, we report on methodological implications of our research and present the open dataset SOTorrent, which supports researchers in analyzing the origin, evolution, and usage of content on Stack Overflow. The common goal for all studies we conducted was to better understand software developers’ work practices. Our findings support researchers and practitioners in making data-informed decisions when developing new tools or improving processes related to either the specific work habits we studied or expertise development in general.

scholarly journals Comparing Maintainability Index, SIG Method, and SQALE for Technical Debt Identification

2020 ◽  
Vol 2020 ◽  
pp. 1-14
Author(s):  
Peter Strečanský ◽  
Stanislav Chren ◽  
Bruno Rossi
Keyword(s):  
Time Series ◽  
Open Source ◽  
Steady States ◽  
The Other ◽  
Clear Understanding ◽  
Technical Debt ◽  
Software Projects ◽  
Over Time ◽  
The Way

There are many definitions of software Technical Debt (TD) that were proposed over time. While many techniques to measure TD emerged in recent times, there is still not a clear understanding about how different techniques compare when applied to software projects. The goal of this paper is to shed some light on this aspect, by comparing three techniques about TD identification that were proposed over time: (i) the Maintainability Index (MI), (ii) SIG TD models, and (iii) SQALE analysis. Considering 20 open source Python libraries, we compare the TD measurements time series in terms of trends and evolution according to different sets of releases (major, minor, and micro), to see if the perception of practitioners about TD evolution could be impacted. While all methods report generally growing trends of TD over time, there are different patterns. SQALE reports more periods of steady states compared to MI and SIG TD. MI is the method that reports more repayments of TD compared to the other methods. SIG TD and MI are the models that show more similarity in the way TD evolves, while SQALE and MI are less similar. The implications are that each method gives slightly a different perception about TD evolution.

scholarly journals Knowledge reuse in software projects: Retrieving software development Q&A posts based on project task similarity

PLoS ONE ◽  
2020 ◽  
Vol 15 (12) ◽  
pp. e0243852
Author(s):  
Glaucia Melo ◽  
Toacy Oliveira ◽  
Paulo Alencar ◽  
Donald Cowan
Keyword(s):  
Software Development ◽  
Programming Languages ◽  
Knowledge Reuse ◽  
Software Projects ◽  
Explicit Integration ◽  
Stack Overflow ◽  
Task Similarity ◽  
Development Phases ◽  
Amount Of Knowledge ◽  
Agile Software

Software developers need to cope with a massive amount of knowledge throughout the typical life cycle of modern projects. This knowledge includes expertise related to the software development phases (e.g., programming, testing) using a wide variety of methods and tools, including development methodologies (e.g., waterfall, agile), software tools (e.g., Eclipse), programming languages (e.g., Java, SQL), and deployment strategies (e.g., Docker, Jenkins). However, there is no explicit integration of these various types of knowledge with software development projects so that developers can avoid having to search over and over for similar and recurrent solutions to tasks and reuse this knowledge. Specifically, Q&A sites such as Stack Overflow are used by developers to share software development knowledge through posts published in several categories, but there is no link between these posts and the tasks developers perform. In this paper, we present an approach that (i) allows developers to associate project tasks with Stack Overflow posts, and (ii) recommends which Stack Overflow posts might be reused based on task similarity. We analyze an industry dataset, which contains project tasks associated with Stack Overflow posts, looking for the similarity of project tasks that reuse a Stack Overflow post. The approach indicates that when a software developer is performing a task, and this task is similar to another task that has been associated with a post, the same post can be recommended to the developer and possibly reused. We believe that this approach can significantly advance the state of the art of software knowledge reuse by supporting novel knowledge-project associations.

The Technical Debt Density Over Multiple Releases and the Refactoring Story

2021 ◽  
Vol 31 (01) ◽  
pp. 99-116
Author(s):  
Mrwan BenIdris ◽  
Hany Ammar ◽  
Dale Dzielski
Keyword(s):  
Software Development ◽  
Magic Number ◽  
Software Systems ◽  
Code Smells ◽  
Technical Debt ◽  
Software Projects ◽  
Development Life Cycle ◽  
The Cost ◽  
Multiple Releases

Do developers postpone fixing Technical Debt (TD) in software systems? TD is a metaphor that refers to short-term decisions in software development that may affect the cost of the software development life cycle. The bad smell is an imperfect solution in the software system that negatively impacts the internal software quality and maintainability. In this paper, we will study five open-source software projects (OSSPs) that have several releases and also estimate the numbers of architecture smells (ASs), design smells (DSs), and code smells (CSs) for every release. Designite will be used to detect smells. We describe a case study conducted to explore the following: (1) What is the average smells density for architecture, design, and code smells in an OSSP? (2) Does the density of each smell type increase over multiple releases? (3) What percentage of each smell-type density is eliminated by refactoring? We collected around 2 million LOC from five OSSPs that have multiple releases from the GitHub repository to statistically analyze the software concerning the smells as indicators of TD. We find 36% of Architecture Technical Debt (ATD) is Cyclic Dependency, while 33% of Design Debt (DD) is Cyclically-dependent Modularization. More than 70% of Code Debt (CD) is Magic Number. Even though the developers do refactoring between releases, the TD density in general increases. On average, by refactoring, developers remove around 48%, 16%, and 22% from the introduced ATD, DD, and CD from their next release, respectively.

Sign in / Sign up

Export Citation Format

Share Document