waashk/dblp huggingface dataset:
how we refactor, and how we know it. much of what we know about how programmers refactor in the wild is based on studies that examine just a few software projects. researchers have rarely taken the time to replicate these studies in other contexts or to examine the assumptions on which they are based. to help put refactoring research on a sound scientific basis, we draw conclusions using four data sets spanning more than 13 000 developers, 240 000 tool-assisted refactorings, 2500 developer hours, and 3400 version control commits. using these data, we cast doubt on several previously stated assumptions about how programmers refactor, while validating others. for example, we find that programmers frequently do not indicate refactoring activity in commit logs, which contradicts assumptions made by several previous researchers. in contrast, we were able to confirm the assumption that programmers do frequently intersperse refactoring with other program changes. by confirming assumptions and replicating studies made by other researchers, we can have greater confidence that those researchers' conclusions are generalizable.
tesseract: interactive visual exploration of socio-technical relationships in software development. software developers have long known that project success requires a robust understanding of both technical and social linkages. however, research has largely considered these independently. research on networks of technical artifacts focuses on techniques like code analysis or mining project archives. social network analysis has been used to capture information about relations among people. yet, each type of information is often far more useful when combined, as when the “goodness” of social networks is judged by the patterns of dependencies in the technical artifacts. to bring such information together, we have developed tesseract, an interactive exploratory environment that utilizes cross-linked displays to visualize the myriad relationships between artifacts, developers, bugs, and communications. we evaluated tesseract by (1) demonstrating its feasibility with gnome project data (2) assessing its usability via informal user evaluations, and (3) verifying its suitability for the open source community via semi-structured interviews.
the impact of process choice in high maturity environments: an empirical analysis. we present the results of a three year field study of the software development process choices made by project teams at two leading offshore vendors. in particular, we focus on the performance implications of project teams that chose to augment structured, plan-driven processes to implement the cmm level-5 key process areas (kpas) with agile methods. our analysis of 112 software projects reveals that the decision to augment the firm-recommended, plan-driven approach with improvised, agile methods was significantly affected by the extent of client knowledge and involvement, the newness of technology, and the project size. furthermore this decision had a significant and mostly positive impact on project performance indicators such as reuse, rework, defect density, and productivity
taming coincidental correctness: coverage refinement with context patterns to improve fault localization. recent techniques for fault localization leverage code coverage to address the high cost problem of debugging. these techniques exploit the correlations between program failures and the coverage of program entities as the clue in locating faults. experimental evidence shows that the effectiveness of these techniques can be affected adversely by coincidental correctness, which occurs when a fault is executed but no failure is detected. in this paper, we propose an approach to address this problem. we refine code coverage of test runs using control- and data-flow patterns prescribed by different fault types. we conjecture that this extra information, which we call context patterns, can strengthen the correlations between program failures and the coverage of faulty program entities, making it easier for fault localization techniques to locate the faults. to evaluate the proposed approach, we have conducted a mutation analysis on three real world programs and cross-validated the results with real faults. the experimental results consistently show that coverage refinement is effective in easing the coincidental correctness problem in fault localization techniques.
learning operational requirements from goal models. goal-oriented methods have increasingly been recognised as an effective means for eliciting, elaborating, analysing and specifying software requirements. a key activity in these approaches is the elaboration of a correct and complete set of opertional requirements, in the form of pre- and trigger-conditions, that guarantee the system goals. few existing approaches provide support for this crucial task and mainly rely on significant effort and expertise of the engineer. in this paper we propose a tool-based framework that combines model checking, inductive learning and scenarios for elaborating operational requirements from goal models. this is an iterative process that requires the engineer to identify positive and negative scenarios from counterexamples to the goals, generated using model checking, and to select operational requirements from suggestions computed by inductive learning.
succession: measuring transfer of code and developer productivity. code ownership transfer or succession is a crucial ingredient in open source code reuse and in offshoring projects. measuring succession can help understand factors that affect the success of such transfers and suggest ways to make them more efficient. we propose and evaluate several methods to measure succession based on the chronology and traces of developer activities. using ten instances of offshoring succession identified through interviews, we find that the best succession measure can accurately pinpoint the most likely mentors. we model the productivity ratio of more than 1000 developer pairs involved in the succession to test conjectures formulated using the organizational socialization theory and find the ratio to decrease for instances of offshoring and for mentors who have worked primarily on a single project or have transferred ownership for their non-primary project code, thus supporting a theory-based conjectures and providing practical suggestions on how to improve succession.
the secret life of bugs: going past the errors and omissions in software repositories. every bug has a story behind it. the people that discover and resolve it need to coordinate, to get information from documents, tools, or other people, and to navigate through issues of accountability, ownership, and organizational structure. this paper reports on a field study of coordination activities around bug fixing that used a combination of case study research and a survey of software professionals. results show that the histories of even simple bugs are strongly dependent on social, organizational, and technical knowledge that cannot be solely extracted through automation of electronic repositories, and that such automation provides incomplete and often erroneous accounts of coordination. the paper uses rich bug histories and survey results to identify common bug fixing coordination patterns and to provide implications for tool designers and researchers of coordination in software development.
transtrl: an automatic need-to-translate string locator for software internationalization. software internationalization is often necessary when distributing software applications to different regions around the world. in many cases, developers often do not internationalize a software application at the beginning of the development stage. to internationalize such an existing application, developers need to externalize some hard-coded constant strings to resource files, so that translators can easily translate the application to be in a local language without modifying its source code. since not all the constant strings require externalization, locating those need-to-translate constant strings is a basic task that the developers must conduct. in this paper, we present transtrl, an eclipse plug-in tool that automatically locates need-to-translate constant strings in java code. our tool maintains a pre-collected list of api methods related to the graphical user interface (gui), and then searches for need-to-translate strings in the source code starting from the invocations of these api methods using string-taint analysis.
flexsync: an aspect-oriented approach to java synchronization. designers of concurrent programs are faced with many choices of synchronization mechanisms, among which clear functional trade-offs exist. making synchronization customizable is highly desirable as different deployment scenarios of the same program often prioritize synchronization choices differently. unfortunately, such customizations cannot be accomplished in the conventional non-modular implementation of synchronization. to enable customizability, we present flexsync, an aspect oriented synchronization library, to enable the modular reasoning and the declarative specification of synchronization. complex java systems can simultaneously work with multiple synchronization mechanisms without any code changes. the flexsync load-time weaver performs deployment time optimizations and ensures these synchronization mechanisms consistently interact with each other and with the core system. we evaluated flexsync on commercially used complex java systems and observed significant speedups as a result of the deployment-specific customization.
refactoring sequential java code for concurrency via concurrent libraries. parallelizing existing sequential programs to run efficiently on multicores is hard. the java 5 package java.util.concurrent (j.u.c.) supports writing concurrent programs: much of the complexity of writing thread-safe and scalable programs is hidden in the library. to use this package, programmers still need to reengineer existing code. this is tedious because it requires changing many lines of code, is error-prone because programmers can use the wrong apis, and is omission-prone because programmers can miss opportunities to use the enhanced apis. this paper presents our tool, concurrencer, that enables programmers to refactor sequential code into parallel code that uses three j.u.c. concurrent utilities. concurrencer does not require any program annotations. its transformations span multiple, non-adjacent, program statements. a find-and-replace tool can not perform such transformations, which require program analysis. empirical evaluation shows that concurrencer refactors code effectively: concurrencer correctly identifies and applies transformations that some open-source developers overlooked, and the converted code exhibits good speedup.
alitheia core: an extensible software quality monitoring platform. research in the fields of software quality and maintainability requires the analysis of large quantities of data, which often originate from open source software projects. pre-processing data, calculating metrics, and synthesizing composite results from a large corpus of project artefacts is a tedious and error prone task lacking direct scientific value. the alitheia core tool is an extensible platform for software quality analysis that is designed specifically to facilitate software engineering research on large and diverse data sources, by integrating data collection and preprocessing phases with an array of analysis services, and presenting the researcher with an easy to use extension mechanism. the system has been used to process several projects successfully, forming the basis of an emerging ecosystem of quality analysis tools.
automatically finding patches using genetic programming. automatic program repair has been a longstanding goal in software engineering, yet debugging remains a largely manual process. we introduce a fully automated method for locating and repairing bugs in software. the approach works on off-the-shelf legacy applications and does not require formal specifications, program annotations or special coding practices. once a program fault is discovered, an extended form of genetic programming is used to evolve program variants until one is found that both retains required functionality and also avoids the defect in question. standard test cases are used to exercise the fault and to encode program requirements. after a successful repair has been discovered, it is minimized using structural differencing algorithms and delta debugging. we describe the proposed method and report experimental results demonstrating that it can successfully repair ten different c programs totaling 63,000 lines in under 200 seconds, on average.
ldiff: an enhanced line differencing tool. differencing tools are highly relevant for a series of software engineering tasks, including analyzing developers' activities, assessing the changeability of software artifacts, and monitoring the maintenance of critical assets such as source clones and vulnerable instructions. this tool demonstration shows the features of ldiff, an enhanced, language-independent line differencing tool. l-diff builds upon the unix diff and overcomes its limitations in determining whether an artifact line has been changed or is the result of additions and removals, and in tracking artifact fragments that have been moved upward or downward within the file. the paper describes the tool and shows its capability of analyzing changes on different kinds of software artifacts, including use cases, code developed with different programming languages, and test cases.
equality and hashing for (almost) free: generating implementations from abstraction functions. in an object-oriented language such as java, every class requires implementations of two special methods, one for determining equality and one for computing hash codes. although the specification of these methods is usually straightforward, they can be hard to code (due to subclassing, delegation, cyclic references, and other factors) and often harbor subtle faults. a technique is presented that simplifies this task. instead of writing code for the methods, the programmer gives, as a brief annotation, an abstraction function that defines an abstract view of an object's representation, and sometimes an additional observer in the form of an iterator method. equality and hash codes are then computed in library code that uses reflection to read the annotations. experiments on a variety of programs suggest that, in comparison to writing the methods by hand, our technique requires less text from the programmer and results in methods that are more often correct.
holmes: effective statistical debugging via efficient path profiling. statistical debugging aims to automate the process of isolating bugs by profiling several runs of the program and using statistical analysis to pinpoint the likely causes of failure. in this paper, we investigate the impact of using richer program profiles such as path profiles on the effectiveness of bug isolation. we describe a statistical debugging tool called holmes that isolates bugs by finding paths that correlate with failure. we also present an adaptive version of holmes that uses iterative, bug-directed profiling to lower execution time and space overheads. we evaluate holmes using programs from the sir benchmark suite and some large, real-world applications. our results indicate that path profiles can help isolate bugs more precisely by providing more information about the context in which bugs occur. moreover, bug-directed profiling can efficiently isolate bugs with low overheads, providing a scalable and accurate alternative to sparse random sampling.
validation of contracts using enabledness preserving finite state abstractions. pre/post condition-based specifications are common-place in a variety of software engineering activities that range from requirements through to design and implementation. the fragmented nature of these specifications can hinder validation as it is difficult to understand if the specifications for the various operations fit together well. in this paper we propose a novel technique for automatically constructing abstractions in the form of behaviour models from pre/post condition-based specifications. the level of abstraction at which such models are constructed preserves enabledness of sets of operations, resulting in a finite model that is intuitive to validate and which facilitates tracing back to the specification for debugging. the paper also reports on the application of the approach to an industrial strength protocol specification in which concerns were identified.
improving api documentation usability with knowledge pushing. the documentation of api functions typically conveys detailed specifications for the benefit of interested readers. in some cases, however, it also contains usage directives, such as rules or caveats, of which authors of invoking code must be made aware to prevent errors and inefficiencies. there is a risk that these directives may be “lost” within the verbose text, or that the text would not be read because there are so many invoked functions. to address these concerns for java, an eclipse plug-in named emoose decorates method invocations whose targets have associated directives. our goal is to lead readers to investigate further, which we aid by highlighting the tagged directives in the javadoc hover. we present a lab study that demonstrates the directive awareness problem in traditional documentation use and the potential benefits of our approach.
featurehouse: language-independent, automated software composition. superimposition is a composition technique that has been applied successfully in many areas of software development. although superimposition is a general-purpose concept, it has been (re)invented and implemented individually for various kinds of software artifacts. we unify languages and tools that rely on superimposition by using the language-independent model of feature structure trees (fsts). on the basis of the fst model, we propose a general approach to the composition of software artifacts written in different languages, furthermore, we offer a supporting framework and tool chain, called featurehouse. we use attribute grammars to automate the integration of additional languages, in particular, we have integrated java, c#, c, haskell, javacc, and xml. several case studies demonstrate the practicality and scalability of our approach and reveal insights into the properties a language must have in order to be ready for superimposition.
contextserv: a platform for rapid and flexible development of context-aware web services. context-aware web services are currently emerging as an important technology for building innovative context-aware applications. unfortunately, context-aware web services are still difficult to build. this paper describes contextserv, a platform for rapid development of context-aware web services. contextserv adopts model-driven development where context-aware web services are specified using contextuml, a uml based modeling language. the platform also offers a set of automated tools for generating and deploying executable implementations of context-aware web services. this paper presents the motivation, system design, implementation, and usage of contextserv.
a toolset for automated failure analysis. classic fault localization techniques can automatically provide information about the suspicious code blocks that are likely responsible for observed failures. this information is useful, but not sufficient to completely understand the causes of failing executions, which still require further (time-consuming) investigations to be exactly identified.
automatic dimension inference and checking for object-oriented programs. this paper introduces unifi, a tool that attempts to automatically detect dimension errors in java programs. unifi infers dimensional relationships across primitive type and string variables in a program, using an inter-procedural, context-sensitive analysis. it then monitors these dimensional relationships as the program evolves, flagging inconsistencies that may be errors. unifi requires no programmer annotations, and supports arbitrary program-specific dimensions, thus providing fine-grained dimensional consistency checking. unifi exploits features of object-oriented languages, but can be used for other languages as well. we have run unifi on real-life java code and found that it is useful in exposing dimension errors. we present a case study of using unifi on nightly builds of a 19,000 line code base as it evolved over 10 months.
junitmx - a change-aware unit testing tool. developers use unit testing to improve the quality of software systems. current development tools for unit testing help with automating test execution, with reporting results, and with generating test stubs. however, they offer no aid for designing tests aimed specifically at exercising the effects of changes to a program. this paper describes a unit testing tool that leverages a change model to assist developers in the creation of new unit tests. the tool provides developers with quantitative feedback and detailed information about change effects, which not only facilitate the writing of more effective tests, but also motivate developers with an achievable coverage goal.
smarttutor: creating ide-based interactive tutorials via editable replay. interactive tutorials, like eclipse's cheat sheets, are good for novice programmers to learn how to perform tasks (e.g., checking out a cvs project) in an integrated development environment (ide). creating these tutorials often requires programming effort that is time-consuming and difficult. in this paper, we propose an approach using editable replay of user actions to help authors create interactive tutorials with little programming effort. user actions of performing a task can be recorded, edited, and presented as a tutorial. the tutorial can be replayed interactively for mentoring. we present our smarttutor implementation in the eclipse ide and conduct a preliminary evaluation on it, which demonstrates efficiency gains for the tutorial authors.
reasoning about edits to feature models. features express the variabilities and commonalities among programs in a software product line (spl). a feature model defines the valid combinations of features, where each combination corresponds to a program in an spl. spls and their feature models evolve over time. we classify the evolution of a feature model via modifications as refactorings, specializations, generalizations, or arbitrary edits. we present an algorithm to reason about feature model edits to help designers determine how the program membership of an spl has changed. our algorithm takes two feature models as input (before and after edit versions), where the set of features in both models are not necessarily the same, and it automatically computes the change classification. our algorithm is able to give examples of added or deleted products and efficiently classifies edits to even large models that have thousands of features.
modular string-sensitive permission analysis with demand-driven precision. in modern software systems, programs are obtained by dynamically assembling components. this has made it necessary to subject component providers to access-control restrictions. what permissions should be granted to each component? too few permissions may cause run-time authorization failures, too many constitute a security hole. we have designed and implemented a composite algorithm for precise static permission analysis for java and the clr. unlike previous work, the analysis is modular and fully integrated with a novel slicing-based string analysis that is used to statically compute the string values defining a permission and disambiguate permission propagation paths. the results of our research prototype on production-level java code support the effectiveness, practicality, and precision of our techniques, and show outstanding improvement over previous work.