waashk/dblp huggingface dataset:
featureide: a tool framework for feature-oriented software development. tools support is crucial for the acceptance of a new programming language. however, providing such tool support is a huge investment that can usually not be provided for a research language. with featureide, we have built an ide for ahead that integrates all phases of feature-oriented software development. to reuse this investment for other tools and languages, we refactored featureide into an open source framework that encapsulates the common ideas of feature-oriented software development and that can be reused and extended beyond ahead. among others, we implemented extensions for featurec++ and featurehouse, but in general, featureide is open for everybody to showcase new research results and make them usable to a wide audience of students, researchers, and practitioners.
how tagging helps bridge the gap between social and technical aspects in software development. empirical research on collaborative software development practices indicates that technical and social aspects of software development are often intertwined. the processes followed are tacit and constantly evolving, thus not all of them are amenable to formal tool support. in this paper, we explore how “tagging”, a lightweight social computing mechanism, is used to bridge the gap between technical and social aspects of managing work items. we present the results from an empirical study on how tagging has been adopted and adapted over the past two years of a large project with 175 developers. our research shows that the tagging mechanism was eagerly adopted by the team, and that it has become a significant part of many informal processes. our findings indicate that lightweight informal tool support, prevalent in the social computing domain, may play an important role in improving team-based software development practices.
taint-based directed whitebox fuzzing. we present a new automated white box fuzzing technique and a tool, buzzfuzz, that implements this technique. unlike standard fuzzing techniques, which randomly change parts of the input file with little or no information about the underlying syntactic structure of the file, buzzfuzz uses dynamic taint tracing to automatically locate regions of original seed input files that influence values used at key program attack points (points where the program may contain an error). buzzfuzz then automatically generates new fuzzed test input files by fuzzing these identified regions of the original seed input files. because these new test files typically preserve the underlying syntactic structure of the original seed input files, they tend to make it past the initial input parsing components to exercise code deep within the semantic core of the computation. we have used buzzfuzz to automatically find errors in two open-source applications: swfdec (an adobe flash player) and mupdf (a pdf viewer). our results indicate that our new directed fuzzing technique can effectively expose errors located deep within large programs. because the directed fuzzing technique uses taint to automatically discover and exploit information about the input file format, it is especially appropriate for testing programs that have complex, highly structured input file formats.
concernlines: a timeline view of co-occurring concerns. understanding the evolution of a software system requires understanding how information about the release history, non-functional requirements and project milestones relates to functional requirements on the software components. this short paper describes a new tool, called concernlines, that supports this cognitive process by visualizing co-occurring concerns over time.
clonedetective - a workbench for clone detection research. the area of clone detection has considerably evolved over the last decade, leading to approaches with better results, but at the same time using more elaborate algorithms and tool chains. in our opinion a level has been reached, where the initial investment required to setup a clone detection tool chain and the code infrastructure required for experimenting with new heuristics and algorithms seriously hampers the exploration of novel solutions or specific case studies. as a solution, this paper presents clonedetective, an open source framework and tool chain for clone detection, which is especially geared towards configurability and extendability and thus supports the preparation and conduction of clone detection research.
how to avoid drastic software process change (using stochastic stability). before performing drastic changes to a project, it is worthwhile to thoroughly explore the available options within the current structure of a project. an alternative to drastic change are internal changes that adjust current options within a software project. in this paper, we show that the effects of numerous internal changes can out-weigh the effects of drastic changes. that is, the benefits of drastic change can often be achieved without disrupting a project.
mints: a general framework and tool for supporting test-suite minimization. test-suite minimization techniques aim to eliminate redundant test cases from a test-suite based on some criteria, such as coverage or fault-detection capability. most existing test-suite minimization techniques have two main limitations: they perform minimization based on a single criterion and produce suboptimal solutions. in this paper, we propose a test-suite minimization framework that overcomes these limitations by allowing testers to (1) easily encode a wide spectrum of test-suite minimization problems, (2) handle problems that involve any number of criteria, and (3) compute optimal solutions by leveraging modern integer linear programming solvers. we implemented our framework in a tool, called mints, that is freely-available and can be interfaced with a number of different state-of-the-art solvers. our empirical evaluation shows that mints can be used to instantiate a number of different test-suite minimization problems and efficiently find an optimal solution for such problems using different solvers.
wise: automated test generation for worst-case complexity. program analysis and automated test generation have primarily been used to find correctness bugs. we present complexity testing, a novel automated test generation technique to find performance bugs. our complexity testing algorithm, which we call wise (worst-case inputs from symbolic execution), operates on a program accepting inputs of arbitrary size. for each input size, wise attempts to construct an input which exhibits the worst-case computational complexity of the program. wise uses exhaustive test generation for small input sizes and generalizes the result of executing the program on those inputs into an “input generator.” the generator is subsequently used to efficiently generate worst-case inputs for larger input sizes. we have performed experiments to demonstrate the utility of our approach on a set of standard data structures and algorithms. our results show that wise can effectively generate worstcase inputs for several of these benchmarks.
does distributed development affect software quality? an empirical case study of windows vista. it is widely believed that distributed software development is riskier and more challenging than collocated development. prior literature on distributed development in software engineering and other fields discuss various challenges, including cultural barriers, expertise transfer difficulties, and communication and coordination overhead. we evaluate this conventional belief by examining the overall development of windows vista and comparing the post-release failures of components that were developed in a distributed fashion with those that were developed by collocated teams. we found a negligible difference in failures. this difference becomes even less significant when controlling for the number of developers working on a binary. we also examine component characteristics such as code churn, complexity, dependency information, and test code coverage and find very little difference between distributed and collocated components to investigate if less complex components are more distributed. further, we examine the software process and phenomena that occurred during the vista development cycle and present ways in which the development process utilized may be insensitive to geography by mitigating the difficulties introduced in prior work in this area.
automatic creation of sql injection and cross-site scripting attacks. we present a technique for finding security vulnerabilities in web applications. sql injection (sqli) and cross-site scripting (xss) attacks are widespread forms of attack in which the attacker crafts the input to the application to access or modify user data and execute malicious code. in the most serious attacks (called second-order, or persistent, xss), an attacker can corrupt a database so as to cause subsequent users to execute malicious code.
discovering and representing systematic code changes. software engineers often inspect program differences when reviewing others' code changes, when writing check-in comments, or when determining why a program behaves differently from expected behavior after modification. program differencing tools that support these tasks are limited in their ability to group related code changes or to detect potential inconsistencies in those changes. to overcome these limitations and to complement existing approaches, we built logical structural diff (lsdiff), a tool that infers systematic structural differences as logic rules. lsdiff notes anomalies from systematic changes as exceptions to the logic rules. we conducted a focus group study with professional software engineers in a large e-commerce company; we also compared lsdiff's results with textual differences and with structural differences without rules. our evaluation suggests that lsdiff complements existing differencing tools by grouping code changes that form systematic change patterns regardless of their distribution throughout the code, and its ability to discover anomalies shows promise in detecting inconsistent changes.
cocoviz with ambient audio software exploration. for ages we used our ears side by side with our ophthalmic stimuli to gather additional information, leading and supporting us in our visualization. nowadays numerous software visualization techniques exist that aim to facilitate program comprehension. in this paper we discuss how we can support such software comprehension visualization with environmental audio and lead users to identify relevant aspects. we use cognitive visualization techniques and audio concepts described in our previous work to create an ambient audio software exploration (aase) out of program entities (packages, classes …) and their mapped properties. the concepts where implemented in a extended version of our tool called cocoviz. our first results with the prototype shows that with this combination of visual and aural means we can provide additional information to lead users during program comprehension tasks.
automatically capturing source code context of nl-queries for software maintenance and reuse. as software systems continue to grow and evolve, locating code for maintenance and reuse tasks becomes increasingly difficult. existing static code search techniques using natural language queries provide little support to help developers determine whether search results are relevant, and few recommend alternative words to help developers reformulate poor queries. in this paper, we present a novel approach that automatically extracts natural language phrases from source code identifiers and categorizes the phrases and search results in a hierarchy. our contextual search approach allows developers to explore the word usage in a piece of software, helping them to quickly identify relevant program elements for investigation or to quickly recognize alternative words for query reformulation. an empirical evaluation of 22 developers reveals that our contextual search approach significantly outperforms the most closely related technique in terms of effort and effectiveness.
do code clones matter? code cloning is not only assumed to inflate maintenance costs but also considered defect-prone as inconsistent changes to code duplicates can lead to unexpected behavior. consequently, the identification of duplicated code, clone detection, has been a very active area of research in recent years. up to now, however, no substantial investigation of the consequences of code cloning on program correctness has been carried out. to remedy this shortcoming, this paper presents the results of a large-scale case study that was undertaken to find out if inconsistent changes to cloned code can indicate faults. for the analyzed commercial and open source systems we not only found that inconsistent changes to clones are very frequent but also identified a significant number of faults induced by such changes. the clone detection tool used in the case study implements a novel algorithm for the detection of inconsistent clones. it is available as open source to enable other researchers to use it as basis for further investigations.
effective static deadlock detection. we present an effective static deadlock detection algorithm for java. our algorithm uses a novel combination of static analyses each of which approximates a different necessary condition for a deadlock. we have implemented the algorithm and report upon our experience applying it to a suite of multi-threaded java programs. while neither sound nor complete, our approach is effective in practice, finding all known deadlocks as well as discovering previously unknown ones in our benchmarks with few false alarms.
in-field healing of integration problems with cots components. developers frequently integrate complex cots frameworks and components in software applications. cots products are often only partially documented, and developers may misuse technologies and introduce integration faults, as witnessed by the many entries in fault repositories. once identified, common integration problems and their fixes are usually documented in forums and fault repositories on the web, but this does not prevent them to occur in the field when cots products are reused.
listening to programmers - taxonomies and characteristics of comments in operating system code. innovations from multiple directions have been proposed to improve software reliability. unfortunately, many of the innovations are not fully exploited by programmers. to bridge the gap, this paper proposes a new approach to “listen” to thousands of programmers: studying their programming comments. since comments express programmers' assumptions and intentions, comments can reveal programmers' needs, which can provide guidance (1) for language/-tool designers on where they should develop new techniques or enhance the usability of existing ones, and (2) for programmers on what problems are most pervasive and important so that they should take initiatives to adopt some existing tools or language extensions. we studied 1050 comments randomly sampled from the latest versions of linux, freebsd, and opensolaris. we found that 52.6% of these comments could be leveraged by existing or to-be-proposed tools for improving reliability. our findings include: (1) many comments describe code relationships, code evolutions, or the usage and meaning of integers and integer macros, (2) a significant amount of comments could be expressed by existing annotation languages, and (3) many comments express synchronization related concerns but are not well supported by annotation languages.
save-ide - a tool for design, analysis and implementation of component-based embedded systems. the paper presents save-ide, an integrated development environment for the development of component-based embedded systems. save-ide supports efficient development of dependable embedded systems by providing tools for design of embedded software systems using a dedicated component model, formal specification and analysis of component and system behaviors already in early development phases, and a fully automated transformation of the system of components into an executable image.
locating need-to-translate constant strings for software internationalization. modern software applications require internationalization to be distributed to different regions of the world. in various situations, many software applications are not internationalized at early stages of development. 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 into 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 necessary task that developers must complete for internationalization. in this paper, we present an approach to automatically locating need-to-translate constant strings. our approach first collects a list of api methods related to the graphical user interface (gui), and then searches for need-to-translate strings from the invocations of these api methods based on string-taint analysis. we evaluated our approach on four real-world open source applications: rtext, risk, artofillusion, and megamek. the results show that our approach effectively locates most of the need-to-translate constant strings in all the four applications.
synthesizing intensional behavior models by graph transformation. this paper describes an approach (spy) to recovering the specification of a software component from the observation of its run-time behavior. it focuses on components that behave as data abstractions. components are assumed to be black boxes that do not allow any implementation inspection. the inferred description may help understand what the component does when no formal specification is available. spy works in two main stages. first, it builds a deterministic finite-state machine that models the partial behavior of instances of the data abstraction. this is then generalized via graph transformation rules. the rules can generate a possibly infinite number of behavior models, which generalize the description of the data abstraction under an assumption of “regularity” with respect to the observed behavior. the rules can be viewed as a likely specification of the data abstraction. we illustrate how spy works on relevant examples and we compare it with competing methods.
ueman: a tool to manage user evaluation in development environments. one of the challenges in software development is to collect and analyze the end users' feedback in an effective and efficient manner. in this paper we present a tool to manage user evaluation alongside the process of software development. the tool is based on the idea that user evaluation should be managed iteratively from within the integrated development environment (ide) in order to provide high quality user interface. the main capabilities include creating the experiment object as part of the software project; deriving development tasks from the analysis of evaluation data; and tracing these tasks to and from the code. further, we provide a library to enable development of java aspects for creation of automatic measures to increase the body of the evaluation data. using this tool, development teams can manage user-centered design (ucd) activities at the ide level, hence developing software products with an adequate level of usability.
accurate interprocedural null-dereference analysis for java. null dereference is a commonly occurring defect in java programs, and many static-analysis tools identify such defects. however, most of the existing tools perform a limited interprocedural analysis. in this paper, we present an interprocedural path-sensitive and context-sensitive analysis for identifying null dereferences. starting at a dereference statement, our approach performs a backward demand-driven analysis to identify precisely paths along which null values may flow to the dereference. the demand-driven analysis avoids an exhaustive program exploration, which lets it scale to large programs. we present the results of empirical studies conducted using large open-source and commercial products. our results show that: (1) our approach detects fewer false positives, and significantly more interprocedural true positives, than other commonly used tools; (2) the analysis scales to large subjects; and (3) the identified defects are often deleted in subsequent releases, which indicates that the reported defects are important.
semantics-based code search. our goal is to use the vast repositories of available open source code to generate specific functions or classes that meet a user's specifications. the key words here are specifications and generate. we let users specify what they are looking for as precisely as possible using keywords, class or method signatures, test cases, contracts, and security constraints. our system then uses an open set of program transformations to map retrieved code into what the user asked for. this approach is implemented in a prototype system for java with a web interface.
complete and accurate clone detection in graph-based models. model-driven engineering (mde) has become an important development framework for many large-scale software. previous research has reported that as in traditional code-based development, cloning also occurs in mde. however, there has been little work on clone detection in models with the limitations on detection precision and completeness. this paper presents modelcd, a novel clone detection tool for matlab/simulink models, that is able to efficiently and accurately detect both exactly matched and approximate model clones. the core of modelcd is two novel graph-based clone detection algorithms that are able to systematically and incrementally discover clones with a high degree of completeness, accuracy, and scalability. we have conducted an empirical evaluation with various experimental studies on many real-world systems to demonstrate the usefulness of our approach and to compare the performance of modelcd with existing tools.
invariant-based automatic testing of ajax user interfaces. ajax-based web 2.0 applications rely on stateful asynchronous client/server communication, and client-side runtime manipulation of the dom tree. this not only makes them fundamentally different from traditional web applications, but also more error-prone and harder to test. we propose a method for testing ajax applications automatically, based on a crawler to infer a flow graph for all (client-side) user interface states. we identify ajax-specific faults that can occur in such states (related to dom validity, error messages, discoverability, back-button compatibility, etc.) as well as dom-tree invariants that can serve as oracle to detect such faults. we implemented our approach in atusa, a tool offering generic invariant checking components, a plugin-mechanism to add application-specific state validators, and generation of a test suite covering the paths obtained during crawling. we describe two case studies evaluating the fault revealing capabilities, scalability, required manual effort and level of automation of our approach.