waashk/acm huggingface dataset:
factors affecting readability  no one has found a way to really help writers create readable prose. robert gunning developed a method for calculating the 'fog index' and rudolph flesch worked out more than one formula for measuring the simplicity of writing. by one of flesch's formulas (the one without personal pronouns), ronald s. lemos in the february, 1985 issue of communications of the acm (cacm) was able to prove that cacm required two less years of school to read than datamation. statistics can prove anything. i have no idea what sophomore in high school could read the cacm cover to cover and even understand most of it.  flesch's book 'the art of plain talk' was given to me at a yourdon systems analysis course. the instructor handed it to each of us, saying something like "read this and you'll be a manager in no time" (supposedly, management is handed to the least efficient person who can also write well). the book is full of examples, mostly journalistic, showing how good writers evoke human interest. of course, these writers had human events, thoughts and feelings as their focal points, not software, i doubt whether any of the graduates of that week ever used flesch as a reference for grading their own documentation. how would bernard shaw have documented software? or mingus played it? this paper addresses these burning issues.  chris hallgren
comparing mark-and sweep and stop-and-copy garbage collection  stop- and-copy garbage collection has been preferred to mark-and-sweep collection in the last decade because its collection time is proportional to the size of reachable data and not to the memory size. this paper compares the cpu overhead and the memory requirements of the two collection algorithms extended with generations, and finds that mark-and-sweep collection requires at most a small amount of additional cpu overhead (3-6%) but, requires an average of 20% (and up to 40%) less memory to achieve the same page fault rate. the comparison is based on results obtained using trace-driven simulation with large common lisp programs.  benjamin zorn
software experience with concurrent c and lisp in a distributed system  this paper discusses a software system made possible by the current advances in distributed processing, high-speed computer networks, and concurrent language implementation. the system discussed herein consists of several software layers. at the core of the system lies the unix operating system. this particular operating system provides an extensible set of communication domains which support communication within one unix system as well as within several computers inside a local area network. concurrent c‡, a concurrent programming language, provides the capability for dynamically creating processes within a set of interconnected computers. the user interface to the system consists of a lisp interpreter written in concurrent c. the resulting system uses a data- driven mechanism such that processes can start executing once their respective input data becomes available. the system has been used for testing tasks for the real-time robotics vision and for the simulation of large vlsi designs.  roberto salama wentai liu ronald s. gyurcsik
transitioning legacy assets to a product line architecture  a successful software system evolves over time, but this evolution often occurs in an ad-hoc fashion. one approach to structure system evolution is the concept of software product lines where a core architecture supports a variety of application contexts. however, in practice, the high cost and high risks of redevelopment as well as the substantial investments made to develop the existing systems most often mandate significant leverage of the legacy assets. yet, there is little guidance in the literature on how to transition legacy assets into a product line set-up.  in this paper, we present re-place, an approach developed to support the transition of existing software assets towards a product line architecture while taking into account anticipated new system variants. we illustrate this approach with its application in an industrial setting.  joachim bayer jean-françois girard martin wurthner jean-marc debaud martin apel
a mechanism for environment integration  this paper describes research associated with the development and evaluation of odin-an environment integration system based on the idea that tools should be integrated around a centralized store of persistent software objects. the paper describes this idea in detail and then presents the odin architecture, which features such notions as the typing of software objects, composing tools out of modular tool fragments, optimizing the storage and rederivation of software objects, and isolating tool interconnectivity information in a single centralized object. the paper then describes some projects that have used odin to integrate tools on a large scale. finally, it discusses the significance of this work and the conclusions that can be drawn about superior software environment architectures.  geoffrey clemm leon osterweil
visual aid for fortran program debugging  this paper presents a new type of debugging tool for fortran programs. we call this the "dock" system, referring to the dock where ships stay during repairs. dock provides new debugging functions such as slow display of program execution. major functions and a brief indication of the methods of implementation are given in this paper.  four "execution modes" control execution speed. execution is displayed on the screen in full screen mode. the source program listing is displayed with the executing statement shown in a different color or brightness. at certain places, the program stops temporarily in a status called "stationary mode". in the stationary mode, several debugging functions are available.  k. takahashi t. aso m. kobayashi
self: the power of simplicity  self is a new object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior. prototypes combine inheritance and instantiation to provide a framework that is simpler and more flexible than most object-oriented languages. slots unite variables and procedures into a single construct. this permits the inheritance hierarchy to take over the function of lexical scoping in conventional languages. finally, because self does not distinguish state from behavior, it narrows the gaps between ordinary objects, procedures, and closures. self's simplicity and expressiveness offer new insights into object-oriented computation.  david ungar randall b. smith
1983 invited address solved problems, unsolved problems and non-problems in concurrency  this is an edited transcript of a talk given at last year's conference. to preserve the flavor of the talk and the questions, i have done very little editing---mostly eliminating superfluous words and phrases, correcting especially atrocious grammar, and making the obvious changes needed when replacing slides by figures. the tape recorder was not functioning for the first few minutes, so i had to recreate the beginning of the talk.  leslie lamport
efficient implementation of adaptive software  adaptive programs compute with objects, just like object-oriented programs. each task to be accomplished is specified by a so-called propagation pattern which traverses the receiver object. the object traversal is a recursive descent via the instance variables where information is collected or propagated along the way. a propagation pattern consists of (1) a name for the task, (2) a succinct specification of the parts of the receiver object that should be traversed, and (3) code fragments to be executed when specific object types are encountered. the propagation patterns need to be complemented by a class graph which defines the detailed object structure. the separation of structure and behavior yields a degree of flexibility and understandability not present in traditional object-oriented languages. for example, the class graph can be changed without changing the adaptive program at all. we present an efficient implementation of adaptive programs. given an adaptive program and a class graph, we generate an efficient object-oriented program, for example, in c++. moreover, we prove the correctness of the core of this translation. a key assumption in the theorem is that the traversal specifications are consistent with the class graph. we prove the soundness of a proof system for conservatively checking consistency, and we show how to implement it efficiently.  jens palsberg cun xiao karl lieberherr
a linear-time algorithm for computing the memory access sequence in data- parallel programs  data-parallel languages, such as high performance fortran, are widely regarded as a promising means for writing portable programs for distributed-memory machines. novel features of these languages call for the development of new techniques in both compilers and run-time systems. in this paper, we present an improved algorithm for finding the local memory access sequence in computations involving regular sections of arrays with cyclic(k) distributions. after establishing the fact that regular section indices correspond to elements of an integer lattice, we show how to find a lattice basis that allows for simple and fast enumeration of memory accesses. the complexity of our algorithm is shown to be lower than that of the previous solution for the same problem. in addition, the experimental results demonstrate the efficiency of our method in practice.  ken kennedy nenad nedeljkovic ajay sethi
compilation techniques for block-cyclic distributions  compilers for data-parallel languages such as fortran d and high-performance fortran use data alignment and distribution specifications as the basis for translating programs for execution on mimd distributed-memory machines. this paper describes techniques for generating efficient code for programs that use block-cyclic distributions. these techniques can be applied to programs with symbolic loop bounds, symbolic array dimensions, and loops with non-unit strides. we present algorithms for computing the data elements that need to be communicated among processors both for loops with unit and non-unit strides, a linear-time algorithm for computing the memory access sequence for loops with non-unit strides, and experimental results for a hand-compiled test case using block-cyclic distributions  seema hiranandani ken kennedy john mellor-crummey ajay sethi
use of virus functions to provide a virtual apl interpreter under user control  by inserting a simple statement at the beginning of an apl function, it is possible to cause the execution of a reconstructed version of the function, rather than of its original statements. this reconstruction can simulate the effect of an arbitrary change in the apl language; thus, the apl programmer can have available a private, "virtual" version of the interpreter  we show some general- and special - purpose functions which can be used for this purpose, and give elementary examples of their application.  j. b. gunn
a novel codesign methodology for real-time embedded cots multiprocessor-based signal processing systems  the process of designing large real-time embedded signal processing systems is plagued by a lack of coherent specification and design methodology (sdm). powerful frameworks exist for each individual phase of this canonical design process, but no single methodology exists which enables these frameworks to work together coherently, i.e., allowing the output of a framework used in one phase to be consumed by a different framework used in the next phase. a specification and design methodology (sdm) known as "search-explore-refine" (ser) was developed by gajski, vahid, et al. for an application and technology domain that is different from that of real-time embedded signal processing systems implemented with commercial-off-the-shelf multiprocessing hardware and software. however, due to similarities between the fundamental design objects of these two domains, a new sdm was developed and prototyped based on ser known as the magic sdm. the "tools and rules" of the magic sdm are presented. the magic sdm achieves a high degree of model continuity based largely on its use of standards-based computation (vsipl) and communication (mpi) middleware.  randall s. janka linda m. wills
problem oriented protocol design  the prevention of deadlock in certain types of distributed simulation systems requires special synchronization protocols. these protocols often create an excessive amount of performance-degrading communication; yet a protocol with the minimum amount of communication may not lead to the fastest network finishing time. we propose a protocol that attempts to balance the network's need for auxiliary synchronization information with the cost of providing that information. using an empirical study we demonstrate the efficiency of this protocol. also, we show that the synchronization requirements at different interfaces may vary; an integral part of our proposal assigns a protocol to an interface according to the interface's synchronization needs.  david m. nicol paul f. reynolds
an incremental programming environment  this document describes an incremental programming environment (ipe) based on compilation technology, but providing facilities traditionally found only in interpretive systems. ipe provides a comfortable environment for a single programmer working on a single program. in ipe the programmer has a uniform view of the program in terms of the programming language. the program is manipulated through a syntax-directed editor and its execution is controlled by a debugging facility, which is integrated with the editor. other tools of the traditional tools cycle (translator, linker, loader) are applied automatically and are not visible to the programmer. the only interface to the programmer is the user interface of the editor.  peter h. feiler raul medina-mora
a design framework to efficiently explore energy-delay tradeoffs  comprehensive exploration of the design space parameters at the system-level is a crucial task to evaluate architectural tradeoffs accounting for both energy and performance constraints. in this paper, we propose a system-level design methodology for the efficient exploration of the memory architecture from the energy-delay combined perspective. the aim is to find a sub-optimal configuration of the memory hierarchy without performing the exhaustive analysis of the parameters space. the target system architecture includes the processor, separated instruction and data level- one caches, the main memory, and the system buses. the methodology is based on the sensitivity analysis of the optimization function with respect to the tuning parameters of the cache architecture (mainly cache size, block size and associativity). the effectiveness of the proposed methodology has been demonstrated through the design space exploration of a real-world example: a microsparc2-based system running the mediabench suite. experimental results have shown an optimization speed up of 329 times with respect to the full search, while the near-optimal system-level configuration is characterized by a distance from the optimal full search configuration in the band of 10%.  william fornaciari donatella sciuto cristina silvano vittorio zaccaria
an automata-theoretic approach to modular model checking  in modular verification the specification of a module consists of two part. one part describes the guaranteed behavior of the module. the other part describes the assumed behavior of the system in which the module is interacting. this is called the assume- guarantee paradigm. in this paper we consider assume-guarantee specifications in which the guarantee is specified by branching temporal formulas. we distinguish between two approaches. in the first approach, the assumption is specified by branching temporal formulas too. in the second approach, the assumption is specified by linear temporal logic. we consider guarantees in  ∀ ctl, and  ∀ ctl*. we develop two fundamental techniques: building maximal models for  ∀ ctl and  ∀ ctl* formulas and using alternating automata to obtain space-efficient algorithms for fair model checking. using these techniques we classify the complexity of satisfiability, validity, implication, and modular verification for  ∀ ctl and ∀ ctl*. we show that modular verification is pspace- complete for  ∀ ctl and is exspace-complete for  ∀ ctl*. we prove that when the assumption is linear, these bounds hold also for guarantees in ctl and ctl*. on the other hand, the problem remains exspace- hard even when we restrict the assumptions to ltl and take the guarantees as a fixed  ∀ ctl formula.  orna kupferman moshe y. vardi
the fortran 90 bindings for opengl it is important to provide a good fortran interface to opengl and related libraries for scientific visualization in mathematical software. opengl has had fortran 77 bindings for some time, however these bindings rely upon several extensions to the fortran 77 standard. by using the new features of fortran 90 it is possible to define bindings for opengl that do not depend on any extensions to the standard and provide access to the full functionality of opengl. william f. mitchell
an architecture for flexible, evolvable process-driven user-guidance environments complex toolsets can be difficult to use. user interfaces can help by guiding users through the alternative choices that might be possible at any given time, but this tends to lock users into the fixed interaction models dictated by the user-interface designers. alternatively, we propose an approach where the tool utilization model is specified by a process, written in a process definition langauge. our approach incorporates a user-interface specification that describes how the user-interface is to respond to, or reflect, progress through the execution of the process definition. by not tightly binding the user-guidance process, the associated user-interfaces, and the toolset, it is easy to develop alternative processes that provide widely varying levels and styles of guidance and to be responsive to evolution in the processes, user interfaces, or toolset. in this paper, we describe this approach for developing process-driven user-guidance environments, a lossely coupled architecture for supporting this separation of concerns, and a generator for automatically binding the process and the user interface. we report on a case study using this approach. although this case study used a specific process definition language and a specific toolset, the approach is applicable to other process definition languages and toolsets, provided they meet some basic, sound software engineering requirements. timothy j. sliski matthew p. billmers lori a. clarke leon j. osterweil
generalized algorithmic debugging and testing  this paper presents a method for semi-automatic bug localization, generalized algorithmic debugging, which has been integrated with the category partition method for functional testing. in this way the efficiency of the algorithmic debugging method for bug localization can be improved by using test specifications and test results. the long-range goal of this work is a semi- automatic debugging and testing system which can be used during large-scale program development of nontrivial programs.  the method is generally applicable to procedural languages and is not dependent on any ad hoc assumptions regarding the subject program. the original form of algorithmic debugging, introduced by shapiro, was however limited to small prolog programs without side-effects, but has later been generalized to concurrent logic programming languages. another drawback of the original method is the large number of interactions with the user during bug localization.  to our knowledge, this is the first method which uses category partition testing to improve the bug localization properties of algorithmic debugging. the method can avoid irrelevant questions to the programmer by categorizing input parameters and then match these against test cases in the test database. additionally, we use program slicing, a data flow analysis technique, to dynamically compute which parts of the program are relevant for the search, thus further improving bug localization.  we believe that this is the first generalization of algorithmic debugging for programs with side-effects written in imperative languages such as pascal. these improvements together makes it more feasible to debug larger programs. however, additional improvements are needed to make it handle pointer-related side-effects and concurrent pascal programs.  a prototype generalized algorithmic debugger for a pascal subset without pointer side-effects and a test case generator for application programs in pascal, c, dbase, and lotus have been implemented.  peter fritzson nahid shahmehri mariam kamkar tibor gyimothy
context-insensitive alias analysis reconsidered  recent work on alias analysis in the presence of pointers has concentrated on context-sensitive interprocedural analyses, which treat multiple calls to a single procedure independently rather than constructing a single approximation to a procedure's effect on all of its callers. while context-sensitive modeling offers the potential for greater precision by considering only realizable call-return paths, its empirical benefits have yet to be measured.  this paper compares the precision of a simple, efficient, context- insensitive points-to analysis for the c programming language with that of a maximally context-sensitive version of the same analysis. we demonstrate that, for a number of pointer-intensive benchmark programs, context-insensitivity exerts little to no precision penalty. we also describe techniques for using the output of context-insensitive analysis to improve the efficiency of context- sensitive analysis without affecting precision.  erik ruf
wait-free synchronization  a wait-free implementation of a concurrent data object is one that guarantees that any process can complete any operation in a finite number of steps, regardless of the execution speeds of the other processes. the problem of constructing a wait-free implementation of one data object from another lies at the heart of much recent work in concurrent algorithms, concurrent data structures, and multiprocessor architectures. first, we introduce a simple and general technique, based on reduction to a concensus protocol, for proving statements of the form, "there is no wait-free implementation of x by y." we derive a hierarchy of objects such that no object at one level has a wait-free implementation in terms of objects at lower levels. in particular, we show that atomic read/write registers, which have been the focus of much recent attention, are at the bottom of the hierarchy: thay cannot be used to construct wait-free implementations of many simple and familiar data types. moreover, classical synchronization primitives such astest&amp;set; and fetch&amp;add;, while more powerful than read and write, are also computationally weak, as are the standard message-passing primitives. second, nevertheless, we show that there do exist simple universal objects from which one can construct a wait-free implementation of any sequential object.  maurice herlihy