waashk/dblp huggingface dataset:
improving test suites for efficient fault localization. the need for testing-for-diagnosis strategies has been identified for a long time, but the explicit link from testing to diagnosis (fault localization) is rare. analyzing the type of information needed for efficient fault localization, we identify the attribute (called dynamic basic block) that restricts the accuracy of a diagnosis algorithm. based on this attribute, a test-for-diagnosis criterion is proposed and validated through rigorous case studies: it shows that a test suite can be improved to reach a high level of diagnosis accuracy. so, the dilemma between a reduced testing effort (with as few test cases as possible) and the diagnosis accuracy (that needs as much test cases as possible to get more information) is partly solved by selecting test cases that are dedicated to diagnosis.
programming as an evolutionary process. programming is studied as an evolutionary process (starting with the problem description and ending with some computer program), which is done in a sequence of transformation steps. nature of these steps at several levels is illustrated by typical examples. the aim is to arrive at a computer-surveyed, intuition-controlled programming support system (cips). some aspects of this project, which is under way at the technical university of munich informatics institute, are discussed.
from specifications to machine code: program construction through formal reasoning. due to modern technology, software will to an increasing extent be frozen into hardware. this is just one example for situations where bugs in the software are absolutely intolerable. therefore programming must soon become a safe process of program construction; that is, it has to be organized as a sequence of steps of rational reasoning. starting from an elaborate formal problem specification using elements of predicate logic, set theory and primitives from some algebras, the application of formal rules leads to algorithmic versions and finally to programs oriented towards the instruction repertoire of particular concrete machines. a genuine program construction process needs strict formalization throughout. all versions including the specifications can conveniently be represented by one programming language comprising the complete spectrum of descriptive, applicative and procedural styles. such a language includes the concept of nondeterminism, which makes the development process transparent and extremely flexible, and it is to be interpreted by some model of the underlying abstract data types. the use of formally proved transformation rules guarantees this correctness. in addition, the transformational approach is universal in the sense that the collection of rules can be adapted to the application in question: although initially envisaged and mainly used now for the construction of software for classical sequential stored-program machines, the approach can be extended to other computational models corresponding to the often cited innovative hardware architectures.
test plan generation using formal grammars. a test plan generation algorithm is proposed for systems such as process-control systems or transaction-processing systems. input to the algorithm is a description of the functional requirements for a given system. this is converted to an augmented finite state automaton (fsa) from which a regular grammar is derived. the grammar is used to generate test &ldquo;sentences&rdquo; each of which describes a sequence of stimuli to be applied to the system under test and responses required of the system under test.
using transformation systems for software maintenance and reengineering. software maintenance costs dominate software engineering costs, partly because most such engineering is done manually. program transformation tools leverage an engineer-provided base of &ldquo;transforms&rdquo; (a kind of generative reuse of programming knowledge), to automate analysis, modification, and generation of software, enhancing productivity and quality over conventional methods. this tutorial provides a complete overview of program transformation, from theory to implementation to application. several real transformation systems will be examined, with application examples including automated detection and removal of duplicate code from large systems, and the potential for semi-automated refactoring of large object frameworks. the tutorial progresses from introductory to intermediate, but all the necessary background will be provided, so attendees need only basic software engineering knowledge and motivating experience modifying software.
dms®: program transformations for practical scalable software evolution. while a number of research systems have demonstratedthe potential value of program transformations, very few ofthese systems have made it into practice. the core technologyfor such systems is well understood; what remains isintegration and more importantly, the problem of handlingthe scale of the applications to be processed.this paper describes dms, a practical, commercialprogram analysis and transformation system, and sketchesa variety of tasks to which it has been applied, from redocumentingto large-scale system migration. its successderives partly from a vision of design maintenance and theconstruction of infrastructure that appears necessary tosupport that vision. dms handles program scale by carefulspace management, computational scale via parallelismand knowledge acquisition scale via domains.
quantifying software designs. this paper describes an effort to use metrics to evaluate software designs early in the design process. key facets of the work include a machine processable design notation and the definition of software design metrics. we believe that the future success of building an intelligent software design assistant depends on the ability to quantify attributes of a software design, as well as to have the representation of the design available for automated examination.
program and interface slicing for reverse engineering. reverse engineering involves a great deal of effort in comprehension of the current implementation of a software system and the ways in which it differs from the original design. automated support tools are critical to the success of such efforts. it is shown how program slicing techniques can be employed to assist in the comprehension of large software systems, through traditional slicing techniques at the statement level, and through a new technique, interface slicing, at the module level
traits: tools and methodology. traits are an object-oriented programming language constructthat allow groups of methods to be named and reusedin arbitrary places in an inheritance hierarchy. classes canuse methods from traits as well as defining their own methodsand instance variables. traits thus enable a new styleof programming, in which traits rather than classes are theprimary unit of reuse. however, the additional sub-structureprovided by traits is always optional: a class written usingtraits can also be viewed as a flat collection of methods,with no change in its semantics.this paper describes the tool that supports these two alternateviews of a class, called the traits browser, and theprogramming methodology that we are starting to developaround the use of traits.
symbolic invariant verification for systems with dynamic structural adaptation. the next generation of networked mechatronic systems will be characterized by complex coordination and structural adaptation at run-time. crucial safety properties have to be guaranteed for all potential structural configurations. testing cannot provide safety guarantees, while current model checking and theorem proving techniques do not scale for such systems. we present a verification technique for arbitrarily large multi-agent systems from the mechatronic domain, featuring complex coordination and structural adaptation. we overcome the limitations of existing techniques by exploiting the local character of structural safety properties. the system state is modeled as a graph, system transitions are modeled as rule applications in a graph transformation system, and safety properties of the system are encoded as inductive invariants (permitting the verification of infinite state systems). we developed a symbolic verification procedure that allows us to perform the computation on an efficient bdd-based graph manipulation engine, and we report performance results for several examples.
a robust b-tree implementation. a storage structure for b-trees is presented which is robust in that any pair of changes to structural fields of an instance of the structure can be detected, as well as many sets of larger numbers of changes. included in the paper are a motivation for robustness as a design criterion, cost and performance implications of the b-tree implementation, and a solution to the subproblem of a robust implementation for each node's contiguous list of pointers and keys.
a case study on the automated verification of groupware protocols. we report on a fruitful combination of applying academic experience with formal modelling and verification techniques to an industrial case study. the goal of the case study was to investigate a priori, i.e. before implementation, the effects of adding a lightweight and easy-to-use publish/subscribe (event) notification service to thinkteam--an asynchronous and dispersed groupware system which was developed by think3. researchers from the formal methods and tools (fm&t) group of isti-cnr--with a longstanding experience in research on the development and application of formal methods, notations, and software tools for the specification, design, and verification of complex computer systems--therefore teamed up with think3--a global provider of integrated product development solutions that provides mechanical design and product data management (pdm) software catering the product management needs of design processes in the manufacturing industry. the technical details of this joint research effort have been documented elsewhere, here we report on the lessons learned from this experience.
oil and water? high performance garbage collection in java with mmtk. increasingly popular languages such as java and c# requireefficient garbage collection. this paper presents thedesign, implementation, and evaluation of mmtk, a memorymanagement toolkit for and in java. mmtk is an efficient, composable, extensible, and portable framework for building garbage collectors. mmtk uses design patternsand compiler cooperation to combine modularity and efficiency. the resulting system is more robust, easier to maintain, and has fewer defects than monolithic collectors. experimentalcomparisons with monolithic java and c implementationsreveal mmtk has significant performance advantagesas well. performance critical system software typicallyuses monolithic c at the expense of flexibility. our resultsrefute common wisdom that only this approach attainsefficiency, and suggest that performance critical softwarecan embrace modular design and high-level languages.
do students recognize ambiguity in software design? a multi-national, multi-institutional report. successful software engineering requires experience and acknowledgment of complexity, including that which leads designers to recognize ambiguity within the software design description itself. we report on a study of 21 post-secondary institutions from the usa, uk, sweden, and new zealand. first competency and graduating students as well as educators were asked to perform a software design task. we found that as students go from first competency to graduating seniors they tend to recognize ambiguities in under-specified problems. additionally, participants who recognized ambiguity addressed more requirements of the design.
central flow control software development: a case study of the effectiveness of software engineering techniques. the purpose of this paper is to present cost and error data collected during the development cycle of a large-scale software effort, to analyze this data in comparison with other available data from similar projects, and to evaluate the effectiveness of the techniques utilized on the project. the project being reported on is computer sciences corporation's development of the central flow control software system for the federal aviation administration's air traffic control system command center. analysis of the cost data provides insight not only into the added development costs associated with severely limiting module sizes, but also into the effectiveness of various cost estimation techniques. the error data analysis supports the usefulness of the software engineering techniques which were used on the project in conjunction with definitive module-level test requirements. the paper provides a foundation upon which to establish the development and data collection environment for future software systems.
observing timed systems by means of message sequence chart graphs. tools that feature msc do not have the ability to check model or implementation executions against the specified behavior.in this paper, we present a method for observing the behavior of timed systems specified using message sequence chart graphs (msc-graphs) (a simplified version of itu z.120 notation [5]).we believe that a log-analyzer and a run-time monitor based on msc-graphs are practical and powerful tools to improve the quality of real-time systems. on one hand, the log analyzer can play the role of an oracle while testing non-functional requirements. on the other hand, the run-time monitor can help in the verification of protocol assertions given in terms of message interchange annotated with time constraints.the work is built over a formal definition of the syntax and semantics of msc-graphs, which is similar to [1] (i.e. based on partial orders). those msc-graphs are enriched with timers and delay intervals in a similar way to [2] and [3].the work will mainly feature:&bull; an algorithm to check whether a time stamped log conforms a specification given by means of a msc-graph. the msc-graph does not need to be safe realizable [4] or bounded [1] to be treated by our algorithm. the proof of coorectness is given incrementally following a series of is given incrementally following a series of enhancements, starting from a basic algorithm.&bull; software architecture and an implementation for a log analyzer and a monitoring system.integration with existing tools supporting mscs (i.e.: teleogic tau [6], rational rose real tiem [7], rhapsody [8], distributed middlewares, etc.).coverage reporting over msc-graphs.
specifications: a key to effective software development. specifications provide the fundamental link to make the transition between the concept and definition phases of the system development cycle. straightforward, unambiguous specifications are required to ensure successful results and at the same time minimize cost overruns during the development cycle. many of the problems currently being addressed by software engineers have their origins in the frequently inconsistent and incomplete nature of system specifications. the u.s. army ballistic missile defense advanced technology center (bmdatc) is currently studying several advanced software development technologies. bmdatc's efforts are directed toward identifying and resolving the fundamental problems that plague the software community: excessive costs, unrealistic or inappropriate schedules, and inadequate performance. a primary category of the bmdatc program is data processing system engineering research. this research employs an advanced engineering approach to the generation, verification, and unambiguous communication of a complete and consistent set of system requirements. the key elements of this technology are: (1) a mathematically rigorous decomposition technology that effectively translates system requirements into a traceable graphic representation; (2) a usable system specification language (ssl) that supports simulation and specification generation; (3) a set of software tools that aid in the development, verification, and configuration control of the decomposed requirements; and (4) a management approach that supports the designed-in quality of the developed specification. definitive specifications are of primordial importance to the development process in that they are both the springboard for the design process and the yardstick of the test procedures. this paper describes the importance of verifying systems specifications before commencing any software design and delineates a technique for accomplishing this objective.
three paradigms for developing information systems. this paper examines three paradigms for information system development. development here is defined to include all activities associated with the implementation of an information system from initial requirements analysis through operational maintenance. that is, the full life cycle. two of the paradigms reflect common implementation environments. the third suggests an alternate approach.
software requirements: are they really a problem? do requirements arise naturally from an obvious need, or do they come about only through diligent effort&mdash;and even then contain problems? data on two very different types of software requirements were analyzed to determine what kinds of problems occur and whether these problems are important. the results are dramatic: software requirements are important, and their problems are surprisingly similar across projects. new software engineering techniques are clearly needed to improve both the development and statement of requirements.
on the use of formal methods in software development. we propose a total framework for the software development stages of specification (definition), design and coding. this framework is based on three cornerstones: (a) the concept of software development graphs which specify all the stages and steps of development; (b) the use of formal methods, in our case vdm, the vienna software development method, in all stages and steps of development; and (c) the clearly separate r&ocirc;les of theoretical computer scientists, programmers, software engineers, and development managers in all aspects of software development. thus not only programming is formalised (ie. programs considered formal objects), but also development, its engineering and management (ie. the entire programming itself is also considered a formal object about which to reason).
automatic input of flow chart in document image. the technology of document image processing has the possibility of automatic document input. by utilizing it, the flow chart in document image as the alternate expression of fortran source statements is automatically input into the computer. the paper reports the algorithm and the experimental results of field segmentation and classification in document image, the recognition of flow chart including control lines and blocks, and hand-written alpha-numerical characters in the blocks and the explanatory fields, the conversion of flow chart into program functions and the generation of fortran source statements. it showed the possibility that program functions such as initialization, input/output format and branch address were determined by the analysis of flow chart and explanatory description under the writing rule of it and also the restriction that the flow chart should have the good quality in order to recognize the flow and characters and be subject to the writing rule.
fargo: a system for mobile component-based application development. the design of efficient and reliable distributed applications that need to operate over various machines which are networked by wide area and/or low-bandwidth connections, demands new programming abstractions and mechanisms. in particular, the conventional static design-time determination of local-remote relationships between components implies that dynamic environmental changes are hard if not impossible to address without reengineering the application. the fargo system presents a novel programming model that is centered around the concept of "dynamic application layout", which permits the manipulation of component location at runtime, thereby enabling to map dynamically the logical components onto physical hosts. since the emphasis is on components that are part of a larger application (as opposed to "agents" that are often autonomous applications), component mobility preserves the validity of incoming and outgoing component references, in addition to the internal state of the component. thus, fargo inter-component references can dynamically stretch (i.e., become remote) and shrink (become local), unlike traditional references, which are fixed at design time to be either local or remote.
a view of 20th and 21st century software engineering. george santayana's statement, "those who cannot remember the past are condemned to repeat it," is only half true. the past also includes successful histories. if you haven't been made aware of them, you're often condemned not to repeat their successes.in a rapidly expanding field such as software engineering, this happens a lot. extensive studies of many software projects such as the standish reports offer convincing evidence that many projects fail to repeat past successes.this paper tries to identify at least some of the major past software experiences that were well worth repeating, and some that were not. it also tries to identify underlying phenomena influencing the evolution of software engineering practices that have at least helped the author appreciate how our field has gotten to where it has been and where it is.a counterpart santayana-like statement about the past and future might say, "in an era of rapid change, those who repeat the past are condemned to a bleak future." (think about the dinosaurs, and think carefully about software engineering maturity models that emphasize repeatability.)this paper also tries to identify some of the major sources of change that will affect software engineering practices in the next couple of decades, and identifies some strategies for assessing and adapting to these sources of change. it also makes some first steps towards distinguishing relatively timeless software engineering principles that are risky not to repeat, and conditions of change under which aging practices will become increasingly risky to repeat.
a paradigm for decentralized process modeling and its realization in the oz environment. we present a model for decentralized process centered environments (pces), which support concerted efforts among geographically-dispersed teams - each local team with its own autonomous process - and emphasize flexibility in the tradeoff between collaboration vs. autonomy. we consider both decentralized process modeling and decentralized process enaction. we describe a realization in the oz decentralized pce, which employs a rule-based formalism, and also investigate the application to pces based on petri-nets