waashk/acm huggingface dataset:
what happened to integrated environments? (panel session) 20 years ago, in 1979, a landmark community-wide process was launched to establish notional requirements for integrated software engineering environments. the resulting "stoneman" document was published in february 1980. bred of the software engineering research community and catalyzed by the government ada sponsor, this "integrated environment movement" branched out and was embraced widely in the software engineering community in the 1980's as a needed, achievable, centrist approach to accelerate the benefits of disciplined software engineering into mainstream practice. the case tool industry bloomed as products integrating lifecycle activities and artifacts emerged, and research evolved to environments integrated by support for emerging, maturing notions of software processes. yet, at the end of the 1990's, this movement appears to have virtually died, and more and more production software organizations are instead (or again) using old-fashioned stand-alone development tools and struggling to match up tools and their outputs and inputs to do software engineering. the purpose of this panel is to explore the reasons why the integrated environment movement has retreated, whether the recent tools and methods are or are not achieving the goals of integrated environments, whether those goals have been superceded by other goals better served without integrated environments, and what these examinations indicate about future requirements and research needs. hal hart barry boehm s. tucker taft tony wasserman
experimental comparison of software metrics (abstract only)  software complexity metrics attempt to objectively measure the difficulty involved in creating and maintaining a program. this experiment will compare five complexity metrics as measures for reading comprehension of programs. the metrics compared are halstead's effort, mccabe's cyclomatic, oviedo's program complexity, gilb's logical complexity, and data dependency tree count. the metrics will be applied to independent groups of four functionally equivalent pl/i programs. these results will be compared to the subjective ranking of a control group of competent programmers after agreement among the experts has been determined. these results will be compared using the friedman two-way analysis of variance by ranks and a multiple comparison procedure. the friedman two-way analysis of variance by ranks determines if a significant difference exists between metrics. once this has been established the multiple comparison procedure will be used to determine how the metrics differ.  beth clark
why ada is not just another programming language  since there have been hundreds of high level languages developed over the past twenty years, many people are asking why there is so much fuss about ada. the question is frequently asked---why isn't ada just another programming language.  although ada was developed to meet department of defense requirements, those requirements were really for embedded computer systems i.e. those in which the computer is integrated with additional hardware. such systems certainly exist in the nonmilitary environment e.g. process control, microwave ovens, and so ada is applicable to many cases which have no connection with the military.  in addition to being a programming language, ada provides support for software engineering concepts, as well as a programming support environment, and it is this combination which is unique. ada is unique non-technically for social, economic, and political reasons which relate to the way in which it was developed and the way in which it is being viewed by many people and organizations. ada is unique technically because of its support for the concept of software components, its excellent blend of modern useful features, and its support for the production of very large software systems.  jean e. sammet
logic enhancement: a method for extending logic programming languages  languages based on first order logic have rapidly gained popularity as practical programming languages in several fields. with experience, several problems with the most popular such language, prolog, have come to light. several proposals for changes and extensions to prolog have been made, but proposals have been expensive to build and evaluate. an inexpensive method for extension is described that relies on preprocessors and checkers written in prolog itself. the method is efficient and applies to any logic programming language that permits manipulation of programs as objects. several extensions have been built, including modules, macros, functional notation, repetition notation, debugging, and profiling; the first three are explored in detail.  paul r eggert d val schorre
analysis of steady-state segment storage utilizations in a log-structured file system with least-utilized segment cleaning the steady-state distribution of storage utilizations of segments in a log-structured file system with least- utilized (greedy) segment cleaning is found using analytic methods. furthermore, it is shown that as the number of segments increases, this distribution approaches a limiting continuous distribution, which is also derived. these results could be useful for preliminary performance analysis of lfs-type system designs prior to the development of detailed simulation models or actual implementation. john t. robinson
expressional loops  this paper proposes an expressional loop notation (xloop) based on the ideas described in [16,17] which makes it practical to express loops as compositions of functions. the primary benefit of xloop is that it brings the powerful metaphor of expressions and decomposability to bear on the domain of loops. wherever this metaphor can be applied, it makes algorithms much easier to construct, understand, and modify.  xloop applies the expressional metaphor to loops by introducing a new data type series. a series is an ordered one dimensional sequence of data objects. series are used to represent intermediate results during a computation. algorithms which would typically be rendered as iterative loops are instead represented as compositions of functions operating on series. for example, the program sum_vect computes the sum of the elements in a vector of integers by using enum_vector to create a series of the integers in the vector and then using sum to compute their sum.  richard c. waters
hope: an experimental applicative language  an applicative language called hope is described and discussed. the underlying goal of the design and implementation effort was to produce a very simple programming language which encourages the construction of clear and manipulable programs. hope does not include an assignment statement; this is felt to be an important simplification. the user may freely define his own data types, without the need to devise a complicated encoding in terms of low- level types. the language is very strongly typed, and as implemented it incorporates a typechecker which handles polymorphic types and overloaded operators. functions are defined by a set of recursion equations; the left- hand side of each equation includes a pattern used to determine which equation to use for a given argument. the availability of arbitrary higher-order types allows functions to be defined which 'package' recursion. lazily-evaluated lists are provided, allowing the use of infinite lists which could be used to provide interactive input/output and concurrency. hope also includes a simple modularisation facility which may be used to protect the implementation of an abstract data type.  r. m. burstall d. b. macqueen d. t. sannella
a bounded first-in, first-enabled solution to the _l_-exclusion problem  this article presents a solution to thefirst-come, first-enabled -exclusionproblem of fischer et al. [1979]. unlike their solution, thissolution does not use powerful read-modify-write synchronizationprimitives and requires only bounded shared memory. use of theconcurrent timestamp system of dolevand shavir [1989] is key in solving the problem within bounded sharedmemory.  yehuda afek danny dolev eli gafni michael merritt nir shavit
the design of an interactive compiler for optimizing microprograms  microprogramming has traditionally been done in assembly language because of the perceived need for fast execution; compiler technology does not yet exist for discovering and performing many of the clever tricks of an experienced microprogrammer. unfortunately, programming at the machine- instruction level is both tedious and error-prone. a possible compromise between these two approaches is that of an interactive compiler, where the programmer guides the crafting of critical data structures and sections of code, while the compiler ensures that the resulting code has the same semantics as the original program, generates code where speed is not critical, and performs bookkeeping tasks. we are in the process of implementing a prototype of such a system. this paper describes the system being developed and discusses some of the key design issues.  s. r. vegdahl
investigations of the software testing coupling effect  fault-based testing strategies test software by focusing on specific, common types of faults. the coupling effect hypothesizes that test data sets that detect simple types of faults are sensitive enough to detect more complex types of faults. this paper describes empirical investigations into the coupling effect over a specific class of software faults. all of the results from this investigation support the validity of the coupling effect. the major conclusion from this investigation is the fact that by explicitly testing for simple faults, we are also implicitly testing for more complicated faults, giving us confidence that fault-based testing is an effective way to test software.  a. jefferson offutt
verification of andf components  this paper presents validation work done on andf at the open software foundation research institute. the ultimate andf scenario splits a compiler into two separate components (producer/installer). this changes the compiler validation process as the two components have to be validated separately. this paper presents the originality and the difficulties of such an approach and summarizes the status of two pieces of software to which the osf-ri has contributed: the andf validation suite and the general andf interpreter.  frederic broustaut christian fabre francois de ferriere eric ivanov mauro fiorentini
long term file migration: development and evaluation of algorithms  the steady increase in the power and complexity of modern computer systems has encouraged the implementation of automatic file migration systems which move files dynamically between mass storage devices and disk in response to user reference patterns. using information describing 13 months of user disk data set file references, we develop and evaluate (replacement) algorithms for the selection of files to be moved from disk to mass storage. our approach is general and demonstrates a general methodology for this type of problem. we find that algorithms based on both the file size and the time since the file was last used work well. the best realizable algorithms tested condition on the empirical distribution of the times between file references. acceptable results are also obtained by selecting for replacement that file whose size times time to most recent reference is maximal. comparisons are made with a number of standard algorithms developed for paging, such as working set, vmin, and gopt. sufficient information (parameter values, fitted equations) is provided so that our algorithms may be easily implemented on other systems.  alan jay smith
memory allocation with lazy fits  dynamic memory allocation is an important part of modern programming languages. it is important that it be done fast without wasting too much memory. memory allocation using lazy fits is introduced, where pointer increments, which is very fast, is used as the primary allocation method and where conventional fits such as best fit or first fit are used as backup. some experimental results showing how lazy fits might perform are shown, and shows that the approach has the potential to be useful in actual systems.  yoo chung soo-mook moon
yesterday, my program worked. today, it does not. why?  imagine some program and a number of changes. if none of these changes is applied ("yesterday"), the program works. if all changes are applied ("today"), the program does not work. which change is responsible for the failure? we present an efficient algorithm that determines the minimal set of failure-inducing changes. our delta debugging prototype tracked down a single failure-inducing change from 178,000 changed gdb lines within a few hours.  andreas zeller
ada in concert in a concert, it is truly marvelous how a diverse group of musicians playing an assortment of musical instruments come together to produce beautiful music. a point that is frequently made by those familiar with the new ada standard, referred to here as ada(95), is how the features in ada(95) come together to enhance the software development process. this paper contains several examples that illustrate how the new features in ada(95) dramatically improve the correlation between the design of a solution and its eventual implementation at the source code level when compared to ada(83).the example, binary tree packaging, illustrates the design and implementation of recursive data structures. a data structure is recursive if the structure contains one or more substructures of the type being defined. as a result, recursive data structures lend themselves to processing with recursive algorithms. lists, binary trees, and n-ary trees are examples of data structures that may be defined recursively. the example presented here is a package that implements binary trees using a recursive paradigm. the paper compares an ada 83 solution with a solution using ada 95. the paper focuses on how ada 95 allows us to create a solution that more closely mirrors the specifications for the recursive data structure with improved time, space, and coding efficiency over an ada 83 implementation. in a sense, this paper provides one illustration of how the '95 standard improves ada. jack beidler
automated method-extraction refactoring by using block-based slicing  refactoring improves the design of existing code but is not complex to do by hand. this paper proposes a mechanism that automatically refactors methods of object-oriented programs by using program slicing. to restructure a method without changing its observable behavior, the mechanism uses block- based slicing that does not extract the fragments of code from the whole program but from the region consisting of some consecutive basic-blocks of the program. a refactoring tool implementing the mechanism constructs a new method that contains the extracted code and re-forms the source method that contains this tool, a programmer indicates only a variable of interest in the code that he/she wants to refactor and then selects a suitable method from among the candidates created by the tool. the programmer does not have to test the refactored code since the mechanism is based on data-and control-flow analysis. thus the tool enables programmers to avoid manual refactoring whose process is error-prone and time-consuming  katsuhisa maruyama
compiler-based i/o prefetching for out-of-core applications  current operating systems offer poor performance when a numeric application's working set does not fit in main memory. as a result, programmers who wish to solve "out-of-core" problems efficiently are typically faced with the onerous task of rewriting an application to use explicit i/o operations (e.g., read/write). in this paper, we propose and evaluate a fully automatic technique which liberates the programmer from this task, provides high performance, and requires only minimal changes to current operating systems. in our scheme the compiler provides the crucial information on future access patterns without burdening the programmer; the operating system supports nonbinding prefetch and release hints for managing i/o; and the operating systems cooperates with a run-time layer to accelerate performance by adapting to dynamic behavior and minimizing prefetch overhead. this approach maintains the abstraction of unlimited virtual memory for the programmer, gives the compiler the flexibility to aggressively insert prefetches ahead of references, and gives the operating system the flexibility to arbitrate between the competing resource demands of multiple applications. we implemented our compiler analysis within the suif compiler, and used it to target implementations of our run-time and os support on both research and commercial systems (hurricane and irix 6.5, respectively). our experimental results show large performance gains for out-of-core scientific applications on both systems: more than 50% of the i/o stall time has been eliminated in most cases, thus translating into overall speedups of roughly twofold in many cases.  angela demke brown todd c. mowry orran krieger
an abstract type for statistics collection in simula  although the use of abstract types has been widely advocated as a specification and implementation technique, their use has often been associated with programming languages that are not widely available, and examples published to date are rarely taken from actual applications. simula is a widely available language that supports the use of abstract types. the purposes of this paper are (1) to demonstrate the application of the concepts of data abstraction to a common problem; (2) to demonstrate the use of data abstraction in a widely available language; and (3) to provide a portable facility for statistics collection that may make the use of simula more attractive. a discussion of the background of and requirements for an abstract type for statistics collection is presented, followed by a specification for the type using traces. a simula implementation, with examples of its use, is given. finally, implementation of the abstract type in other languages is discussed.  carl e. landwehr
on distribution of coordinated atomic actions the concept of coordinated atomic (ca) actions was introduced about two years ago. since then this research has addressed many new problems and, in particular, problems of ca action distribution and implementation. recently we have gained some experience in implementing different schemes in ada 95 and java. our intention within this paper is to discuss how distributed ca action schemes can be realised. in particular, we outline different ways of action component distribution, trade-offs, applications for which these schemes are applicable. we discuss a wide range of schemes (some of them have not yet been implemented) based on a classification of various approaches to ca action distribution; to do this we analyse all possible ways of different action component distribution. we believe that this general discussion should help to better understand the current state of ca action implementation and is important for future research in ca actions. a. romanovsky a. f. zorzo
log files: an extended file service exploiting write-once storage  a log service provides efficient storage and retrieval of data that is written sequentially (append-only) and not subsequently modified. application programs and subsystems use log services for recovery, to record security audit trails, and for performance monitoring. ideally, a log service should accommodate very large, long-lived logs, and provide efficient retrieval and low space overhead.  in this paper, we describe the design and implementation of the clio log service. clio provides the abstraction of log files: readable, append-only files that are accessed in the same way as conventional files. the underlying storage medium is required only to be append-only; more general types of write access are not necessary. we show how log files can be implemented efficiently and robustly on top of such storage media---in particular, write-once optical disk.  in addition, we describe a general application software storage architecture that makes use of log files.  this work was supported in part by the defense advanced research projects agency under contracts n00039-84-c-0211 and n00039-86-k-0431, by national science foundation grant dcr-83-52048, and by digital equipment corporation, bell-northern research and at&amp;t; information systems.  r. finlayson d. cheriton
xil and yil: the intermediate languages of tobey  typically, the choice of intermediate representation by a particular compiler implementation seeks to address a specific goal. the intermediate language of the tobey compilers, xil, was initially chosen to facilitate the production of highly optimal scalar code, yet, it was easily extended to a higher level form yil in order to support a new suite of optimizations which in most existing compilers are done at the level of source to source translation. in this paper we will discuss those design features of xil that were important factors in the production of optimal scalar code. in addition we will demonstrate how the strength of the yil abstraction lay in its ability to access the underlying low level representation.  kevin o'brien kathryn m. o'brien martin hopkins arvin shepherd ron unrau
software engineering for user interfaces  the discipline of software engineering can be extended in a natural way to deal with the issues raised by a systematic approach to the design of human- machine interfaces. two main points are made: that the user should be treated as part of the system being designed, and that projects should be organized to take account of the current (small) state of a priori knowledge about how to design interfaces.  because the principles of good user-interface design are not yet well specified (and not yet known), interfaces should be developed through an iterative process. this means that it is essential to develop tools for evaluation and debugging of the interface, much the same way as tools have been developed for the evaluation and debugging of program code. we need to develop methods of detecting bugs in the interface and of diagnosing their cause. the tools for testing interfaces should include measures of interface performance, acceptance tests, and benchmarks. developing useful measures is a non-trivial task, but a start can and should be made.  stephen w. draper donald a. norman
completeness criteria for testing elementary program functions  program testing metrics are based on criteria for measuring the completeness of a set of program tests. branch testing measures the percentage of program branches that are traversed during a set of tests. mutation testing measures the ability of a set of tests to distinguish a program from similar programs. a criterion for test completeness is introduced in this paper which measures the ability of a set of tests to distinguish between functions which are implemented by parts of programs. the criterion is applied to functions which are implemented by different kinds of programming language statements. it is more effective than branch testing and incorporates some of the advantages of mutation testing. its effectiveness can be discussed formally and it can be described as part of an integrated approach to testing. a tool can be used to implement the method.  william e. howden