waashk/acm huggingface dataset:
observ - a prototyping language and environment  the observ methodology for software development is based on rapid construction of an executable specification, or prototype, of a systems, which may be examined and modified repeatedly to achieve the desired functionality. the objectives of observ also include facilitating a smooth transition to a target system, and providing means for reusing specification, design, and code of systems and subsystems. we are particularly interested in handling embedded systems, which are likely to have concurrency and have some real-time requirements.  the observ prototyping language combines several paradigms to express the behavior of a system. the object-oriented approach provides the basic mechanism for building a system from a collection of objects, with well- defined interfaces between them. we use finite-state machines to model the behavior of individual objects. at a lower level, activities that occur within objects, either upon entry to a state or in transition between thus allowing a nonprocedural description.  the environment provided to a prototype builder is as important as the language. we have made an attempt to provide flexible tools for executing or simulating the prototype being built, as well as for browsing and static checking. the first implementation of the tools was window based but not graphic. a graphic front end, name cruise, was developed afterwards.  a simulation sequence focuses on a single object, which can be as complex as necessary, possibly the entire system, and expects all the interactions between it and the outside world to be achieved by communication between the simulator and the user. the simulator allows the user to easily switch back and forth from one object to another, simulating each object in isolation.  to enable testing the behavior of a prototype in a realistic environment, it is possible to construct objects that imitate the environment objects. we also allow simulation of systems with missing pieces, by calling upon the user to simulate any such missing piece by himself.  shmuel tyszberowicz amiram yehudai
kava - a powerful and portable reflective java (poster session)  _kava_ is a powerful and portable reflective java that uses byte code rewriting to implement behavioural reflection. in our poster we briefly overview the _kava_ system, give an example of its use, and contrast it with simple byte code rewriting. more details about kava are available from _http://www.cs.ncl .ac.uk /research/dependability/reflection_.  ian s. welch robert j. stroud
an example of a software process model based on unit workload network  we are developing a software engineering and management database called kyotodb based on an object-base-data model. it has two types of objects. the first represents engineering data such as specifications, programs, etc., and encapsulates operations on these data. the second represents management data and encapsulates operations on the management data. each instance of the second type object, representing each individual unit workload, includes process programs and operations on management data (schedule, cost, quality, etc.) for that unit workload.  the process program in unitwokload class invokes tools (editors, compilers, debuggers, etc.), and pass engineering data (files) or management data to those tools. the process programs also specify procedures to maintain semantic consistency between many engineering data, as well as between many human interactions.  figure 1 shows an example hierarchical structure in kyotodb. figure 2 is an example of process program in class unit workload.  yoshihiro matsumoto tsuneo ajisaka
a safe, efficient regression test selection technique  regression testing is an expensive but necessary maintenance activity performed on modified software to provide confidence that changes are correct and do not adversely affect other portions of the softwore. a regression test selection technique choses, from an existing test set, thests that are deemed necessary to validate modified software. we present a new technique for regression test selection. our algorithms construct control flow graphs for a precedure or program and its modified version and use these graphs to select tests that execute changed code from the original test suite. we prove that, under certain conditions, the set of tests our technique selects includes every test from the original test suite that con expose faults in the modified procedfdure or program. under these conditions our algorithms are safe. moreover, although our algorithms may select some tests that cannot expose faults, they are at lease as precise as other safe regression test selection algorithms. unlike many other regression test selection algorithms, our algorithms handle all language constructs and all types of program modifications. we have implemented our algorithms; initial empirical studies indicate that our technique can significantly reduce the cost of regression testing modified software.  gregg rothermel mary jean harrold
automated support for seamless interoperability in polylingual software systems interoperability is a fundamental concern in many areas of software engineering, such as software reuse or infrastructures for software development environments. of particular interest to software engineers are the interoperability problems arising in _polylingual_ software systems. the defining characteristic of polylingual systems is their focus on uniform interaction among a set of components written in two or more different languages.existing approaches to support for interoperability are inadequate because they lack _seamlessness:_ that is, they generally force software developers to compensate explicitly for the existence of multiple languages or the crossing of language boundaries. in this paper we first discuss some foundations for polylingual interoperability, then review and assess existing approaches. we then outline polyspin, an approach in which interoperability can be made transparent and existing systems can be made to interoperate with no visible modifications. we also describe polyspinner, our prototype implementation of a toolset providing automated support for polyspin. we illustrate the advantages of our approach by applying it to an example problem and comparing polyspin's ease of use with that of an alternative, corba-style approach. daniel j. barrett alan kaplan jack c. wileden
creating abstract superclasses by refactoring  this paper focuses on object-oriented programming and one kind of structure- improving transformation (refactoring) that is unique to object-oriented programming: finding abstract superclasses. we decompose the operation of finding an abstract superclass into a set of refactoring steps, and provide examples. we discuss techniques that can automate or automatically support these steps. we also consider some of the conditions that must be satisfied to perform a refactoring safely; sometimes to satisfy these conditions other refactorings must first be applied.  william f. opdyke ralph e. johnson
a study of the applicability of existing exception-handling techniques to component-based real-time software technology  this study focuses on the current state of error-handling technology and concludes with recommendations for further research in error handling for component-based real-time software. with real-time programs growing in size and complexity, the quality and cost of developing and maintaining them are still deep concerns to embedded software industries. component-based software is a promising approach in reducing development cost while increasing quality and reliability. as with any other real-time software, component-based software needs exception detection and handling mechanisms to satisfy reliability requirements. the current lack of suitable error-handling techniques can make an application composed of reusable software nondeterministic and difficult to understand in the presence of errors.  jun lang david b. stewart
an implementation of standard ml modules  standard ml includes a set of module constructs that support programming in the large. these constructs extend ml's basic polymorphic type system by introducing the dependent types of martin lof's intuitionistic type theory. this paper discusses the problems involved in implementing standard ml's modules and describes a practical, efficient solution to these problems. the representations and algorithms of this implementation were inspired by a detailed formal semantics of standard ml developed by milner, tofte, and harper. the implementation is part of a new standard ml compiler that is written in standard ml using the module system.  david macqueen
cats: computer aided testing of software this paper describes the implementation of an automated test system for apl functions. it extends an implementation of assertive comments in apl to derive a notation for formal specification using pre and post conditions. these conditions are apl statements and so can be built into test functions. data supplied to provide examples is captured and subjected to mutations to test behaviour under edge conditions. the techniques make extensive use of modern apl ideas such as defined operators, phrasal forms and function assignment. maurice jordan
an empirical study of the reliability of unix utilities  the following section describes the tools we built to test the utilities. these tools include the fuzz (random character) generator, ptyjig (to test interactive utilities), and scripts to automate the testing process. next, we will describe the tests we performed, giving the types of input we presented to the utilities. results from the tests will follow along with an analysis of the results, including identification and classification of the program bugs that caused the crashes. the final section presents concluding remarks, including suggestions for avoiding the types of problems detected by our study and some commentary on the bugs we found. we include an appendix with the user manual pages for fuzz and ptyjig.  barton p. miller louis fredriksen bryan so
impulse-86: a substrate for object-oriented interface design  impulse-86 provides a general and extensible substrate upon which to construct a wide variety of interactive user interfaces for developing, maintaining, and using knowledge-based systems. the system is based on five major building blocks: editor, editor window, propertydisplay, menu, and operations. these building blocks are interconnected via a uniform framework and each has a well-defined set of responsibilities in an interface.  customized interfaces can be designed by declaratively replacing some of the building blocks in existing impulse-86 templates. customization may involve a wide range of activities, ranging from simple override of default values or methods that control primitive operations (e.g., font selection), to override of more central impulse-86 methods (e.g., template instantiation). most customized interfaces require some code to be written--- to handle domain- specific commands. however, in all cases, the impulse-86 substrate provides considerable leverage by taking care of the low-level details of screen, mouse, and keyboard manipulation.  impulse-86 is implemented in strobe, a language that provides object-oriented programming support for lisp. this simplifies customization and extension.  reid g. smith rich dinitz paul barth
interprocedural control flow analysis of first-order programs with tail-call optimization  knowledge of low-level control flow is essential for many compiler optimizations. in systems with tail-call optimization, the determination of interprocedural control flow is complicated by the fact that because of tail- call optimization, control flow at procedure returns is not readily evident from the call graph of the program. this article shows how interprocedural control-flow analysis of first-order programs can be carried out using well- known concepts from parsing theory. in particular, we show that context- insensitive ( or zeroth-order) control-flow analysis corresponds to the notion of follow sets in context-free grammars, while context-sensitive (or first- order) control-flow analysis corresponds to the notion of lr(1) items. the control-flow information so obtained can be used to improve the precision of interprocedural dataflow analyses as well as to extend certain low-level code optimizations across procedure boundaries.  saumya k. debray todd a. proebsting
solving two-state logic problems with boolean arrays: an approach unique to apl many great advances in science and mathematics were preceded by notational improvements. while a given algorithm can be implemented in any general purpose programming language, discovery of algorithms is heavily influenced by the notation used to investigate them. it is often conjectured that apl notation leads to unique solutions. in logic problems the values for variables are often limited to two states or options: yes/no, true/false, on/off, guilt/innocence, etc. this paper provides one example of how apl provides a unique solution to such problems. kenneth fordyce manuel alfonseca james brown gerald sullivan
object race detection we present an on-the-fly mechanism that detects access conflicts in executions of multi-threaded java programs. access conflicts are a conservative approximation of data races. the checker tracks access information at the level of objects (_object races_) rather than at the level of individual variables. this viewpoint allows the checker to exploit specific properties of object-oriented programs for optimization by restricting dynamic checks to those objects that are identified by escape analysis as potentially shared. the checker has been implemented in collaboration with an "ahead-of- time"java compiler. the combination fo static program analysis (escape- analysis) and inline instrumentation during code generation allows us to reduce the runtime overhead of detecting access conflicts. this overhead amounts to about 16-129% in time and less than 25% in space for typical benchmark applications and compares favorably to previously published on-the- fly mechanism that incurred an overhead of about a factor of 2-80 in time and up to a factor of 2 in space. christoph von praun thomas r. gross
anintroduction to ada  the most important features of ada are covered briefly in this paper. as with many aspects of programming languages, what is most important is subjective. therefore the subjects selected for this introduction are the result ofthe author's experience in studying the language. you may end up with a separate list after your study of the language.  ada is an attempt by the department of defense to introduce a single high- level language to the real-time computer world. a proliferation of programming languages are used in real-time computing. most of them are not taught in computer science departments. a high percentage of the application areas still use assembly language. for example, in the avionics area, assembly language is used more than 50% of the time and the dod approved language for this application, jovial, is not known by most programmers who develop avionic systems.  sabina h. saib
dcg: an efficient, retargetable dynamic code generation system  dynamic code generation allows aggressive optimization through the use of runtime information. previous systems typically relied on ad hoc code generators that were not designed for retargetability, and did not shield the client from machine-specific details. we present a system, dcg, that allows clients to specify dynamically generated code in a machine-independent manner. our one-pass code generator is easily retargeted and extremely efficient (code generation costs approximately 350 instructions per generated instruction). experiments show that dynamic code generation increases some application speeds by over an order of magnitude.  dawson r. engler todd a. proebsting
objects as closures: abstract semantics of object-oriented languages  we discuss denotational semantics of object-oriented languages, using the concept of closure widely used in (semi) functional programming to encapsulate side effects. it is shown that this denotational framework is adequate to explain classes, instantiation, and inheritance in the style of simula as well as smalltalk-80. this framework is then compared with that of kamin, in his recent denotational definition of smalltalk-80, and the implications of the differences between the two approaches are discussed.  uday reddy
criteria for software modularization  a central issue in programming practice involves determining the appropriate size and information content of a software module. this study attempted to determine the effectiveness of two widely used criteria for software modularization, strength and size, in reducing fault rate and development cost. data from 453 fortran modules developed by professional programmers were analyzed. the results indicated that module strength is a good criterion with respect to fault rate, whereas arbitrary module size limitations inhibit programmer productivity. this analysis is a first step toward defining empirically based standards for software modularization.  david n. card gerald t. page frank e. mcgarry
saustall - a new software environment  saustall (sequential algorithmic universal set-theoretical associative logical language) started as an attempt to define a new programming language. i have widened its scope to include the total software environment. it is hoped that saustall will be accepted as a general purpose language considerably better than conventional programming languages. further, saustall attempts to overcome the conventional division of software into compilers, editors, command language, etc. it may be thought presumptuous to place before the public something which is a long way from availability. the reason for doing it is in the hope of getting reactions from the software community which will improve saustall.  robert k. bell
namespaces semipermeable membranes for apl applications  namespaces are proposed as an extension to apl which can provide for large apl applications the same sort of structure and communications control provided in living structures by semipermeable membranes.  living systems are partitioned by a variety of semipermeable membranes. those membranes provide protection and isolation for subenvironments of the entity. they also control the flow of information and material between the subenvironments.  large applications designed for maintainability and extensibility are similar to living systems. they are hierarchically subdivided into simple subunits which are defined in terms of other subunits and which communicate with them in controlled ways.  apl and most other programming environments do not provide suitable means to enforce the isolation and communication control conventions that are appropriate for large applications. instead isolation depends on the good intentions and discipline of the implementers and the maintenance programmers.  ronald c. murray
elementary functions packages for ada  this paper incorporates some of the discussions by the acm/sigada working group on ada numerics, the iso/tc97/sc22/wg9 rapporteur group on an elementary functions package, and the ada-europe ada numerics working group. this is not a report from any one of those groups nor does it attempt to reflect all the discussions or potential resolutions of the issues. this paper is the author's attempt to provide information on the current thinking of these groups about a standard specification for an elementary functions package for ada so that a broader group can assess the utility and trade-offs involved in such standard specifications and libraries.  the following people have been involved in developing and influencing the ideas presented here: jim cody, paul cohen, sandy cohen, ken dritz, brian ford, graham hodgson, jan kok, gil myers, brian smith, jon squire, and bill whitaker. any confusion or inaccuracies are the author's. these people represent a combination of interests in the ada language ranging from numerical analysis to embedded application development.  the sigada numerics working group (sigada numwg) has met at the sigada meetings in pittsburgh, pa (july, 1986), charleston, wv (november, 1986), fort lauderdale, fl (january, 1987), and seattle, wa (august, 1987), several times at argonne national laboratory near chicago, il and at various locations in the washington, dc area. the numerics working group of ada-europe has met many times on this and related topics.  a number of proposals for elementary functions in ada ([firth 1982], [whitaker & eicholtz 1982], [witte 1983], [symm, wichmann, kok & winter 1984], [kok & symm 1984], and [kok 1987]) have been studied by the sigada numwg. these were considered along with recent work in numerical analysis about the calculation of the elementary functions and about the properties of floating point arithmetic. various aspects of ada's real arithmetic, type mechanism, generic packages, and library structures have also been considered as they relate to the specification and implementations of a potentially widely used package.  the proposed package specification is given at the very end of the paper as a convenient reference point.  robert f. mathis
cost-optimal code motion  we generalize knoop et al.'s lazy code motion (lcm) algorithm for partial redundancy elimination so that the generalized version also performs strength reduction. although knoop et al. have themselves extended lcm to strength reduction with their lazy strength reduction algorithm, our approach differs substantially from theirs and results in a broader class of candidate expressions, stronger safety guarantees, and the elimination of the potential for performance loss instead of gain. also, our general framework is not limited to traditional strength reduction, but rather can also handle a wide variety of optimizations in which data-flow information enables the replacement of a computation with a less expensive one. as a simple example, computations can be hoisted to points where they are constant foldable. another example we sketch is the hoisting of polymorphic operations to points where type analysis provides leverage for optimization. our general approach consists of placing computations so as to minimize their cost, rather than merely their number. so long as the cost differences between flowgraph nodes obey a certain natural constraint, a cost- optimal code motion transformation that does not unnecessarily prolong the lifetime of temporary varibles can be found using techniques completely analogous to lcm. specifically, the cost differences can be discovered using a wide variety of forward data-flow analyses in a manner which we describe.  max hailperin
the game of life with ada tasks the game of life is a popular programming project, both in computer science courses and on the world wide web. it is commonly implemented with a bounded array of values representing the cells of life. this project provides an appealing visual representation of cells living or dying over repeated generations.an ada implementation using tasks allows a number of interesting features. state information can be retained between calls. a generic declaration defines a conceptually unbounded grid, which a distributed implementation with tasks can potentially implement. tasking communication provides an exercise in both inter-cell communication and in deadlock prevention. lastly, the independence of cell communication can allow for relaxing the synchronization of cell generations. gertrude levine