Find research datasets worth reusing
Search datasets from major research repositories and use ShareScore to quickly assess how well each record supports discovery, access, and reuse.
45
datasets available to search
ShareScore release 0.7.1
Dataset results
45 results for “refactoring”
Towards a Catalog of Refactorings for Elixir [Replication Package]
<p>Replication Package of the paper accepted into ICSME NIER 2023</p>
Recommending Composite Refactorings for Smell Removal: Heuristics and Evaluation
<p>Short presentation for the paper entitled "Recommending Composite Refactorings for Smell Removal: Heuristics and Evaluation.</p> <p><strong>Abstract.</strong> Structural degradation is the process in which quality attributes of a system are negatively impacted. When due attention is not paid to structural degradation, the source code may also become difficult to change. Code smells are recurring structures in the source code that may represent structural degradation. Hence, there are many catalogs and techniques for supporting the removal of code smells through refactoring recommendations, such as a Move Method or a Extract Method. Such recommendations usually consist of single refactorings. However, single refactorings are often not enough for completely removing certain smell occurrences. Moreover, recent studies show that developers most often apply composite refactorings -- i.e., sequences of two or more refactorings -- for removing code smells. Despite showing the importance of performing composite refactorings, existing studies do not provide information on which composite refactoring patterns are recurrent in practice. Therefore, in this work, we conducted an empirical study to extract data from multiple open source systems regarding the composite refactoring practice. This data helped us to find 35 recurring patterns that are effective in removing certain types of code smells. Based on such patterns, we propose a suite of new recommendation heuristics to help developers in applying effective composite refactorings. These heuristics are intended to remove three code smell types, namely Complex Class, Feature Envy, and God Class. After designing the heuristics, we evaluated their effectiveness through a quasi-experiment. This evaluation was conducted with 12 software developers and 9 smelly Java classes. Results indicate that developers considered our heuristics effective or partially effective in more than 93% of the cases. In addition, the evaluation helped us to identify multiple factors that contribute to the acceptance or rejection of the refactoring recommendations. Based on these factors we define new guidelines for the effective recommendation of smell-removal composite refactorings.</p>
RefDiff4Go: Detecting Refactorings in Go
<p>RefDiff4Go: Detecting Refactorings in Go. </p> <p>Presentation for 14th Brazilian Symposium on Software Components, Architectures, and Reuse (SBCARS ’20), October 19–20, 2020, Natal, Brazil</p>
Appendix: Refactoring Data Set
<p>A large-scale data set containing refactorings mined from 92.800 open-source Java projects enriched with code metrics. Additionally, the data set contains Stable-Instances of the Class-, Method-, Variable- and Field-Level.</p> <p>The source code of the data collection tool can be found on GitHub: https://github.com/refactoring-ai/Data-Collection.<br> </p> <p> </p>
Refactoring Code Smells in Open Source Projects: A Hands-on Approach to Teaching Software Maintenance
<p>Code smells are suboptimal code structures that can undermine software quality and maintainability. On the one hand, software engineers commonly apply refactoring techniques to address these deficiencies and improve internal quality attributes. On the other hand, when performed manually and without discipline, refactoring can lead to code degradation. Despite its importance, refactoring and code smells are rarely explored in depth in undergraduate computing courses, which can be reflected in industry practices. To address this gap, this paper presents a hands-on approach to teaching code smell refactoring through contributions to Open Source Software (OSS) projects, an environment where developers with diverse skill levels collaborate, and maintaining code quality is particularly challenging. Code smells accumulate over time in such scenarios, hindering software evolution and collaboration. Our study in two undergraduate Software Quality and Software Maintenance courses expands on previous findings by incorporating an in-depth analysis of students’ learning experiences. The results indicate that: (i) students rec- ognized improvements in code quality after refactoring; (ii) they identified strong connections between refactoring, testing, and debugging; (iii) their confidence decreased when refactoring required changes across multiple files; (iv) code complexity posed a significant challenge to refactoring; (v) students’ choices of refactoring techniques were influenced by project structure and personal preferences, often combining multiple techniques to address a single smell; (vi) in some cases, refactoring introduced new code smells; (vii) the longest refactoring efforts were also the most likely to reintroduce code smells; (viii) contributing to OSS projects improved students’ programming skills and fostered a sense of professional growth; (ix) students faced challenges in understanding OSS contribution processes, particularly regarding issue resolution, adherence to contribution guidelines, and responding to maintainer feedback; (x) automated checks and review workflows varied across projects, affecting students’ ability to submit successful contributions; and (xi) despite these challenges, engagement with OSS enabled students to gain practical experience in collaborative software development. Our findings offer valuable insights for software engineering educators seeking to integrate refactoring practices into coursework while leveraging OSS contributions as an educational tool.</p>
Refactoring React-based Web Apps
<p>This dataset was utilized in the research paper titled "Refactorings in React-based Web Apps," accepted for publication in The Journal of Systems and Software. Herein, we present a concise abstract of the study.</p> <p>Refactoring is a well-known technique to improve software quality. However, there are relevant domains where refactoring has not been studied in-depth before, such as JavaScript front-end frameworks. To fill this gap, we empirically study refactorings that developers perform when maintaining and evolving React-based Web applications. By manually inspecting 320 refactoring commits performed in open source projects, we catalog 69 distinct refactoring operations of which 25 are specific to React code, 17 are adaptations of traditional refactorings for the React context, 22 are traditional refactorings, and six are specific to JavaScript and CSS code. The catalog of refactorings proposed in this article might support practitioners when improving the maintainability of React applications.</p>
Predicting Software Refactoring - CSV Cache
<p>Dataset contains cache used for machine learning solution of our paper.</p>
An Empirical Study on the Impact of Refactoring Activities on Evolving Client-Used APIs
<p>Context: Refactoring is recognized as an effective practice to maintain evolving software systems. For software libraries, we study how library developers refactor their Application Programming Interfaces (APIs), especially when it impacts client users by breaking an API of the library. Objective: Our work aims to understand how clients that use a library API are affected by refactoring activities. We target popular libraries that potentially impact more library client users. Method: We distinguish between library APIs based on their client-usage (refereed to as client-used APIs) in order to understand the extent to which API breakages relate to refactorings. Our tool-based approach allows for a large-scale study across eight libraries (i.e., totaling 183 consecutive versions) with around 900 clients projects. Results: We find that library maintainers are less likely to break client-used API classes. Quantitatively, we find that refactoring activities break less than 37% of all client-used APIs. In a more qualitative analysis, we show two documented cases of where non-refactoring API breaking changes are motivated other maintenance issues (i.e., bug fix and new features) and involve more complex refactoring operations. Conclusion: Using our automated approach, we find that library developers are less likely to break APIs and tend to break client-used APIs when addressing these maintenance issues.</p>
ML 4 Refactoring: dataset
<p>ML4Refactoring dataset</p> <p>all.zip: Source code before and after the refactoring</p> <p>refactoring50.zip: Structural metrics</p> <p>sample.xlsx: The list of projects under study</p>
Refactoring React-based Web Apps
<p>Refactoring React-based Web Apps - Dataset</p>
Automated refactoring actions for performance improvement in component-based software engineering
<p>Dataset of UML models randomly generated to validate the portfolio of refactoring actions.</p>
Online Survey: Impacts of Smells and Refactorings for Microservice Security
<p>This file contains the responses given to an online survey by practitioners and researchers working with microservice applications. The survey was aimed at measuring their agreement/disagreement with the possible impacts of smells and refactorings for microservices security [1], which were elicited by means of thematic analysis of both white and grey literature on the topic.</p> <p>[1] https://doi.org/10.1016/j.jss.2022.111393</p>
Refactoring Assertion Roulette and Duplicate Assert test smells: a controlled experiment [DATA]
<p>Data of the experiment with the RAIDE tool.</p>
Replication Package for the paper: "Behind the Intents: An In-depth Empirical Study on Software Refactoring in Modern Code Review"
<p>This is the replication package for the paper: "Behind the Intents: An In-depth Empirical Study on Software Refactoring in Modern Code Review", published at the 17th International Conference on Mining Software Repositories (MSR ’20). </p> <p> </p> <p>It contains all the preliminary and final results of our empirical methodology. We highlight the manual classification of developers' intents behind code changes with refactoring operations. This might be used for further studies on developers' motivations when performing refactoring. </p> <p> </p> <p>Feel free to use any part of this replication package in your study, please cite as:</p> <p>Matheus Paixão, Anderson Uchôa, Ana Carla Bibiano, Daniel Oliveira, Alessandro Garcia, Jens Krinke, and Emilio Arvonio. 2020. Behind the In-tents: An In-depth Empirical Study on Software Refactoring in Modern Code Review. In 17th International Conference on Mining Software Repositories (MSR ’20), October 5–6, 2020, Seoul, Republic of Korea. ACM, New York, NY,USA, 11 pages.</p>
Refactoring Dataset and Analysis Packages
<p>Refactoring Dataset and Analysis Packages</p>
An Empirical Study of Refactorings and Technical Debt in Machine Learning Systems
<p>Machine Learning (ML), including Deep Learning (DL), systems, i.e., those with ML capabilities, are pervasive in today's data-driven society. Such systems are complex; they are comprised of ML models and many subsystems that support learning processes. As with other complex systems, ML systems are prone to classic technical debt issues, especially when such systems are long-lived, but they also exhibit debt specific to these systems. Unfortunately, there is a gap of knowledge in how ML systems actually evolve and are maintained. In this paper, we fill this gap by studying refactorings, i.e., source-to-source semantics-preserving program transformations, performed in real-world, open-source software, and the technical debt issues they alleviate. We analyzed 26 projects, consisting of 4.2 MLOC, along with 327 manually examined code patches. The results indicate that developers refactor these systems for various reasons, both specific and tangential to ML; some refactorings correspond to established technical debt categories. In contrast, others do not, and code duplication is a major cross-cutting theme that particularly involved ML configuration and model code, which was also the most refactored. We also introduce 14 and 7 new ML-specific refactorings and technical debt categories, respectively, and put forth several recommendations, best practices, and anti-patterns. The results can potentially assist practitioners, tool developers, and educators in facilitating long-term ML system usefulness.</p>
Quantifying the Effects of Refactorings on Bad Smells
<p>Refactoring aims to remove bad smells and increase software maintainability by improving the software structure without changing its behavior. Even with the existence of tools to assist refactoring, many developers do not trust in their solutions, claiming that some studies show that refactoring may even introduce new bad smells into the source code. However, we do not find a complete catalog that states when this may occur. To investigate this subject deeply, the goal of this dissertation is to evaluate the effects of refactoring on the detection of bad smells. Specifically, we want to know if and what refactoring removes bad smells or introduces them. To achieve our goal, we plan to conduct empirical studies to provide a catalog showing these situations.</p>
Impermanent Identifiers: Enhanced Source Code Comprehension and Refactoring
Open the record for dataset details and reuse information.
Exploring and Analyzing Software Architecture Refactoring in Practice
Open the record for dataset details and reuse information.
Exploring the Automatic Recommendation of Composite Refactorings
<p>Dataset of the survey with developers to explore a recommender of refactoring. </p>
ScienceDex guides
Understand access before you commit
These curated guides explain access requirements, typical timelines, costs, and reuse considerations for widely used research datasets.
Allen Brain Atlas
Allen Brain Atlas is an Allen Institute collection of brain map atlases, datasets, APIs, and analysis tools covering mouse, human, and non-human primate brain resources.
Annotated Behaviour and Observability Dataset (ABODe)
ABODe is a University of Edinburgh DataShare dataset for behavior classification in group-housed mice using home-cage video, identities, bounding boxes, ground-plate positions, and annotator labels.
DANDI Archive for NWB datasets
DANDI is a BRAIN Initiative archive for publishing and sharing neurophysiology data, including electrophysiology, optophysiology, and behavioral data packaged as NWB and related standards.
International Brain Laboratory public data
The International Brain Laboratory public data releases expose standardized mouse decision-making experiments, including Neuropixels recordings, widefield calcium imaging, behavior, and session metadata accessed through the ONE API.
OpenNeuro
OpenNeuro is a free, open platform for sharing neuroimaging datasets, with public search, dataset pages, and download paths for web, S3, DataLad, and the OpenNeuro CLI.