waashk/dblp huggingface dataset:
efficient forward computation of dynamic slices using reduced ordered binary decision diagrams. dynamic slicing algorithms can greatly reduce the debuggingeffort by focusing the attention of the user on a relevantsubset of program statements. recently algorithms forforward computation of dynamic slices have beenproposed which maintain dynamic slices of all variables asthe program executes. an advantage of this approach is thatwhen a request for a slice is made, it is already available.the main disadvantage of using such an algorithm for slicingrealistic programs is that the space and time requiredto maintain a large set of dynamic slices corresponding toall program variables can be very high. in this paper weanalyze the characteristics of dynamic slices and identifyproperties that enable space efficient representation of a setof dynamic slices. we show that by using reduced orderedbinary decision diagrams (robdds) to represent a set ofdynamic slices, the space and time requirements of maintainingdynamic slices are greatly reduced. in fact not onlycan the latest dynamic slices of all variables be easilymaintained, but rather all dynamic slices of all variablesthroughout a programýs execution can be maintained. ourexperiments show that our robdd based algorithm for forwardcomputation of dynamic slices can maintain 107-217million dynamic slices arising during long program runs usingonly 28-392 megabytes of storage. in addition, the performanceof the robdd based forward computation methodcompares favorably with the performance of the lp backwardcomputation algorithm.
babel: representing business rules in xml for application integration. in this paper, we discuss babel, a prototype tool for integrating multiple heterogeneous applications, by wrapping them and by specifying the logic of their interoperation in xml.
a new approach for software testability analysis. software testability analysis has been an important research direction since 1990s and becomes more pervasive when entering 21st century. in this paper, we summarize problems in existing research work. we propose to use beta distribution to indicate software testability. when incorporating testing effectiveness information, we theoretically prove that the distribution can express testing effort and test value at the same time. we conduct experiment and validate our results on siemens programs. future work concentrate on deducing a prior estimation of the distribution for given software and testing criterion pair from program slicing and semantic analysis.
sniafl: towards a static non-interactive approach to feature location. to facilitate software maintenance and evolution, a helpfulstep is to locate features concerned in a particular maintenancetask. in the literature, both dynamic and interactive approacheshave been proposed for feature location. in this paper, wepresent a static and non-interactive method for achieving thisobjective. the main idea of our approach is to use theinformation retrieval (ir) technology to reveal the basicconnections between features and computational units in sourcecode. due to the characteristics of the retrieved connections, weuse a static representation of the source code named brcg tofurther recover both the relevant and the specific computationalunits for each feature. furthermore, we recover therelationships among the relevant units for each feature. apremise of our approach is that programmers should usemeaningful names as identifiers. we perform an experimentalstudy based on a gnu system to evaluate our approach. in theexperimental study, we present the detailed quantitativeexperimental data and give the qualitative analytical results.
applying regression test selection for cots-based applications. abb incorporates a variety of commercial-off-the-shelf (cots) components in its products. when new releases of these components are made available for integration and testing, source code is often not provided. various regression test selection processes have been developed and have been shown to be cost effectiveness. however, the majority of these test selection techniques rely on access to source code for change identification. in this paper we present the application of the lightweight integrated - black-box approach for component change identification (i-bacci) version 3 process that select regression tests for applications that use cots components. two case studies, examining a total of nine new component releases, were conducted at abb on products written in c/c++ to determine the effectiveness of i-bacci. the results of the case studies indicate this process can reduce the required number of regression tests at least 70% without sacrificing the regression fault exposure.
an experimental comparison of four test suite reduction techniques. as a test suite usually contains redundancy, a subset of the test suite (representative set) may still satisfy all the test objectives. as the redundancy increases the cost of executing the test suite, many test suite reduction techniques have been brought out in spite of the np-completeness of the general problem of finding the optimal representative set of the test suite. in the literature, some experimental studies of test suite reduction techniques have already been reported, but there are still shortcomings of the studies of these techniques. this paper presents an experimental comparison of the four typical test suite reduction techniques: heuristic h, heuristic gre, genetic algorithm-based approach and ilp-based approach. the aim of the study is to provide a guideline for choosing the appropriate test suite reduction techniques.
revisiting statechart synthesis with an algebraic approach. the idea of synthesizing statecharts out of a collection of scenarios has received a lot of attention in recent years. however due to the poor expressive power offirst generation scenario languages, including uml1.xsequence diagrams, the proposed solutions often use adhoc tricks and suffer from many shortcomings. the recent adoption in uml2.0 of a richer scenario language, including interesting composition operators, now makesit possible to revisit the problem of statechart synthesis with a radically new approach. inspired by the way uml2.0 sequence diagrams can be algebraically composed, we first define an algebraic framework for composing state charts. then we show how to leverage thealgebraic structure of uml2.0 sequence diagrams toget a direct algorithm for synthesizing a compositionof state charts out of them. the synthesized statechartsexhibit interesting properties that make them particularly useful as a basis for the detailed design process. beyond offering a systematic and semanticallywell founded method, another interest of our approachlies in its flexibility: the modification or replacement ofa given scenario has a limited impact on the synthesisprocess, thus fostering a better traceability between therequirements and the detailed design.
investigating the readability of state-based formal requirements specification languages. the readability of formal requirements specification languages is hypothesized as a limiting factor in the acceptance of formal methods by the industrial community. an empirical study was conducted to determine how various factors of state-based requirements specification language design affect readability using aerospace applications. six factors were tested in all, including the representation of the overall state machine structure, the expression of triggering conditions, the use of macros, the use of internal broadcast events, the use of hierarchies, and transition perspective (going-to or coming-from). subjects included computer scientists as well as aerospace engineers in an effort to determine whether background affects notational preferences. because so little previous experimentation on this topic exists on which to build hypotheses, the study was designed as a preliminary exploration of what factors are most important with respect to readability. it can serve as a starting point for more thorough and carefully controlled experimentation in specification language readability.
taking lessons from history. mining of software repositories has become an active research area. however, most past research considered any change to software as beneficial. this thesis will show how we can benefit from a classification into good and bad changes. the knowledge of bad changes will improve defect prediction and localization. furthermore, we will describe how to learn project-specific error patterns that will help reducing future errors.
mining version histories to guide software changes. we apply data mining to version histories in order toguide programmers along related changes: "programmerswho changed these functions also changed. . . ". given aset of existing changes, such rules (a) suggest and predictlikely further changes, (b) show up item coupling that is indetectableby program analysis, and (c) prevent errors dueto incomplete changes. after an initial change, our roseprototype can correctly predict 26% of further files to bechanged ¿ and 15% of the precise functions or variables.the topmost three suggestions contain a correct locationwith a likelihood of 64%.
an insider's survey on software development. this paper presents an overview of the results from &ldquo;an insider's survey on software development&rdquo;. the purpose of the survey was: to provide a vehicle for the communication of information on the usefulness and effectiveness of methodologies, tools, control mechanisms, metrics, and data collection used by bell telephone laboratories software developers; to evaluate the severity of certain obstacles to project development; and to ascertain feelings on the value of specific software quality issues. the results of the survey emphasize the need for work in the requirements area; the lack of attention given to the importance of maintenance within the software life cycle; and the need for more tools and methodologies, automated data collection, and effective software metrics.
a framework for automatic generation of evolvable e-commerce workplaces using business processes. business processes encapsulate the knowledge of operations and services provided by organizations. due to the changing nature of business processes, the design and implementation of e-commerce applications, such as workplace applications, could not be evolved consistently to support changing business requirements. e-commerce workplaces suffer from design and usability problems and may not conform to updated and constantly changing business processes. in this research demonstration, we present a framework that automatically generates business workplaces using workflow specifications. the generated workplaces can easily adapt to the changing business needs and reflect better the interaction within complex business processes in organizations.
research abstract: semantic concepts for the specification of non-functional properties of component-based software. in my research i try to de.ne a framework which can beused to provide semantics for non-functional specificationsof component-based systems. some of the key questionsdriving my work are:what is the fundamental difference between functionaland non-functional specifications? what formal apparatusis required to provide for this difference?what effects need to be taken into consideration whencomposing components with non-functional properties?what is the dependency between functional and nonfunctionalspecifications?what evaluation or analysis algorithms will be appliedto a non-functional specification? what informationmust be extractable from the semantics of a nonfunctionalspecification?
from use cases to code - rigorous software development with uml. the rational unified process lacks technical guidance for the development of object oriented applications. this tutorial fills this gap. we first use uml scenario diagrams to analyze use-cases. next, we show a method to analyze scenarios and to derive uml class diagrams and uml behavior modeling for active classes and methods. we show how to choose and embed design patterns in a design and how to employ different architectural styles. from such a precise design, smart case tools generate fully functional implementations. we explain state-of-the-art code generation concepts for uml and assess current case tools for their code generation capabilities and for their support through all software development phases more generally.
story driven modeling: a practical guide to model driven software development. the rational unified process lacks practical guidance for the development of object oriented applications. model driven software development (mdd) proposes to do most of these development steps at the model level of abstraction. this tutorial takes the mdd idea and examplifies such a development process. the tutorial guides the user from textual requirements descriptions through uml scenario modeling to the derivation of test case specifications, class diagrams and uml behavior models and finally to the implementation of the desired system. the tutorial employs a running example that allows to illustrate the modeling activities for each development phase and the guidelines for each modeling step. we discuss how existing case tools may be used in such an approach and how the fujaba environment supports our development process.
helping the automated validation process of user interfaces systems. this paper describes the prototype of a software environment that was devised for helping the formal validation of user interfaces systems. the paper suggests an approach to include such formal operations in the design process. an abstract and formal representation of the user interface system is produced to perform formal verifications on it. the paper explains why the user interface system can be modelled properly by a dataflow system and how this model can be expressed by using equations of flows in the language lustre. it describes then some main tools of the environment
crisp--a fault localization tool for java programs. crisp is an eclipse plug-in tool for constructing intermediate versions of a java program that is being edited. after a long editing session, a programmer will run regression tests to make sure she has not invalidated previously tested functionality. if a test fails unexpectedly, crisp allows the programmer to select parts of the edit that affected the failing test and to add them to the original program, creating an intermediate version guaranteed to compile. then the programmer can re-execute the test in order to locate the exact reasons for the failure by concentrating on those affecting changes that were applied. using crisp, a programmer can iteratively select, apply, and undo individual (or sets of) affecting changes and, thus effectively find a small set of failure-inducing changes. crisp is an extension to our change impact analysis tool, chianti, [6].
a sound assertion semantics for the dependable systems evolution verifying compiler. the verifying compiler (vc) project is a core component of the dependable systems evolution grand challenge. the vc offers the promise of automatically proving that a program or component is correct, where correctness is defined by program assertions. while several vc prototypes exist, all adopt a semantics for assertions that is unsound. this paper presents a consolidation of vc requirements analysis activities that, in particular, brought us to ask targeted vc customers what kind of semantics they wanted. taking into account both practitioners' needs and current technological factors, we offer recovery of soundness through an adjusted definition of assertion validity that matches user expectations and can be implemented practically using current prover technology. we describe how support for the new semantics has been added to esc/java2. preliminary results demonstrate the effectiveness of the new semantics at uncovering previously indiscernible specification errors.
spotlight: a prototype tool for software plans. software evolution is made difficult by the need to integrate new features with all previously implemented features in the system. we present spotlight, a prototype editor for software plans that seeks to address this problem by providing the programmer a principled way to separately develop and incrementally integrate independent features.
parallel randomized state-space search. model checkers search the space of possible program behaviors to detect errors and to demonstrate their absence. despite major advances in reduction and optimization techniques, state-space search can still become cost-prohibitive as program size and complexity increase. in this paper, we present a technique for dramatically improving the cost-effectiveness of state-space search techniques for error detection using parallelism. our approach can be composed with all of the reduction and optimization techniques we are aware of to amplify their benefits. it was developed based on insights gained from performing a large empirical study of the cost-effectiveness of randomization techniques in state-space analysis. we explain those insights and our technique, and then show through a focused empirical study that our technique speeds up analysis by factors ranging from 2 to over 1000 as compared to traditional modes of state-space search, and does so with relatively small numbers of parallel processors.
compatibility and regression testing of cots-component-based software. software engineers frequently update cots components integrated in component-based systems, and can often chose among many candidates produced by different vendors. this paper tackles both the problem of quickly identifying components that are syntactically compatible with the interface specifications, but badly integrate in target systems, and the problem of automatically generating regression test suites. the technique proposed in this paper to automatically generate compatibility and prioritized test suites is based on behavioral models that represent component interactions, and are automatically generated while executing the original test suites on previous versions of target systems.
bug hunt: making early software testing lessons engaging and affordable. software testing efforts account for a large part of software development costs. however, as educators, we struggle to properly prepare students to perform software testing activities. this struggle is caused by multiple factors: 1) it is challenging to effectively incorporate software testing into an already over-packed curriculum, 2) ad-hoc efforts to teach testing generally happen too late in the students' career, after bad habits have already been developed, and 3) these efforts lack the necessary institutional consistency and support to be effective. to address these challenges we created bug hunt, a web-based tutorial to engage students in learning software testing strategies. in this paper we describe the most interesting aspects of the tutorial including the lessons and feedback mechanisms, and the facilities for instructors to configure the tutorial and obtain automatic student assessment. we also present the lessons learned after two years of deployment.
refactoring for parameterizing java classes. type safety and expressiveness of many existing java libraries and their client applications would improve, if the libraries were upgraded to define generic classes. ef- ficient and accurate tools exist to assist client applications to use generic libraries, but so far the libraries themselves must be parameterized manually, which is a tedious, time-consuming, and error-prone task. we present a type-constraint- based algorithm for converting non-generic libraries to add type parameters. the algorithm handles the full java language and preserves backward compatibility, thus making it safe for existing clients. among other features, it is capable of inferring wildcard types and introducing type parameters for mutually-dependent classes. we have implemented the algorithm as a fully automatic refactoring in eclipse. we evaluated our work in two ways. first, our tool parameterized code that was lacking type parameters. we contacted the developers of several of these applications, and in all cases they confirmed that the resulting parameterizations were correct and useful. second, to better quantify its effectiveness, our tool parameterized classes from already-generic libraries, and we compared the results to those that were created by the libraries' authors. our tool performed the refactoring accurately.in 87% of cases the results were as good as those created manually by a human expert, in 9% of cases the tool results were better, and in 4% of cases the tool results were worse.
korat: a tool for generating structurally complex test inputs. this paper describes the korat tool for constraint-based generation of structurally complex test inputs for java programs. korat takes (1) an imperative predicate that speci fies the desired structural integrity constraints and (2) a finitization that bounds the desired test input size. korat generates all inputs (within the bounds) for which the predicate returns true. to do so, korat performs a systematic search of the predicate's input space. the inputs that korat generates enable bounded-exhaustive testing for programs ranging from library classes to stand-alone applications.
randomized differential testing as a prelude to formal verification. most flight software testing at the jet propulsion laboratory relies on the use of hand-produced test scenarios and is executed on systems as similar as possible to actual mission hardware. we report on a flight software development effort incorporating large-scale (biased) randomized testing on commodity desktop hardware. the results show that use of a reference implementation, hardware simulation with fault injection, a testable design, and test minimization enabled a high degree of automation in fault detection and correction. our experience will be of particular interest to developers working in domains where on-time delivery of software is critical (a strong argument for randomized automated testing) but not at the expense of correctness and reliability (a strong argument for model checking, theorem proving, and other heavyweight techniques). the effort spent in randomized testing can prepare the way for generating more complete confidence using heavyweight techniques.
adaptive online program analysis. analyzing a program run can provide important insights about its correctness. dynamic analysis of complex correctness properties, however, usually results in significant run-time overhead and, consequently, it is rarely used in practice. in this paper, we present an approach for exploiting properties of stateful program specifications to reduce the cost of their dynamic analysis. with our approach, analysis results are guaranteed to be identical to those of a traditional expensive dynamic analyses, while analysis cost is very low -- between 23% and 33% more than the un-instrumented program for the analyses we studied. we describe the principles behind our adaptive online program analysis technique, extensions to our java run-time analysis framework that support such analyses, and report on the performance and capabilities of two different families of adaptive online program analyses.