waashk/acm huggingface dataset:
reflective facilities in smalltalk-80  computational reflection makes it easy to solve problems that are otherwise difficult to address in smalltalk-80, such as the construction of monitors, distributed objects, and futures, and can allow experimentation with new inheritance, delegation, and protection schemes. full reflection is expensive to implement. however, the ability to override method lookup can bring much of the power of reflection to languages like smalltalk-80 at no cost in efficiency.  b. foote r. e. johnson
encapsulating objects with confined types object-oriented languages provide little support for encapsulating objects. reference semantics allows objects to escape their defining scope. the pervasive aliasing that ensues remains a major source of software defects. this paper introduces kacheck/j a tool for inferring object encapulation properties in large java programs. our goal is to develop practical tools to assist software engineers, thus we focus on simple and scalable techniques. kacheck/j is able to infer _confinement_ for java classes. a class and its sublasses are confined if all of their instances are encapsulated in their defining package. this simple property can be used to identify accidental leaks of sensitive objects. the analysis is scalable and efficient; kacheck/j is able t infer confinement on a corpus of 46,000 classes (115 mb) in 6 minutes christian grothoff jens palsberg jan vitek
ensemble: a graphical user interface development system for the design and use of interactive toolkits  user interface development systems (uids), as opposed to user interface management systems or ui toolkits focus on supporting the design and implementation of the user interface. this paper describes ensemble, an experimental uids that begins to explore the electronic creation of interaction techniques as well as the corresponding design processes. issues related to the impact on the components of the development system are discussed. finally, problems with the current implementation and future directions are presented.  m. k. powers
building an apl2 x-windows interface for vm and aix with a general apl2-to-c interface this paper describes apl2/x, an interface between x-windows and apl2, designed and built at the ibm cambridge scientific center. it currently runs under vm/cms and aix. the apl2/x vm version of the interface uses the apl2 associated processor 11 to communicate with x. the apl2/x aix version uses a new auxiliary processor, ap144, to achieve the same functionality.apl2/x enables all of the x-windows xlib calls and data- structures for use from the apl2 environment. in so doing, it enables apl2 to make use of a true windowing environment. several apl2 sample programs using the interface have been coded to illustrate and validate the interface.the basic x-windows xlib is actually a large application written in c. apl2/x has therefore been built upon, as well as heavily influenced, a general apl2-to-c interface that runs on various platforms: apl2 under vm/cms and mvs/tso, apl2 for the risc system/6000 under aix, and apl2/pc under pc/dos. john r. jensen kirk a. beaty
introducing granularity-dependent quantitative distance and diameter measures in common-sense reasoning contexts in this paper, i will present a method for constructing correlatedseries of granularity-dependent distance and diameter measures onthe basis of a theory of qualitative spatial concepts. eachgranularity-dependent measure function has as its range a discretesubset of r. as we proceed through a series of such functions, thedistance between the values in the range will become smaller andthe measurements returned by the functions will becomecorrespondingly more precise. my method for constructing the seriesof functions is partially based on work in kranz, luce, suppes, andtversky, _the foundations of measurement_, vol. 1. i use aresult from that volume to prove that my series of distance anddiameter measures converge to continuous, extensive distance anddiameter measures. but it is the discrete measures in the series,not the continuous limit measures, that should be used in analysesof common-sense concepts. unlike the continuous measure functions,arbitrary values for the discrete measure functions can, in mostcontexts, be determined through practical procedures. moreover, theability to move from one granularity-level to the next isappropriate for common-sense contexts in which the level ofprecision is typically kept at the minimum necessary to accomplishthe task at hand. maureen donnelly
problem dynamics and working set principle as applied to concurrent processing  for fast and efficient problem solving we need to not only exploit concurrency in the problem structure but also the problem dynamics which allows one to use result sharing and partial evaluation [kri 87]. intuitively it is clear that the interplay of problem structure and problem dynamics can be exploited to identify only the essential part of a computation as it evolves over a period of time. ignoring dynamics may result in redundant and hence inefficient, slow, and expensive computation.  the notion of working set in the context of efficient processing of programs was introduced by denning [den 68]. for cost-effective computation it is essential to have no more computational resources than that demanded by the average working set of the computation. similarly, for performance reasons, the amount of computational resources must be at least equal to that demanded by the working set of the computation. thus, the idea of generating a working set and scheduling computational tasks from the working set is key to both cost- effective and high-performance computations.  the working set model based on locality properties has been extensively studied in [den 68] which assumes sequential computational model. the design and implementation of a working set dispatcher is discussed in [ros 73]. the working set of processes in running state are computed periodically and the paging algorithm never chooses replacement pages from the working set of running processes. the notion of working set as applied to concurrent processing is proposed in [tok 83]. the contribution towards working set here is two-fold: due to principle of locality and simultaneity of execution. unlike in a sequential machine, where the computation flow is more like a thread, in a concurrent machine the computation flow is like a wavefront on the data flow graph. a potentially costly component of a data flow machine is the mechanism to recognize when an instruction node has all of its operands available. for cost and performance reasons only the working set of nodes need to be checked. the working set of computation need to be automatically created based on the structure of the data flow graph of the computation and node fetch and replacement policies.  when problem dynamics is exploited in the form of result sharing and better decomposition techniques, as considered in [kri 87], the potential for efficient problem solving increases by supporting the working set creation and dispatch logic. we need both fast and dynamic analysis of the computation graph in order to identify the working set of computation. some of the issues involved in this respect are discussed.  s. krishnaprasad
an iterative-design model for reusable object-oriented software  we present an iterative-design approach for reusable object-oriented software that augments existing design methods by incorporating iteration into the design methodology and focuses on the set of problems within the domain, encouraging reuse of existing design information. the model has five separate stages which are described, before an example design is outlined using the model with sample code constructs in c++. our results have shown a high degree of code reuse when using the model, directly attributable to two distinct design stages. an analysis of these results is also presented.  sanjiv gossain bruce anderson
obtaining sequential efficiency for concurrent object-oriented languages  concurrent object-oriented programming (coop) languages focus the abstraction and encapsulation power of abstract data types on the problem of concurrency control. in particular, pure fine-grained concurrent object- oriented languages (as opposed to hybrid or data parallel) provides the programmer with a simple, uniform, and flexible model while exposing maximum concurrency. while such languages promise to greatly reduce the complexity of large-scale concurrent programming, the popularity of these languages has been hampered by efficiency which is often many orders of magnitude less than that of comparable sequential code. we present a sufficiency set of techniques which enables the efficiency of fine- grained concurrent object-oriented languages to equal that of traditional sequential languages (like c) when the required data is available. these techniques are empirically validated by the application to a coop implementation of the livermore loops.  john plevyak xingbin zhang andrew a. chien
programming ecology or apl and the world at large  apl, like any programming language, interacts with various environments and individuals. how it does so and how it evolves in response to these external influences are important to the continuing health and survival of the language. it can also have a profound effect on the evolution of these same environments and individuals, since apl is a part of their universe, just as they are part of its universe.  this paper examines the demands and opportunities of interacting with these external influences and the means by which apl has tried to deal with them as a set of mutually interdependent systems, i.e., an ecology. it also proposes some future evolutionary directions for apl which should not only insure its survival but gain it a dominant position in the programming ecology. not the least conclusion is that apl must be responsible for its own success.  jim lucas
design of the opportunistic garbage collector  the opportunistic garbage collector (ogc) is a generational garbage collector for stock hardware and operating systems. while incorporating important features of previous systems, the ogc includes several innovations. a new bucket brigade heap organization supports advancement thresholds between one and two scavenges, using only two or three spaces per generation, and without requiring per-object counts. opportunistic scavenging decouples scavenging from the filling of available memory, in order to hide potentially disruptive scavenge pauses and improve efficiency. card marking efficiently records which small areas of the heap may contain pointers into younger generations, and is supported by a refinement of the crossing map technique, to enable scanning of arbitrary cards.  p. r. wilson t. g. moher
overloading in preliminary ada  ada permits the overloading of enumeration literals, aggregates, subprograms and operators, i.e. the declaration of the same designator with different meanings in the same scope. this leads to difficulties during the semantic analysis of expressions and subprogram calls. for selecting the meaning not only the designator but also the types of its operands or parameters and the type of its result must be used. we show that the identification of expressions is possible in two passes, the first bottom-up, the second top- down.  guido persch georg winterstein manfred dausmann sophia drossopoulou
programming practices: analysis of ada source developed for the air force, army,and navy  in this paper, we discuss programming practices that have been applied to the development of ada source for the air force, army, and navy. we focus on practices shared by various developers producing ada software for different military applications.  we identified these practices by applying automated, hierarchical, ada- specific metrics frameworks to the analysis of segments of ada source for several military projects. in total, over 2 million text lines of ada source were analyzed, with the amount of code examined for any individual project ranging from a few thousand to more than a million lines.  our discussion includes the relationship of these practices to 1) the augmentation or attenuation of quality, 2) published guidelines and coding standards for ada, 3) programming practices for other von neumann languages, and 4) excerpts of analyzed ada source.  j. perkins
data locality and load balancing in cool  large-scale shared memory multiprocessors typically support a multilevel memory hierarchy consisting of per-processor caches, a local portion of shared memory, and remote shared memory. on such machines, the performance of parallel programs is often limited by the high latency of remote memory references. in this paper we explore how knowledge of the underlying memory hierarchy can be used to schedule computation and distribute data structures, and thereby improve data locality. our study is done in the context of cool, a concurrent object- oriented language developed at stanford. we develop abstractions for the programmer to supply optional information about the data reference patterns of the program. this information is used by the runtime system to distribute tasks and objects so that the tasks execute close (in the memory hierarchy) to the objects they reference.  we demonstrate the effectiveness of these techniques by applying them to several applications chosen from the splash parallel benchmark suite. our experience suggests that improving data locality can be simple through a combination of programmer abstractions and smart runtime scheduling.  rohit chandra anoop gupta john l. hennessy
tachyon common lisp: an efficient and portable implementation of cltl2  tachyon common lisp is an efficient and portable implementation of common lisp 2nd edition. the design objective of tachyon is to apply both advanced optimization technology developed for risc processors and lisp optimization techniques. the compiler generates very fast codes comparable to, and sometimes faster than the code generated by unix c compiler. comparing with the most widely used commercial common lisp, tachyon common lisp compiled code is 2 times faster and the interpreter is 6 times faster than the lisp in gabriel benchmark suit. tachyon common lisp is the fastest among the lisp systems known to the authors.  atsushi nagasaka yoshihiro shintani tanji ito hiroshi gomi junichi takahashi
an alternative view of polymorphism  we shall outline the traditional approaches to polymorphism, in the light of strachey's original work, and languages in the style of russell, and review the implications for programming language design of the developing interset amongst theoreticians in this subject.  it will be shown that the "parametric type-polymorphism" favoured by the majority of today's designers, is actually a very limited form of polymorphism, and we shall show how a much more general concept of polymorhism can be constructed by placing arbitrary constraints on abstract storage types.  we will then investigate ways of employing these "guarded cells", outlining several possible applications.  the essence of our proposal is that in any language in which there is an unfettered abstraction mechanism, and a sufficiently rich universe of discourse, including types which are properly manipulable values, many forms of polymorphism can be built as abstractions, and so need not be built directly into the fabric of that language. we interpret this to mean that polymorphism is not a major factor in programming language design, whereas we take the view that achieving maximum expressivity is crucial to a design.  we shall conclude by relating our work to that of theoreticians in the field, and showing the implications of our proposal for program verification.  david m. harland martyn w. szyplewski john b. wainwright
using tuple space communication in distributed object-oriented languages  when object-oriented languages are applied to distributed problem solving, the form of communication restricted to direct message sending is not flexible enough to naturally express complex interactions among the objects. we transformed the tuple space communication model[29] for better affinity with object-oriented computation, and integrated it as an alternative method of communication among the distributed objects. to avoid the danger of potential bottleneck, we formulated an algorithm that makes concurrent pattern matching activities within the tuple space possible.  satoshi matsuoka satoru kawai
automatic microcode generation for horizontally microprogrammed processors  a procedure is described which permits applications problems coded in a higher level language to be compiled to microcode for horizontally microprogrammed processors. an experimental language has been designed which is suitable for expressing computationally oriented problems for such processors in a distributed processing environment. source programs are compiled first to a machine independent intermediate language and then to a machine dependent form consisting of elementary microoperations, with optimizations performed during each step. the microoperations are then compacted into executable microinstructions for a specific target machine. the procedure has been implemented for experimental purposes and used to compile several different types of applications programs. the experimental results are presented with an interpretation and analysis, along with recommendations for future study.  robert j. sheraga john l. gieser
profiles in mass storage: a tale of two systems  the los alamos common file system (cfs) and the ncar mass storage system (mss) are file storage and file management systems that serve heterogeneous computing networks of supercomputers, general purpose computers, scientific workstations and personal computers. this paper details philosophical, implementation and performance aspects of the two mass storage systems. areas covered include the computing environment, the user interface, storage strategies and file movement strategies.  b. collins d. kitts m. devaney
beyond definition/use: architectural interconnection  large software systems require decompositional mechanisms in order to make them tractable. traditionally, mils and idls have played this role by providing notations based on definition/use bindings. in this paper we argue that current mil/idls based on definition/use have some serious drawbacks. a significant problem is that they fail to distinguish between "implementation" and "interaction" relationships between modules. we propose an alternative model in which components interact along well-defined lines of communication ---or connectors. connectors are defined as protocols that capture the expected patterns of communication between modules. we show how this leads to a scheme that is much more expressive for architectural relationships, that allows the formal definition of module interaction, and that supports its own form of automated checks and formal reasoning.  robert allen david garlan
chart drawing: a simplified tool for improving computer system documentation  this paper takes a different approach to overcoming this documentation problem. the approach taken incorporates within wylbur, an on- line program maintenance system, a set of documentation tools for allowing the system designers and programmers to automatically draw the necessary charts, and more importantly, to maintain these charts as the system and program designs evolve. the documentation tools, called chart drawing, utilize the facilities of wylbur and do not require any additional hardware or software capabilities. the use of the chart drawing system also provides standardization in chart presentation and the use of charting symbols.  kenneth a. hough larry r. hart
the design of the c++ booch components  this paper describes design issues encountered developing a reusable component library. the design applied encapsulation, inheritance, composition and type parameterization. the implementation uses various c++ mechanisms, including: virtual and static member functions, templates, and exceptions.  the resulting library contains about 500 components (mostly template classes and functions) and an optional utility for instantiating templates. the components provide variations of basic collection/container abstractions with various time and space complexities.  a key insight gained from this project: the design process centered on developing a "template for the templates" \--- designing a component framework and orderly process for generating the template classes.  grady booch michael vilot
cray pascal  this paper presents an investigation of the design decisions taken in the implementation of a compiler for pascal on the cray-1 computer. the structured nature of pascal statements and data structures is contrasted with the 'powerful computing engine' nature of the cray-1 hardware. the accepted views of pascal as a simple one-pass language and the cray-1 as a vector processor are laid aside in favour of a multi-pass approach, taking account of the machine's scalar capabilities. the project as a whole, aims to produce highly efficient run-time code for applications likely to be programmed in pascal. some statistics are given to indicate the nature of such applications.  n. h. madhavji i. r. wilson
using lifetime predictors to improve memory allocation performance  dynamic storage allocation is used heavily in many application areas including interpreters, simulators, optimizers, and translators. we describe research that can improve all aspects of the performance of dynamic storage allocation by predicting the lifetimes of short-lived objects when they are allocated. using five significant, allocation-intensive c programs, we show that a great fraction of all bytes allocated are short-lived (> 90% in all cases). furthermore, we describe an algorithm for liftetime prediction that accurately predicts the lifetimes of 42--99% of all objects allocated. we describe and simulate a storage allocator that takes adavantage of lifetime prediction of short-lived objects and show that it can significantly improve a program's memory overhead and reference locality, and even, at times, improve cpu performance as well.  david a. barrett benjamin g. zorn
matching-based incremental evaluators for hierarchical attribute grammar dialects  although attribute grammars have been very effective for defining individual modules of language translators, they have been rather ineffective for specifying large program-transformational systems. recently, several new attribute grammar "dialects" have been developed that support the modular specification of these systems by allowing modules, each described by an attribute grammar, to be composed to form a complete system. acceptance of these new hierarchical attribute grammar dialects requires the availability of efficient batch and incremental evaluators for hierarchical specifications. this paper addresses the problem of developing efficient incremental evaluators for hierarchical specifications. a matching- based approach is taken in order to exploit existing optimal change propagation algorithms for nonhierarchical attribute grammars. a sequence of four new matching algorithms is presented, each increasing the number of previously computed attribute values that are made available for reuse during the incremental update.  alan carle lori pollock
design and implementation of the interface to compiled languages in apl*plus ii  apl*plus ii is a second- generation 32-bit apl interpreter that runs under the ms dos operating system. a recent release has introduced two new system functions --- ona and omload \--- that enable apl to dynamically load and execute programs written in compiled languages such as c and fortran. these enhancements presented both design and implementation challenges. on the design side, it was necessary to make it as easy as possible for the apl programmer to integrate non-apl routines into applications. the implementation side required considerable technical creativity and invention, since the ms dos environment provides no built-in functions for dynamic loading and execution of programs.  james g. wheeler