waashk/acm huggingface dataset:
programming with explicit metaclasses in smalltalk-80  this paper discusses the introduction of explicit metaclasses a la objvlisp into the smalltalk-80 language. the rigidity of smalltalk metaclass architecture motivated this work. we decided to implement the objvlisp model into the standard smalltalk-80 system. the resulting combination defines the classtalk platform. this platform provides a full-size environment to experiment with class-oriented programming by combining implicit metaclasses a la smalltalk and explicit metaclasses a la objvlisp. obviously, these experiments are not limited to the smalltalk world and will be useful to understand and practice the metaclass concept advocated by modern object- oriented languages such as objvlisp and clos.  j.-p. briot p. cointe
cocoon: creator of concurrent object-oriented systems the software engineering techniques of reuse, encapsulation and information hiding are increasingly being employed in the construction of large, concurrent software systems. simultaneously, hardware platforms continue to increase in sophistication, particularly in the area of concurrency. thus, systems engineers are confronted with the problem of bridging the gap between (1) large computer- based software systems composed of tasks and adts/objects and (2) parallel and distributed computer platforms. thus, this paper describes the cocoon (creator of concurrent object-oriented systems) toolset. cocoon bridges the gap between object-oriented ada software and distributed architectures. it partitions tasks, packages and subprograms, and assigns partitions to physical processors. the toolset automatically produces a distribution specification. lonnie r. welch
using a coordination language to specify and analyze systems containing mobile components  new computing paradigms for network-aware applications need specification languages able to deal with the features of mobile code- based systems. a coordination language provides a formal framework in which the interaction of active entities can be expressed. a coordination language deals with the creation and destruction of code or complex agents, their communication activites, as well as their distribution and mobility in space. we show how the coordination language polis offers a flexible basis for the description and the automatic analysis of architectures of systems including mobile entities. polis is based on multiple tuple spaces and offers a basis for defining, studying, and controlling mobility as it allows decoupling mobile entities from their environments both in space and in time. the pattern- matching mechanism adopted for communication helps in abstracting from addressing issues. we have developed a model-checking technique for the automatic analysis of polis specifications. in the article we show how this technique can be applied to mobile code-based systems  p. ciancarini f. franze c. mascolo
le menu: changing the user interface on a local area network  through the use of batch commands and special application programs, the interface for users on a local area network can be greatly simplified. in an experiment at syracuse university, a menu system has been created to allow students a more direct access to software and computer assisted instruction (cai). this menu system is used in public microcomputer clusters to allow users to gain access to application programs such as word processors and data base managers, as well as system utilities like formatting diskettes. the menu system minimizes the number of commands the users must learn to become productive on the system. this also allows clusters of microcomputers to be used by students with significantly less prior computer experience. the menu interface is written in "extended batch language" and is an extension of the ms-dos batch command set. this menu interface has five main advantages:  less memorization of commands by users.  better handling of special network commands.  low hardware overhead in the workstation.  easy to modify and maintain.  easy to be phased out by students who gain more complex computer skills.  david k. boesharr
a simplified graphic notation for ada programs  a number of graphic notations for describing ada programs have been proposed. in general, these are not supported by off-the-shelf tools; they are perceived by nonexperts as incomprehensible; they obscure simple design deficiencies; and they cannot adequately represent design overviews. to address these problems, a simplified graphic notation has been developed and used in a large ada application at gte government systems corporation, in rockville, maryland. the notation consists of three interrelated diagrams based on extensions of structure chart concepts.  d. sterne g. pretti a. glendening b. jachowski
a reusable ada package for scientific dimensional integrity abstract -- our recent experience in operations desert shield and desert storm has clearly demonstrated the criticality of software reliability end that truly reliable software is indeed possible. one tool we can employ to enhance our software reliability is the classic scientific computational reliability technique of dimensional integrity, or unite checking. the ads programming language makes it easy to implement units checking. a physical_quantity type is declared which ham entries for both the floating point numeric value of s variable, and integer entries for exponents of the fundamental physical unite of mass, length, and time. the ads feature of "operator overloading" allows creation of symbols to porters arithmetic and relational operations on these variables . for example, the multiplication operation "*" ie overloaded eo that the numeric values of the two operande are multiplied, and the exponents of their fundamental units are added. an assign function is then written to check that the units computed in an expression are equal to the units of the variable to which s new numeric value is assigned. further reliability ie added by "information hiding" through limited private types, and reusability and modifiability are added by making the package generic. for scientific software, this generic package is as reusable as package standard. george w. macpherson
sparse functional stores for imperative programs  in recent years, the trend in program representations for imperative programs has been to make them more functional, or to make them more sparse. however, new sparse representations have been non-functional, and new functional representations have not been sparse in the presence of pointer operations. in this paper, we present a functional representation that is sparse even in the presence of pointer operations.  conventionally, a store is represented in a functional program representation by a single object---typically a mapping from locations to values. we show how such a store object may be fragmented into several objects, each representing part of the store. the result is a sparser representation, which has not only the usual benefit of directly linking producers to consumers, but which also for static program analysis often leads to smaller domains of abstract values for store objects. store fragmentation corresponds to assignment factored ssa form (a factorization of ssa form introduced in this paper). we report on experiments with a thorough fragmentation based on a data flow points-to analysis and an intermediate level fragmentation based on an almost linear time complexity points-to analysis by type inference.  bjarne steensgaard
real-time replication garbage collection  we have implemented the first copying garbage collector that permits continuous unimpeded mutator access to the original objects during copying. the garbage collector incrementally replicates all accessible objects and uses a mutation log to bring the replicas up-to-date with changes made by the mutator. an experimental implementation demonstrates that the costs of using our algorithm are small and that bounded pause times of 50 milliseconds can be readily achieved.  scott nettles james o'toole
a disk emulator for the commodore 1541 disk drive (abstract only)  fitscan is a system of monitoring and analyzing cardiovascular fitness. this is done with a combination of hardware and software. the system is based off of the commodore 64 microcomputer. we have designed a radio that will send a signal to the computer for each pulse. the radio is used for monitoring heart rates of athletes in action. fitscan also runs fitness tests, including a cardiovascular test, muscular test, and a program that determines body fat from skin calipers. the next step for fitscan is to develop a system to test a large number of people in a short amount of time. the ymca's national fitness test protocols are used for this system. the system will use 4 computers, dedicating each to a specific part of the test. since the process will be pipelined and each computer will process 4 people at a time, a rate of fifty people per hour can be achieved.  robert e. owens
a portable apl language test generation and verification system  the major tasks that must be performed during development and use of an apl language test system include construction of tests and verification of test results. in addition, it is desirable that a test system be transportable to a variety of apl language implementations, be extensible, and allow easy revalidation of the language implementation.  in this paper, we will describe the design, implementation, and use of an extensible, portable, self-verifying apl test system that includes facilities to generate large sets of useful tests with very little effort.  the test system is based on a test definition language and on an executable formal definition of the apl language. by careful use of the test system, 150,000 self-verifying language tests were constructed in four man-weeks.  transportability was achieved by using apl as the implementation language for the test system software.  the successful use and transportation of this test system demonstrates that it is relatively easy to generate tests for and in the apl language.  charles g. nylander
experience with porting the portable c compiler  in may of 1981, a project was undertaken at north carolina state university to develop a c compiler for the data general eclipse mv/8000. the compiler was to be based upon the portable c compiler1 (pcc), which was developed at bell labs by steve johnson. the project, now near completion, has proven to be an enlightening journey into the realm of portable software, and many lessons have been learned. this paper will describe the approach we took to porting the compiler, problems we encountered, and our solutions to these problems.  charles h. minchew kuo-chung tai
orwell - a configuration management system for team programming  in this paper, we describe the design and implementation of orwell, a configuration management tool for multiperson smalltalk projects. although the system described has been implemented for smalltalk, the design is applicable to other languages such as c++, objective-c or ada. smalltalk is well recognized as a productive programming environment for an individual programmer, but its lack of team support is currently a major obstacle in using smalltalk for a large software project. to support multiperson smalltalk programming, orwell provides both source and object code sharing as well as version control on a network of personal workstations. class ownership is used as the primary means for dividing work among programmers during the lifecycle of a project. orwell also supports groups of programmers not physically connected to a common file server. we describe our implementation which preserves the productive exploratory environment of smalltalk. seamless integration and performance are essential for orwell to be accepted and used by smalltalk programmers.  dave thomas kent johnson
jrapture: a capture/replay tool for observation-based testing  we describe the design of jrapture: a tool for capturing and replaying java program executions in the field. jrapture works with java binaries (byte code) and any compliant implementation of the java virtual machine. it employs a lightweight, transparent capture process that permits unobtrusive capture of a java programs executions. jrapture captures interactions between a java program and the system, including gui, file, and console inputs, among other types, and on replay it presents each thread with exactly the same input sequence it saw during capture. in addition, jrapture has a profiling interface that permits a java program to be instrumented for profiling ?ter its executions have been captured. using an xml-based profiling specification language a tester can specify various forms of profiling to be carried out during replay.  john steven pravir chandra bob fleck andy podgurski
apl - compilation-where does the time come from?  we have developed an experimental system to compile apl by translating it into a high-level language that has a compiler. the compiled functions can be called by the ibm apl2 interpreter through its name-association interface. five of the ways in which use of our system saves execution time are discussed here. for scalar apl code, some savings result from the removal of all parsing and much checking for conformability and case at run time. substantial savings sometimes arise from the feasibility of searching for a wider variety of special cases. where they apply, such complications as non-zero comparison tolerances are costly; we avoid these costs and expect the programmer to take care of these complications explicitly at the relatively few points where they are needed. by combining loops where possible, we sometimes achieve significant savings. finally, we conjecture that the greatest savings are most often due to our general method of combining primitive apl operations; we can often eliminate redundant computation and avoid storing and fetching temporary results. examples are given.  graham c. driscoll donald l. orth
ensuring integrity by adding obligations to privileges  conventional authorization mechanisms provide actors with permissions to act, without the actor ever incurring any obligations as a result of executing the permitted action. there exist, however, many situations where system integrity requires that certain actions always be followed by others, within some reasonable time frame. we propose an extension to conventional authorization which allows the explicit association of obligations with permissions, and enforces them. we demonstrate that the extended mechanism can be used to support and enforce several general types of control policies and integrity constraints which are otherwise difficult or impossible to support.  naftaly h. minsky abe d. lockman
ace: a language for parallel programming with customizable protocols  customizing the protocols that manage accesses to different data structures within an application can improve the performance of software shared-memory programs substantially. existing systems for using customizable protocols are hard to use directly because the mechanisms they provide for manipulating protocols are low-level ones. this article is an in-depth study of the issues involved in providing language support for application-specific protocols. we describe the design and implementation of a new language for parallel programming, ace, that integrates support for customizable protocols with minimal extensions to c. ace applications are developed using a shared- memory model with a default sequentially consistent protocol. performance can then be optimized, with minor modifications to the application, by experimenting with different protocol libraries. the design of ace was driven by a detailed study of the use of customizable protocols. we delineate the issues that arise when programming with customizable protocols and present novel abstractions that allow for their easy use. we describe the design and implementation of a runtime system and compiler for ace nd discuss compiler optimizations that improve the performance of such software shared-memory systems. we study the communication patterns of a set of benchmark applications and consider the use of customizable protocols to optimize their performance. we evaluate the performance of our system through experiments on a thinking machine cm-5 and a cray t3e. we also present measurements that demonstrate that ace has good performance compared to that of a modern distributed shared-memory system.  mukund raghavachari anne rogers
extending apl "optional arguments"  two types of apl arguments are defined---positional and optional. apl currently provides limited "optional argument" capabilities by optionally specifying the axis on which to operate for some primitives. other current apl optional argument capabilities, defined as global keywords, and optional argument capabilities requiring an expansion of apl, defined as local keywords, are introduced and compared. when the values passed to a function do not change frequently between calls, local keywords are shown to increase the relevance, power and simplicity of apl.  richard l. naugle joseph b. schlam
abstract debugging of higher-order imperative languages  abstract interpretation is a formal method that enables the static determination (i.e. at compile-time) of the dynamic properties (i.e. at run- time) of programs. we present an abstract interpretation-based method, called abstract debugging, which enables the static and formal debugging of programs, prior to their execution, by finding the origin of potential bugs as well as necessary conditions for these bugs not to occur at run-time. we show how invariant assertions and intermittent assertions, such as termination, can be used to formally debug programs. finally, we show how abstract debugging can be effectively and efficiently applied to higher-order imperative programs with exceptions and jumps to non-local labels, and present the syntox system that enables the abstract debugging of the pascal language by the determination of the range of the scalar variables of programs.  françois bourdoncle
a framework for interprocedural optimization in the presence of dynamic class loading  dynamic class loading during program execution in the java programming language is an impediment for generating code that is as efficient as code generated using static whole-program analysis and optimization. whole- program analysis and optimization is possible for languages, such as c++, that do not allow new classes and/or methods to be loaded during program execution. one solution for performing whole-program analysis andavoiding incorrect execution after a new class is loaded is to invalidate and recompile affected methods. runtime invalidation and recompilation mechanisms can be expensive in both space and time, and, therefore, generally restrict optimization.  to address these drawbacks, we propose a new framework, called the extant analysis framework, for interprocedural optimization of programs that support dynamic class (or method)loading. given a set of classes comprising the closed world, we perform an offline static analysis which partitions references into two categories:(1) unconditionally extant references which point only to objects whose runtime type is guaranteed to be in the closed world; and (2) conditionally extant references which point to objects whose runtime type is not guaranteed to be in the closed world. optimizations solely dependent on the first categorycan be statically performed, and are guaranteed to be correct even with any future class/method loading. optimizations dependent on the second category are guarded by dynamic tests, called  extant safety tests, for correct execution behavior.we describe the properties for extant safety tests, and provide algorithms for their generation and placement.  vugranam c. sreedhar michael burke jong-deok choi
automatic derivation of code generators from machine descriptions  work with compiler compilers has dealt principally with automatic generation of parsers and lexical analyzers. until recently, little work has been done on formalizing and generating the back end of a compiler, particularly an optimizing compiler. this paper describes formalizations of machines and code generators and describes a scheme for the automatic derivation of code generators from machine descriptions. it was possible to separate all machine dependence from the code generation algorithms for a wide range of typical architectures (ibm-360, pdp-11, pdp-10, intel 8080) while retaining good code quality. heuristic search methods from work in artificial intelligence were found to be both fast and general enough for use in generation of code generators with the machine representation proposed. a scheme is proposed to perform as much analysis as possible at code generator generation time, resulting in a fast pattern-matching code generator. the algorithms and representations were implemented to test their practicality in use.  r. g. cattell
the mutual exclusion problem: partii - statement and solutions  the theory developed in part i is used to state the mutual exclusion problem and several additional fairness and failure-tolerance requirements. four "distributed" n-process solutions are given, ranging from a solution requiring only one communication bit per process that permits individual starvation, to one requiring about n! communication bits per process that satisfies every reasonable fairness and failure-tolerance requirement that we can conceive of.  leslie lamport
software process instantiation and the planning paradigm  one of the challenges in finding a suitable paradigm for defining software processes relates to the highly dynamic nature of software development. the actions required to carry out a given process are often dependent on detailed aspects of the current state. for example, the modules that need to be archived are just those that have been changed since they were last archived; the choice of archival method (i.e., source code control system versus local backup copy) depends on whether the module is in a steady state or still rapidly changing; use of certain debugging features is ruled out unless compilations were done with optimization disabled; and, many quite diverse factors influence the choice of relevant test cases to be run against a particular system version. the fact that development takes place, in part, through trial-and-error means that failures occur frequently, and recovery from failure must be accommodated. in spite of the programmer's best intentions, design reviews reveal areas needing rework, compilers find errors in source code, test cases fail, and tools sometimes exhibit bugs themselves.  powerful instantiation facilities represent one way to handle this type of dynamic behavior. a software project defines the process its programmers are to follow, and the actions taken by the programmers represent instantiations of this process. at an absolute minimum, instantiation involves binding parameters in the process definition to specific software objects in the environment. in this paper, we describe the relationship between instantiation facilities and the dynamics of process activities. first, we illustrate some limitations in instantiation mechanisms using a familiar paradigm: procedural definitions of processes. then we describe a different approach to instantiation used in the ai planning paradigm.  karen e. huff
qmod: a system for automatically generating and solving analytical queueing network models  an analytical queueing model generator (qmod) is a package for generating and analyzing queueing networks. a description of a queueing network, written in a language meaningful to the user, is compiled into a set of matrices that characterize an analytical model of the network. network flow rates are computed and used to derive arrival rates at each operation and tool. tool arrival rates, service rates, and quantities are used in an analytic queueing model of the m/m/k form. analytical models typically require orders of magnitude less computation time than do simulation models. they, therefore, lend themselves to parametric studies and optimization in ways that would be impractical with simulation models.  leo h. groner