waashk/dblp huggingface dataset:
feedback-directed random test generation. we present a technique that improves random test generation by incorporating feedback obtained from executing test inputs as they are created. our technique builds inputs incrementally by randomly selecting a method call to apply and finding arguments from among previously-constructed inputs. as soon as an input is built, it is executed and checked against a set of contracts and filters. the result of the execution determines whether the input is redundant, illegal, contract-violating, or useful for generating more inputs. the technique outputs a test suite consisting of unit tests for the classes under test. passing tests can be used to ensure that code contracts are preserved across program changes; failing tests (that violate one or more contract) point to potential errors that should be corrected. our experimental results indicate that feedback-directed random test generation can outperform systematic and undirected random test generation, in terms of coverage and error detection. on four small but nontrivial data structures (used previously in the literature), our technique achieves higher or equal block and predicate coverage than model checking (with and without abstraction) and undirected random generation. on 14 large, widely-used libraries (comprising 780kloc), feedback-directed random test generation finds many previously-unknown errors, not found by either model checking or undirected random generation.
automatic inference of structural changes for matching across program versions. mapping code elements in one version of a program to corresponding code elements in another version is a fundamental building block for many software engineering tools. existing tools that match code elements or identify structural changes--refactorings and api changes--between two versions of a program have two limitations that we overcome. first, existing tools cannot easily disambiguate among many potential matches or refactoring candidates. second, it is difficult to use these tools' results for various software engineering tasks due to an unstructured representation of results. to overcome these limitations, our approach represents structural changes as a set of high-level change rules, automatically infers likely change rules and determines method-level matches based on the rules. by applying our tool to several open source projects, we show that our tool identifies matches that are difficult to find using other approaches and produces more concise results than other approaches. our representation can serve as a better basis for other software engineering tools.
presentations by programmers for programmers. common form of live technical presentation is that given by programmers for a programming audience during conferences, demonstrations, code reviews, and tutorials. such presentations require manual switching between general presentation software and the integrated development environment (ide), as well as reconfiguration of the ide's ui to be readable by an audience. in this paper, we present a novel system that allows programmers to easily combine traditional slideware with seamless transitions to user-specified regions of the ide along with special effects for live demonstration.
path-sensitive inference of function precedence protocols. function precedence protocols define ordering relations among function calls in a program. in some instances, precedence protocols are well-understood (e.g., a call to pthread mutex init must always be present on all program paths before a call to pthread mutex lock ). oftentimes, however, these protocols are neither well-documented, nor easily derived. as a result, protocol violations can lead to subtle errors that are difficult to identify and correct. in this paper, we present chronicler, a tool that applies scalable inter-procedural path-sensitive static analysis to automatically infer accurate function precedence protocols. chronicler computes precedence relations based on a program's control-flow structure, integrates these relations into a repository, and analyzes them using sequence mining techniques to generate a collection of feasible precedence protocols. deviations from these protocols found in the program are tagged as violations, and represent potential sources of bugs. we demonstrate chronicler's effectiveness by deriving protocols for a collection of benchmarks ranging in size from 66k to 2m lines of code. our results not only confirm the existence of bugs in these programs due to precedence protocol violations, but also highlight the importance of path sensitivity on accuracy and scalability.
reflections on software engineering education. in recent years, the software engineering community has focused on organizing its existing knowledge and finding opportunities to transform that knowledge into a university curriculum. swebok (the guide to the software engineering body of knowledge) and software engineering 2004 are two initiatives to that end. while these projects have increased se education's visibility, they've also focused largely on se's engineering aspects, at the expense of its human and social dimensions. this article describes how a pure engineering approach contributes to traps that se educators can fall into that in turn can mislead students as to se's true nature.
predicting faults from cached history. we analyze the version history of 7 software systems to predict the most fault prone entities and files. the basic assumption is that faults do not occur in isolation, but rather in bursts of several related faults. therefore, we cache locations that are likely to have faults: starting from the location of a known (fixed) fault, we cache the location itself, any locations changed together with the fault, recently added locations, and recently changed locations. by consulting the cache at the moment a fault is fixed, a developer can detect likely fault-prone locations. this is useful for prioritizing verification and validation resources on the most fault prone files or entities. in our evaluation of seven open source projects with more than 200,000 revisions, the cache selects 10% of the source code files; these files account for 73%-95% of faults--a significant advance beyond the state of the art
uml/analyzer: a tool for the instant consistency checking of uml models. large design models contain thousands of model elements. designers easily get overwhelmed maintaining the consistency of such design models over time. not only is it hard to detect new inconsistencies while the model changes but it also hard to keep track of known inconsistencies. the uml/analyzer tool identifies inconsistencies instantly with design changes and it keeps track of all inconsistencies over time. it does not require consistency rules with special annotations. instead, it treats consistency rules as black-box entities and observes their behavior during their evaluation. the uml/analyzer tool is integrated with the uml modeling tool ibm rational rose^tm for broad applicability and usability. it is highly scalable and was evaluated on dozens of design models.
mining security-sensitive operations in legacy code using concept analysis. his paper presents an approach to statically retrofit legacy servers with mechanisms for authorization policy enforcement. the approach is based upon the obser- vation that security-sensitive operations performed by a server are characterized by idiomatic resource manipula- tions, called fingerprints. candidate fingerprints are auto- matically mined by clustering resource manipulations using concept analysis. these fingerprints are then used to iden- tify security-sensitive operations performed by the server. case studies with three real-world servers show that the approach can be used to identify security-sensitive opera- tions with a few hours of manual effort and modest domain knowledge.
applying template meta-programming techniques for a domain-specific visual language--an industrial experience report. template meta-programming techniques can be used to increase efficiency in software development. these techniques have traditionally been used with textual programming languages, such as c++. in this paper, we discuss how corresponding techniques can be used with visual languages. the visual language under study in this paper is function block language (fbl). fbl is used in metso automation for writing automation control programs that are executed in real-time distributed environments. efficient development of high quality programs and easy customizability of existing programs are key requirements in practical customer projects. these requirements have been one of the main motivations to develop template meta-programming support in fbl discussed. in this paper, we focus both on the technical aspects and on the lessons learnt from programmers' experiences and ways to work with templates. fbl and the programming techniques proposed have been used in hundreds of real-world projects at metso automation.
goaldebug: a spreadsheet debugger for end users. we present a spreadsheet debugger targeted at end users. whenever the computed output of a cell is incorrect, the user can supply an expected value for a cell, which is employed by the system to generate a list of change suggestions for formulas that, when applied, would result in the user-specified output. the change suggestions are ranked using a set of heuristics. in previous work, we had presented the system as a proof of concept. in this paper, we describe a systematic evaluation of the effectiveness of inferred change suggestions and the employed ranking heuristics. based on the results of the evaluation we have extended both, the change inference process and the ranking of suggestions. an evaluation of the improved system shows that change inference process and the ranking heuristics have both been substantially improved and that the system performs effectively.
softguess: visualization and exploration of code clones in context. we introduce softguess, a code clone exploration system. softguess is built on the more general guess system which provides users with a mechanism to interactively explore graph structures both through direct manipulation as well as a domain-specific language. we demonstrate softguess through a number of mini-applications to analyze evolutionary code-clone behavior in software systems. the mini-applications of softguess represent a novel way of looking at code-clones in the context of many system features. it is our hope that softguess will form the basis for other analysis tools in the software-engineering domain.
automated inference of pointcuts in aspect-oriented refactoring. software refactoring is the process of reorganizing the internal structure of code while preserving the external behavior. aspect-oriented programming (aop) provides new modularization of software systems by encapsulating crosscutting concerns. based on these two techniques, aspect-oriented (ao) refactoring restructures crosscutting elements in code. ao refactoring includes two steps: aspect mining (identification of aspect candidates in code) and as- pect refactoring (semantic-preserving transformation to mi- grate the aspect-candidate code to ao code). aspect refac- toring clusters similar join points together for the aspect candidates and encapsulates each cluster with an effective pointcut definition. with the increase in size of the code and crosscutting concerns, it is tedious to manually identify aspects and their corresponding join points, cluster the join points, and infer pointcut expressions. therefore, there is a need to auto- mate the process of ao refactoring. this paper proposes an automated approach that identifies aspect candidates in code and infers pointcut expressions for these aspects. our approach mines for aspect candidates, identifies the join points for the aspect candidates, clusters the join points, and infers an effective pointcut expression for each clus- ter of join points. the approach also provides an addi- tional testing mechanismto ensure that the inferred pointcut expressions are of correct strength. the empirical results show that our approach helps achieve a significant reduc- tion in the total number of pointcut expressions to be used in the refactored code.
synthesis: a tool for automatically assembling correct and distributed component-based systems. synthesis is a tool for automatically assembling correct and distributed component-based systems. in our context, a system is correct when it is deadlock-free and performs only specified component interactions. in order to automatically synthesize the correct composition code, synthesis takes as input an high-level behavioural description for each component that must form the system to be built and a specification of the component interactions that must be enforced in the system. the automatically derived composition code is implemented as a set of distributed component wrappers that cooperatively interact with each other and with their wrapped components in order to prevent possible deadlocks and make the composed system exhibit only the specified interactions. the current version of synthesis supports two possible development platforms: microsoft com/dcom, and ejb (enterprise java beans).
on accurate automatic verification of publish-subscribe architectures. the paper presents a novel approach based on bogor for the accurate verification of applications based on publish- subscribe infrastructures. previous efforts adopted standard model checking techniques to verify the application behavior, but they introduce strong simplifications on the underlying infrastructure to cope with the state space explosion problem and make automatic verification feasible. instead of building on top of existing model checkers, our proposal embeds the asynchronous communication mechanisms of publish-subscribe infrastructures within bogor. this way, publish-subscribe primitives become part of the specification language as additional, domain-specific, constructs. accurate models become feasible without incurring in state space explosion problems, thus enabling the automated verification of applications on top of realistic communication infrastructures.
enhancing software testing by judicious use of code coverage information. recently, tools for the analysis and visualization of code coverage have become widely available. at first glance, their value in assessing and improving the quality of automated test suites seems to be obvious. yet, experimental studies as well as experience from projects in industry indicate that their use is not without pitfalls. we found these tools in a number of recent projects quite beneficial. therefore, we set out to gather code coverage information from one of these projects. in this experience report, first the system under scrutiny as well as our methodology is described. then, four major questions concerning the impact and benefits of using these tools are discussed. furthermore, a list of ten lessons learned is derived. the list may help developers judiciously use code coverage tools, in order to reap a maximum of benefits.
model-based security engineering of distributed information systems using umlsec. given the explosive growth of digitally stored information in modern enterprises, distributed information systems together with search engines are increasingly used in companies. by enabling the user to search all relevant information sources with one single query, however, crucial risks concerning information security arise. in order to make these applications secure, it is not sufficient to penetrate-and- patch past system development, but security analysis has to be an integral part of the system design process for such distributed information systems. this work presents the experiences and results of the security analysis of a search engine in the intranet of a german car manufacturer, by making use of an approach to model-based security engineering that is based on the uml extension umlsec. the focus lies on the application's single-sign-on-mechanism, which was analyzed using the umlsec method and tools. main results of the paper include a field report on the employment of the umlsec method in an industrial context as well as indications on its benefits and limitations.
tool support for developing advanced mechatronic systems: integrating the fujaba real-time tool suite with camel-view. the next generation of advanced mechatronic systems is expected to use its software to exploit local and global networking capabilities to enhance their functionality and to adapt their local behavior when beneficial. such systems will therefore include complex hard real-time coordination at the network level. this coordination is further reflected locally by complex reconfiguration in form of mode management and control algorithms. we present in this paper the integration of two tools which allow the integrated specification of real-time coordination and traditional control engineering specifically targeting the required complex reconfiguration of the local behavior.
using experiments in software engineering as an auxiliary tool for teaching--a qualitative evaluation from the perspective of students' learning process. in this paper we discuss issues of using students as subjects from the perspective of their benefits in terms of learning. we conduct interviews with students who participated in the experiments and present their perceptions of the experiments in order to validate the claims posed in the existing literature. finally we show quantitative data on the rate of obtaining the distinctive pass grades for courses with and without experiments. the results show that integrating experiments with courses could lead to improvements of the performance of students on courses.
an empirical study of the evolution of an agile-developed software system. we have analyzed evolution patterns over two and a half years for a system developed using extreme programming. we find that the system shows a smooth pattern of growth overall, that (mccabe) code complexity is low, and that the relative amount of complexity control work (e.g. refactoring) is higher than in other systems we have studied. to interpret these results, we have drawn on qualitative data including the results of an observational study, records of progress and productivity, and comments on our findings from team members.
using gui run-time state as feedback to generate test cases. this paper presents a new automated model-driven technique to generate test cases by using feedback from the execution of a .seed test suite. on an application under test (aut). the test cases in the seed suite are designed to be generated automatically and executed very quickly. during their execution, feedback obtained from the aut's run-time state is used to generate new, .improved. test cases. the new test cases subsequently become part of the seed suite. this .anytime technique. continues iteratively, generating and executing additional test cases until resources are exhausted or testing goals have been met. the feedback-based technique is demonstrated for automated testing of graphical user interfaces (guis). an existing abstract model of the gui is used to automatically generate the seed test suite. it is executed; during its execution, state changes in the gui pinpoint important relationships between gui events, which evolve the model and help to generate new test cases. together with a reverse-engineering algorithm used to obtain the initial model and seed suite, the feedback-based technique yields a fully automatic, end-to-end gui testing process. a feasibility study on four large fielded open-source software (oss) applications demonstrates that this process is able to significantly improve existing techniques and help identify/report serious problems in the oss. in response, these problems have been fixed by the developers of the oss in subsequent versions.
the role of experience and ability in comprehension tasks supported by uml stereotypes. proponents of design notations tailored for specific application domains or reference architectures, often available in the form of uml stereotypes, motivate them by improved understandability and modifiability. however, empirical studies that tested such claims report contradictory results, where the most intuitive notations are not always the best performing ones. this indicates the possible existence of relevant influencing factors, other than the design notation itself. in this work we report the results of a family of three experiments performed at different locations and with different subjects, in which we assessed the effectiveness of uml stereotypes for web design in support to comprehension tasks. replications with different subjects allowed us to investigate whether subjects' ability and experience play any role in the comprehension of stereotyped diagrams. we observed different behaviors of users with different degrees of ability and experience, which suggests alternative comprehension strategies of (and tool support for) different categories of users.
usability implications of requiring parameters in objects' constructors. the usability of apis is increasingly important to programmer productivity. based on experience with usability studies of specific apis, techniques were explored for studying the usability of design choices common to many apis. a comparative study was performed to assess how professional programmers use apis with required parameters in objects' constructors as opposed to parameterless "default" constructors. it was hypothesized that required parameters would create more usable and self-documenting apis by guiding programmers toward the correct use of objects and preventing errors. however, in the study, it was found that, contrary to expectations, programmers strongly preferred and were more effective with apis that did not require constructor parameters. participants' behavior was analyzed using the cognitive dimensions framework, and revealing that required constructor parameters interfere with common learning strategies, causing undesirable premature commitment.
software development environments for scientific and engineering software: a series of case studies. the need for high performance computing applications for computational science and engineering projects is growing rapidly, yet there have been few detailed studies of the software engineering process used for these applications. the darpa high productivity computing systems program has sponsored a series of case studies of representative computational science and engineering projects to identify the steps involved in developing such applications (i.e. the life cycle, the workflows, technical challenges, and organizational challenges). secondary goals were to characterize tool usage and identify enhancements that would increase the programmers' productivity. finally, these studies were designed to develop a set of lessons learned that can be transferred to the general computational science and engineering community to improve the software engineering process used for their applications. nine lessons learned from five representative projects are presented, along with their software engineering implications, to provide insight into the software development environments in this domain.
good practices for educational software engineering projects. recent publications indicate the importance of software engineering in the computer science curriculum. in this paper, we present the final part of software engineering education at university of groningen in the netherlands and växjö university in sweden, where student teams perform an industrial software development project. it furthermore presents the main educational problems encountered in such real-life projects and explains how this international course addresses these problems. the main contribution of this paper is a set of seven good practices for project based software engineering education.