waashk/acm huggingface dataset:
document structure and modularity in mentor  mentor is a structured document manipulation system. it has been used for several years as a program development and maintenance environment.  its main characteristics are:  it is both interactive and programmable,  it is parameterized by the language to be manipulated,  it can manipulate several languages at the same time, as well as multi-lingual documents.  it is open to and from the outer system,  it is extensible.  the current development of mentor reflects our belief that a major component of programming is the maintenance of large documents of a varied nature: specifications, programs, manuals, progress reports, documentation, etc... in addition, information of various kinds, and in different languages, is often mixed in a single document, and one may have to extract this information selectively upon request (e.g. text, examples and formal specification in a manual, or instructions, comments and assertions in a program).  v. donzeau-gouge g. kahn b. lang b. melese
a method using procedural parameters and callback functions to create a generic exchange-sorting module  a generic exchange-sorting module obviates the need for duplicating sort code in a program, thus promoting module reuse. this paper presents a method for using procedural parameters and callback functions to create a generic exchange-sorting module. based on techniques with roots in functional programming using higher order functions, the method is fairly easy to understand. more importantly it is easy to use, even for beginning programmers. using the rapid application development system delphi and it's object pascal programming language, the method is presented in a way that highlights some useful features of object pascal that might not be well known to readers more familiar with the now-outdated standard pascal or the currently popular c++.  robin m. snyder
a strongly typed, interactive object-oriented database programming language  programming languages with data types have been used successfully to model databases with the abstraction mechanisms of a relational or semantic data model. the benefits of data types for modeling databases with an object- oriented database language has also been considered, but more research is required to isolate the basic features that the type system of the language should have, and to integrate the representation of abstract knowledge with the representation of concrete and procedural knowledge. the point of view is presented that, for a strongly typed programming language, the following features are relevant: a) a type system with concrete types, abstract data types with assertions and inheritance of operators from the representation type; b) the notion of type hierarchies; c) an object-oriented view of databases, where objects are the only values that can be created, destroyed, and updated. examples will be given to show how the conceptual language galileo might be modified to become a strongly typed, object-oriented database language.  a. albano g. ghelli m. e. occhiuto r. orsini
polling in concurrent programming  hoare introduced the concept of polling in his communicating sequential processes (csp) to handle nondeterministic message communication in distributed and concurrent programming. in order to introduce the polling concept effectively in a programming language, the problems of simultaneous polling, effective termination, busy waiting, and expressive power in one-to- many or many-to-one communication must be solved. this paper discusses the concept of polling, the details about the problems, and how a new concurrent programming language, copl, solves the problems. copl introduces a general algorithm to establish a hierarchical relationship between two communicating processes, an efficient mechanism to handle polling termination, a flexible polling to avoid busy waiting, and implicit polling to add asymmetry in the language for more expressive power. [key words: concurrent programming, programming languages, polling, nondeterminism, and distributed systems]  c.-d. jung e. siberrt
ada '82 - status, use and application techniques  the ada language was designed as a language to address embedded systems within the department of defense. the interest in this language is evident from the numerous articles, texts and conferences which have addressed this language and its application within the real time embedded systems environment.  there have been research efforts directed to the use of ada. these efforts have been conducted by a variety of individuals and organizations and have resulted in contributions to requirements and design methodologies as well as application areas. thus, we are seeing several prototype implementations which illustrate the use of ada in the software lifecycle.  john foreman
nil: an integrated language and system for distributed programming  this paper presents features of the nil programming language which support the construction of distributed software systems: (1) a process model in which no pointers or shared data are visible, (2) interprocess communication via synchronous and asynchronous message passing, (3) compile- time typestate checking, guaranteeing module isolation and correct finalization of data, (4) dynamic binding of statically typed ports under the control of capabilities.  we discuss how these features are defined in nil, illustrate the consequences of these decisions for the design of distributed systems, and compare these decisions with those made in other programming languages with similar objectives.  robert e. strom shaula yemini
wsclock - a simple and effective algorithm for virtual memory management  a new virtual memory management algorithm wsclock has been synthesized from the local working set (ws) algorithm, the global clock algorithm, and a new load control mechanism for auxiliary memory access. the new algorithm combines the most useful feature of ws---a natural and effective load control that prevents thrashing---with the simplicity and efficiency of clock. studies are presented to show that the performance of ws and wsclock are equivalent, even if the savings in overhead are ignored.  richard w. carr john l. hennessy
some factors affecting program repair maintenance: an empirical study  an empirical study of 447 operational commercial and clerical cobol programs in one australian organization and two u.s. organizations was carried out to determine whether program complexity, programming style, programmer quality, and the number of times a program was released affected program repair maintenance. in the australian organization only program complexity and programming style were statistically significant. in the two u.s. organizations only the number of times a program was released was statistically significant. for all organizations repair maintenance constituted a minor problem: over 90 percent of the programs studied had undergone less than three repair maintenance activities during their lifetime.  iris vessey ron weber
organization domain modeling (odm): formalizing the core domain modeling life cycle  researchers and practitioners are looking for systematic ways of comparing domain analysis (da) methods. comparisons have often focused on linkage between da methods and related technologies such as systems modeling. less attention has been paid to comparing da methods in terms of certian core methodological issues, including problems of scoping, contextualizing, descriptive vs. prescriptive modeling, and formalized models of variability. this paper presents key aspects of organization domain modeling (odm), a systematic domain analysis method structured in terms of a core domain modeling life cycle directly addressing these methodological concerns.  mark a. simos
an abstract machine design for lexically scoped parallel lisp with speculative processing  an abstract machine is designed to support the data environment requirements of balinda lisp, a parallel lisp dialect which permits speculative processing of conditional modules. logically, the machine provides multiple stacks connected into an environment tree, with lexically visible sections pointed to by display registers. physically, stack sections are stored as separate objects and access is established by the use of a dynamic stack recording the chain of function calls, and a set of lexical display registers pointing at visible objects. this arrangement allows parts of the environment of a function to be retained or garbage-collected as appropriate after exit. by making copies of visible ancestral stack sections, side effects of speculative parallel tasks are handled in accordance with language semantics. the architecture is generic and may be realized in a variety of forms, depending on whether balinda lisp is implemented on a conventional machine, stack machine, or dataflow machine.  c. k. yuen
position paper on microprocessor assembly language draft standard ieee task p694/d11  among the early purposes of assembly languages must be included:  1) the use in the programming process of mnemonic operation codes and symbolic variables names instead of the bit patterns and relative addresses of machine code as an aid to the human programmer. machine code programming has largely disappeared except as a temporary bootstrapping process in producing an early version of an assembler, a compiler, or an interpreter. we shall ignore it in this short note. other reasons often cited as justification for employing an assembly language at the present time are:  2) the availability of all the machine resources and facilities,  3) the necessity of producing a program that executes as fast as possible,  4) the necessity of producing a program that is as parsimoneous of memory as possible, and  5) as the original bootstrap processor in producing compilers or interpretors for higher level systems and applications languages.  we wish to emphasize that these reasons were often valid in the past; that these reasons are sometimes valid at present; and that these reasons will remain valid only under very special circumstances in the future.  g. w. gorsline
always one more bug: applying adawise to improve ada code  adawise, a set of tools currently under development at ora, performs automatic checks to verify the absence of common run-time errors affecting the correctness or portability of ada programs. the tools can be applied to programs of arbitrary size, and they are conservative\\---that is, the absence of a warning guarantees the absence of a problem. if adawise issues a warning, there is a potential error that should be investigated by the programmer. adawise checks at compile-time for such potential errors as incorrect order dependence and erroneous execution due to improper aliasing. these errors are not detected by typical compilers. we ran two of the tools on several publicly available ada software products to determine if the tools issue useful warnings without bombarding the user with "false positives." we found that adawise generated a small number of total warnings, and that false positives usually indicated areas of weakness in the products tested.  this paper describes our preliminary tests using the adawise toolset, and analyzes the warnings that were issued.  cheryl barbasch dan egnor
parameter passing and control stack management in prolog implementation revisited  parameter passing and control stack management are two of the crucial issues in prolog implementation. in the warren abstract machine (wam), the most widely used abstract machine for prolog implementation, arguments are passed through argument registers, and the information associated with procedure calls is stored in possibly two frames. although accessing registers is faster than accessing memory, this scheme requires the argument registers to be saved and restored for back tracking and makes it difficult to implement full tail recursion elimination. these disadvantages may far outweigh the advantage in emulator-based implementations because registers are actually simulated by using memory. in this article, we reconsider the two crucial issues and describe a new abstract machine called atoam (yet another tree-oriented abstract machine). the atoam differs from the wam mainly in that (1) arguments are passed directly into stack frames, (2) only one frame is used for each procedure call, and (3) procedures are translated into matching trees is possible, and clauses in each procedure are indexed on all input arguments. the above-mentioned inefficiencies of the wam do not exist in to he atoam because backtracking requires less bookkeeping operations, and tail recursion can be handled in most cases like a loop statement in procedural languages. an atoam-emulator-based prolog system called b-prolog has been implemented, which is available through anonymous ftp from ftp.kyutech.ac.jp (131.206.1.101) in the directory pub/language/prolog.b-prolog is comparable in performance with and can sometimes be significatly faster than emulated sicstus-prolog. by measuring the numbers of memory and register references made in both systems, we found that passing arguments in stack is no worse than passing arguments in registers even if accessing memory is four times as expensive as accessing registers.  neng-fa zhou
supporting awareness and interaction through collaborative virtual interfaces  this paper explores interfaces to virtual environments supporting multiple users. an interface to an environment allowing interaction with virtual artefacts is constructed, drawing on previous proposals for 'desktop' virtual environments. these include the use of peripheral lenses to support peripheral awareness in collaboration; and extending the ways in which users' actions are represented for each other. through a qualitative analysis of a design task, the effect of the proposals is outlined. observations indicate that, whilst these designs go some way to re-constructing physical co-presence in terms of awareness and interaction through the environment, some issues remain. notably, peripheral distortion in supporting awareness may cause problematic interactions with and through the virtual world; and extended representations of actions may still allow problems in re-assembling the composition of others' actions. we discuss the potential for: designing representations for distorted peripheral perception; and explicitly displaying the course of action in object-focused interaction.  mike fraser steve benford jon hindmarsh christian heath
functionality in the reusability of software  reusable mathematical and statistical software has been available for some time providing substantial programming productivity to scientists and engineers. with the development of ada and extensions of its package concept to more general categories of information systems, libraries of reusable code and cataloging schemes are anticipated from regular practices to yield the same kinds of benefits to these systems. one obstacle has been the lack of abstractions for identifying and developing candidate reusable software, promoting its later classification, recovery and modification. this paper advances a method to discover common functions across different systems to enhance reusability.  ross a. galgiano martin d. fraser mark e. schaefer g. scott owen
soft timers: efficient microsecond software timer support for network processing this paper proposes and evaluates soft timers, a new operating system facility that allows the efficient scheduling of software events at a granularity down to tens of microseconds. soft timers can be used to avoid interrupts and reduce context switches associated with network processing without sacrificing low communication delays.more specifically, soft timers enable transport protocols like tcp to efficiently perform rate-based clocking of packet transmissions. experiments show that rate-based clocking can improve http response time over connections with high bandwidth-delay products by up to 89% and that soft timers allow a server to employ rate-based clocking with little cpu overhead (2-6%) at high aggregate bandwidths.soft timers can also be used to perform network polling, which eliminates network interrupts and increases the memory access locality of the network subsystem without sacrificing delay. experiments show that this technique can improve the throughput of a web server by up to 25%. mohit aron peter druschel
conjunction as composition  partial specifications written in many different specification languages can be composed if they are all given semantics in the same domain, or alternatively, all translated into a common style of predicate logic. the common semantic domain must be very general, the particular semantics assigned to each specification language must be conducive to composition, and there must be some means of communication that enables specifications to build on one another. the criteria for success are that a wide variety of specification languages should be accommodated, there should be no restrictions on where boundaries between languages can be placed, and intuitive expectations of the specifier should be met.  pamela zave michael jackson
automatic tuning of multi-task programs for real-time embedded systems  this paper describes a programming tool for real-time embedded systems. real- time embedded systems are usually implemented by multiple tasks. it is important to allocate tasks to the system appropriately. our tool, called true, performs the allocation of tasks by transformation of the program the user has written. true reads the program and the requirements about its response time. true transforms the program applying rules based on the requirements. then the program is translated into a code for operating system i-tron. i-tron is our original real-time operating system for 32-bit microprocessors. this paper also describes the implementation of true and an example of its use.  toru shimizu ken sakamura
commutativity analysis: a new analysis technique for parallelizing compilers  this article presents a new analysis technique, commutativity analysis, for automatically parallelizing computations that manipulate dynamic, pointer- based data structures. commutativity analysis views the computation as composed of operations on objects. it then analyzes the program at this granularity to discover when operations commute (i.e., generate the same final result regardless of the order in which they execute). if all of the operations required to perform a given computation commute, the compiler can automatically generate parallel code. we have implemented a prototype compilation system that uses commutativity analysis as its primary analysis technique. we have used this system to automatically parallelize three complete scientific computations: the barnes-hut n-body solver, the water liquid simulation code, and the string seismic simulation code. this article presents performance results for the generated parallel code running on the stanford dash machine. these results provide encouraging evidence that commutativity analysis can serve as the basis for a successful parallelizing compiler.  martin c. rinard pedro c. diniz
file-system development with stackable layers  filing services have experienced a number of innovations in recent years, but many of these promising ideas have failed to enter into broad use. one reason is that current filing environments present several barriers to new development. for example, file systems today typically stand alone instead of building on the work of others, and support of new filing services often requires changes that invalidate existing work.  stackable file-system design addresses these issues in several ways. complex filing services are constructed from layer "building blocks," each of which may be provided by independent parties. there are no syntactic constraints to layer order, and layers can occupy different address spaces, allowing very flexible layer configuration. independent layer evolution and development are supported by an extensible interface bounding each layer.  this paper discusses stackable layering in detail and presents design techniques it enables. we describe an implementation providing these facilities that exhibits very high performance. by lowering barriers to new filing design, stackable layering offers the potential of broad third- party file-system development not feasible today.  john s. heidemann gerald j. popek
using operational analysis assumption errors  assumptions that are the basis for operational analysis models of devices have the characteristic that they can be proved to hold by observing the data. error measures are defined for the main operational analysis assumptions. a method for deriving correction terms is described. these terms are functions of the error measures and can be used to get exact results of behavior sequence performance measures of interest, such as, mean number of jobs at a device. these performance measures will be exact no matter how badly the operational assumptions are met by the data. formulas for performance measures that were developed assuming homogeneous arrivals and services were found to give exact results under less restrictive conditions. since the performance measure correction terms can only be calculated exactly with an amount of data that would be required to obtain direct performance measure results, ways to estimate the correction terms with reduced data collection are suggested.  neal m. bengtson
a smalltalk window system based on constraints  we describe the design of a constraint-based window system for smalltalk. this window system uses constraints to specify attributes of windows and relationships between them. three classes of constraints are supported, one of which is implicit and not available for general use. the system extends the current smalltalk system, providing support for both fixed-size and fixed- scale windows. it also provides the capability to dynamically reorganize the layout of a window. a goal of the design is to produce a system with real-time response that is fast enough to be substituted for the existing system. a prototype with response times of approximately 1/4 second has been implemented to demonstrate the feasibility of the design as well as to point out several important optimizations.  danny epstein wilf r. lalonde
integration mechanisms in cedar  the importance of integration in programming environments is well known. perhaps the easiest way to build an integrated system is to build a closed system; the designers of the system can use whatever ad hoc techniques are available to make the pieces they provide hang together nicely. many of the integrated editor/compiler/execution environments (like the cornell program synthesizer) fall into this category [teitelbaum81].  when building an open system, the problem for the designers of the system is not to integrate a fixed collection of tools, but to provide general mechanisms for tool integration. for instance, unix "pipes" provide an elegant means of integrating new tools by making it easy to make the output of one tool the input of another; also, the simplicity of the unix file system makes it easy to integrate new devices into the system - the file system conceals the physical peculiarities of the devices instead of making them visible [kernighan81].  james donahue
powerlist: a structure for parallel recursion  many data-parallel algorithms---fast fourier transform, batcher's sorting schemes, and the prefix-sum---exhibit recursive structure. we propose a data structure called powerlist that permits succinct descriptions of such algorithms, highlighting the roles of both parallelism and recursion. simple algebraic properties of this data structure can be explotied to derive properties of these algorithms and to establish equivalence of different algorithms that solve the same problem.  jayadev misra