waashk/dblp huggingface dataset:
perracotta: mining temporal api rules from imperfect traces. dynamic inference techniques have been demonstrated to provide useful support for various software engineering tasks including bug finding, test suite evaluation and improvement, and specification generation. to date, however, dynamic inference has only been used effectively on small programs under controlled conditions. in this paper, we identify reasons why scaling dynamic inference techniques has proven difficult, and introduce solutions that enable a dynamic inference technique to scale to large programs and work effectively with the imperfect traces typically available in industrial scenarios. we describe our approximate inference algorithm, present and evaluate heuristics for winnowing the large number of inferred properties to a manageable set of interesting properties, and report on experiments using inferred properties. we evaluate our techniques on jboss and the windows kernel. our tool is able to infer many of the properties checked by the static driver verifier and leads us to discover a previously unknown bug in windows.
development of software engineering: co-operative efforts from academia, government and industry. in the past 40 years, software engineering has emerged as an important sub-field of computer science. the quality and productivity of software have been improved and the cost and risk of software development been decreased due to the contributions made in this sub-field. the software engineering community needs to invest much more efforts to cope with the drastically increasing demands on the information technology as well as the extremely open and dynamic nature of the internet. the history of software engineering is reviewed with emphasis on the driving forces of software and the milestones of software engineering development. the history of software engineering in china is reviewed with emphasis on the relationship between software engineering and the software industry. based on the above reviews, we argue that software engineering should become an independent discipline along with computer science and co-operative efforts from academia, governments and industries should be needed for the harmonious development of software engineering. some results are presented based on china's experience of developing software engineering under this model.
software process description using lotos and its enaction. software processes can be treated as cooperative works among several engineers. in order to enact a software process in a distributed environment, the engineers must communicate with each other for exchanging data values and synchronization messages. such communications should be described in a process description for enacting the process automatically and clarifying the engineers' work. since these communications are numerous, it is troublesome for the process designers to describe them minutely in the process description. they also make the description unreadable. we propose a formal software process model where we describe only a whole description of a process in which we describe only the contents and temporal orders of primitive activities, and do not specify the communications. from the whole description, we derive each engineer's individual description, automatically where the contents and orders of his activities and communications to others are described. a whole process is enacted by executing all individual descriptions in parallel. both whole and individual descriptions are described in lotos/spd, an extension of the formal specification language lotos. we have also developed a support system for deriving the individual descriptions and executing them on unix machines
an approach to error-resistant software design. this paper presents a flexible framework, using a system monitor, to design error-resistant software. the system monitor contains the code and data for error detection, error containment and recovery at the module level, program level, and system level. it contains five types of components: the internal process supervisor, the external process supervisor, the interaction supervisor, the system monitor kernel, and the maintenance program. the functions of each component is discussed, followed by a discussion of the strategies to handle errors in the module, program, and system levels.
publishing and composition of atomicity-equivalent services for b2b collaboration. exception handling resolves inconsistency by backward or forward error recovery methods or both in business-to-business (b2b) process collaboration. to avoid committing irrevocable tasks followed by exceptions, b2b processes, which guarantee the atomicity sphere property, are attractive. while atomicity sphere ensures its outcomes to be either all or nothing, conflicting local recoveries may lead to global b2b inconsistencies. existing (global) analysis techniques however mandate every process unveiling all individual tasks. such an analysis is infeasible when some business parties refuse to disclose their process details for privacy or business reasons. to address this problem, we propose a process algebraic technique to prove, construct, and check atomicity-equivalent public views from b2b processes. by checking atomicity spheres in the composition of these public views, business parties can identify suitable services that respect their individual and overall atomicity requirements. an example based on a real-life multilateral supply chain process is included.
toward precise measurements using software normalization. there has been a lot of interest in defining appropriate ways of measuring the attributes of software. we think these measures should accurately represent those attributes which they quantify. however, these software measures are usually not precise enough because they measure elements that need not be included. reducing redundant structures of the program before they are measured is a simple yet important concept. we propose a strategy of software normalization for enhancing software measurement. most importantly, this program normalization allows those metrics to measure what is meant to be measured and avoid imprecise results.
two-way translators based on attribute grammar inversion. an attribute grammar is a non-procedural specification of a translation from one language to another. in this paper we consider restrictions on attribute grammars to make them invertible. given an attribute grammar defining a translation t: l1 &rarr; l2 obeying these restrictions, we show how to automatically synthesize the attribute grammar t-1: l2 &rarr; l1 describing the inverse translation; i.e., t &ogr; t-1 &ogr; t = t. this allows for the generation of bi-directional translators from a single description. we provide motivation and demonstrate the practical utility of these concepts by describing the inversion of an attribute grammar used as part of an interface for database users.
main effects screening: a distributed continuous quality assurance process for monitoring performance degradation in evolving software systems. developers of highly configurable performance-intensive software systems often use a type of in-house performance-oriented "regression testing" to ensure that their modifications have not adversely affected their software's performance across its large configuration space. unfortunately, time and resource constraints often limit developers to in-house testing of a small number of configurations and unreliable extrapolation from these results to the entire configuration space, which allows many performance bottlenecks and sources of qos degradation to escape detection until systems are fielded. to improve performance assessment of evolving systems across large configuration spaces, we have developed a distributed continuous quality assurance (dcqa) process called main effects screening that uses in-the-field resources to execute formally designed experiments to help reduce the configuration space, thereby allowing developers to perform more targeted in-house qa. we have evaluated this process via several feasibility studies on several large, widely-used performance-intensive software systems. our results indicate that main effects screening can detect key sources of performance degradation in large-scale systems with significantly less effort than conventional techniques.
java program analysis projects in osaka university: aspect-based slicing system adas and ranked-component search system spars-j. in our research demonstration, we show two development support systems for java programs. one is an aspect-oriented dynamic analysis and slice calculation system named adas, and another is a software product archiving, analyzing, and retrieving system for java named spars-j.
functional specification of synchronized processes based on modal logic. we present in this paper a pseudo functional language and a specification language both of which are designed to describe systems of synchronized processes with shared resources. the semantics of the pseudo functional language is defined by translating its statements to the set of formulas of intensional logic. the specification language contains formulas of the logic, hence its semantics can be treated by the model theory as usual. a proof method for the program written in the language is proposed. time dependent aspects of processes are described in terms of intensional logic. specification of parallel systems can be described in a well structured manner in our specification language, more precisely, they are described hierarchically according to the function decomposition of the system, and at each level of the hierarchy the configuration of processes and resources and time dependent properties are separately described. resources are defined as an abstract data type with synchronization specification. we give an example of specification and a proof of a program written in the parallel pseudo functional programming language.
open: a flexible oo/cbd process for software-intensive systems development, a uml exposition. object technology is an approach that is increasingly being adopted for the development of quality software and software-intensive systems. recent experience has demonstrated that it provides a sophisticated environment to support high quality software engineering practice. however, the use of object technology should not be restricted to languages but should encompass analysis, design, v&v and many such aspects belonging to the methodological dimension of the development life-cycle. furthermore, it should also cover other issues belonging to the technological and contextual aspects.
design principles behind chiron: a uims for software environments. user interface facilities are a crucial part of the infrastructure of a software environment. we discuss the particular demands and constraints on a user interface management system (uims) for a software environment, and the relation between the architecture of the environment and the uims. a model for designing user interface management systems for large, extensible environments is presented. this model synthesizes several recent advances in user interfaces and specializes them to the domain of software environments. the model can be applied to a wide variety of environment contexts. a prototype implementation is described.
an incremental flow- and context-sensitive pointer aliasing analysis. pointer aliasing analysis is used to determine if two object names containing dereferences and/or field selectors (e.g., *p,9->t) may refer to the same location during execution. such information is necessary for applications such as data-flow-based testers, program understanding tools, and debuggers, but is expensive to calculate with acceptable precision. incremental algorithms update data flow information after a program change rather than recomputing it from scratch, under the assumption that the change impact will be limited. two versions of a practical incremental pointer aliasing algorithm have been developed, based on landi-ryder flow- and context-sensitive alias analysis. empirical results attest to the time savings over exhaustive analysis (a six-fold speedup on average), and the precision of the approximate solution obtained (on average same solution as exhaustive algorithm for 75% of the tests.).
an analysis of the fault correction process in a large-scale sdl production model. improvements in the software development process depend on our ability to collect and analyze data drawn from various phases of the development life cycle. our design metrics research team was presented with a large-scale sdl production model plus the accompanying problem reports that began in the requirements phase of development. the goal of this research was to identify and measure the occurrences of faults and the efficiency of their removal by development phase in order to target software development process improvement strategies. the number and severity of problem reports were tracked by development phase and fault class. the efficiency of the fault removal process using a variety of detection methods was measured. through our analysis of the system data, the study confirms that catching faults in the phase of origin is an important goal. the faults that migrated to future phases are on average eight times more costly to repair. the study also confirms that upstream faults are the most critical faults and more importantly it identifies detailed design as the major contributor of faults, including critical faults.
on the success of empirical studies in the international conference on software engineering. critiques of the quantity and quality of empirical evaluations in software engineering have existed for quite some time. however such critiques are typically not empirically evaluated. this paper fills this gap by empirically analyzing papers published by icse, the prime research conference on software engineering. we present quantitative and qualitative results of a quasi-random experiment of empirical evaluations over the lifetime of the conference. our quantitative results show the quantity of empirical evaluation has increased over 29 icse proceedings but we still have room to improve the soundness of empirical evaluations in icse proceedings. our qualitative results point to specific areas of improvement in empirical evaluations.
executable requirements for embedded systems. an approach to requirements specification for embedded systems, based on constructing an executable model of the proposed system interacting with its environment, is proposed. the approach is explained, motivated, and related to data-oriented specification techniques. portions of a specification language embodying it are introduced, and illustrated with an extended example in which the requirements for a process-control system are developed incrementally.
using peer reviews in teaching framework development. framework development is one of the most challenging software development tasks. teaching framework development is even more challenging. in this paper, we propose a creative process to teach framework development. we propose using peer review in the process. we present the process and some examples and findings out of our experience.
perturbation testing for computation errors. the use of algebraic techniques in defining a neighborhood of functions is particularly suited to testing for computation errors. two possible approaches are howden's algebraic testing method and perturbation testing, which in this paper is generalized to permit analysis of individual test points rather than entire paths. these approaches are shown to be mathematically equivalent when applied to a program's black-box output. perturbation testing, however, offers more flexibility in the choice of potential errors to be investigated. a significant alternative offered by perturbation testing is the ability to work in the static domain, choosing test data to eliminate possible error terms in specific assignment and output statements.
interpretation in a tool-fragment environment. the philosophy of composition of new software tools from previously created tool fragments is a useful approach to facilitating the development of software systems. this paper examines the extension of this philosophy to the design of program interpreters, demonstrating how the separation of interpretation into a core algorithm, value kind definitions, and computation model allows the capture of conventional execution models, symbolic execution models, dynamic data flow tracking, and other useful forms of program interpretation. an interpretation system based upon this separation, called aries, is currently under development.
sufficient tset sets for path analysis testing strategies. many testing methods require the selection of a set of paths over which testing is to be conducted. this paper presents an analysis of the effectiveness of individual paths for testing predicates in linearly domained programs. a measure is derived for the marginal advantage of testing another path after several paths have already been tested. this measure is used to show that any predicate in such programs may be sufficiently tested using at most m+n+1 paths, where m is the number of input values and n is the number of program variables.
automatic program analysis and evaluation. there is currently considerable interest in the computing community in the evaluation of computer programming. however, in order to objectively evaluate such concepts, it is necessary to undertake a thorough evaluation of the programming process itself. most previous studies of this type have analyzed, by hand usually, a few instances of programs. this has led to some general conjectures; however, the amount of information that must be processed precludes any large scale analysis. in order to avoid this problem, an automatic data collection facility has been implemented as part of a pl/1 compiler at the university of maryland. this system automatically collects information on each program that has been compiled - at almost no additional cost to the user of the compiler. this paper will describe the system and will evaluate some of the characteristics of some of the 25,000 programs that have been run since july, 1975.
use of an environment classification model. various reference models have been proposed for the classification of features present in an integrated software engineering environment. two such models are studied and a target system is mapped to the set of services present in these models. this system consisted of approximately 23000 lines of pascal source code in 31 modules and provided tools for developing pascal programs using either a syntax-directed editor or a line-oriented editor. in addition to describing the system, this mapping exercise provided additional feedback on the effectiveness of the two reference models used. the results of this mapping and comments on the effectiveness of the models are given
understanding iv & v in a safety critical and complex evolutionary environment: the nasa space shuttle program. the national aeronautics and space administration is an internationally recognized leader in space science and exploration. nasa recognizes the inherent risk associated with space exploration; however, nasa makes every reasonable effort to minimize that risk. to that end for the space shuttle program nasa instituted a software independent verification and validation (iv&v) process in 1988 to ensure that the shuttle and its crew are not exposed to any unnecessary risks. using data provided by both the shuttle software developer and the iv&v contractor, in this paper we describe the overall iv&v process as used on the space shuttle program and provide an analysis of the use of metrics to document and control this process. our findings reaffirm the value of iv&v and show the impact iv&v has on multiple releases of a large complex software system.
model-based development of dynamically adaptive software. increasingly, software should dynamically adapt its behavior at run-time in response to changing conditions in the supporting computing and communication infrastructure, and in the surrounding physical environment. in order for an adaptive program to be trusted, it is important to have mechanisms to ensure that the program functions correctly during and after adaptations. adaptive programs are generally more difficult to specify, verify, and validate due to their high complexity. particularly, when involving multi-threaded adaptations, the program behavior is the result of the collaborative behavior of multiple threads and software components. this paper introduces an approach to create formal models for the behavior of adaptive programs. our approach separates the adaptation behavior and non-adaptive behavior specifications of adaptive programs, making the models easier to specify and more amenable to automated analysis and visual inspection. we introduce a process to construct adaptation models, automatically generate adaptive programs from the models, and verify and validate the models. we illustrate our approach through the development of an adaptive gsm-oriented audio streaming protocol for a mobile computing application.
locating faults through automated predicate switching. typically debugging begins when during a program execution a point is reached at which an obviously incorrect value is observed. a general and powerful approach to automated debugging can be based upon identifying modifications to the program state that will bring the execution to a successful conclusion. however, searching for arbitrary changes to the program state is difficult due to the extremely large search space. in this paper we demonstrate that by forcibly switching a predicate's outcome at runtime and altering the control flow, the program state can not only be inexpensively modified, but in addition it is often possible to bring the program execution to a successful completion (i.e., program produces the desired output). by examining the switched predicate, also called the critical predicate, the cause of the bug can then be identified. since the outcome of a branch can only be either true or false, the number of modified states resulting by predicate switching is far less than those possible through arbitrary state changes. thus, it is possible to automatically search through modified states to find one that leads to the correct output. we have developed an implementation based upon dynamic instrumentation to perform this search through program re-execution -- the program is executed from the beginning and a predicate's outcome is switched to produce the desired change in control flow. to evaluate our approach, we tried our technique on several reported bugs for a number of unix utility programs. our technique was found to be practical (i.e., acceptable in time taken) and effective (i.e., we were able to automatically identify critical predicates). moreover we show that bidirectional dynamic slices of critical predicates capture the faulty code.
precise dynamic slicing algorithms. dynamic slicing algorithms can greatly reduce the de bugging effort by focusing the attention of the user on a relevant subset of program statements. in this paper we present the design and evaluation of three precise dynamic slicing algorithms called the full preprocessing (fp), no preprocessing (np) and limited preprocessing (lp) algorithms. the algorithms differ in the relative timing of constructing the dynamic data dependence graph and its traversal for computing requested dynamic slices. our experiments show that the lp algorithm is a fast and practical precise slicing algorithm. in fact we show that while precise slices can be orders of magnitude smaller than imprecise dynamic slices, for small number of slicing requests, the lp algorithm is faster than an imprecise dynamic slicing algorithm proposed by agrawal and horgan.