ppxscal/embedding_network huggingface dataset:
Hardware support for object-oriented systems (abstract)
Authors: Mario Wolczko
Venue: ACM SIGPLAN OOPS Messenger (1993)

Hardware Support for Object-Oriented Systems Mario Wolczko, University of Manchester, England When the performance penalty of object-oriented systems is mentioned, a common response is to blame antiquated hardware designs for not supporting object-oriented languages as they deserve, To what extent can the performance gap between conventional languages and object-oriented languages be closed using hardware? What architectural changes benefit object-oriented systems, and by how much? There have been many attempts to make hardware that better supports object-oriented programming. This tutorial describes these systems, and the extent that they have succeeded or failed in their aims. These systems include SOAR, Rekursiv and MUSHROOM, as well as some features from mainstream architectures such as SPARC. Issues covered include: choice of instruction set, design of the memory system including caches and virtual memory hardware, scaleability, use of parallelism, and hardware/software trade-offs. A common misconception is that if something is implemented in hardware then it must be fast. One aspect of the tutorial is to show that there are limits to what hardware support can achieve. However, better hardware can reduce the cost of some language features, such as dynamic binding, and can make a system more scaleable.
Prototyping an intelligent agent through Wizard of Oz
Authors: David Maulsby, Saul Greenberg, Richard Mander
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

Turvy is a simulated prototype of an instructible agent. The user teaches it by demonstrating actions and pointing at or talking about relevant data. We formalized our assumptions about what could be implemented, then used the Wizard of Oz to flesh out a design and observe users' reactions as they taught several editing tasks. We found: a) all users invent a similar set of commands to teach the agent; b) users learn the agent's language by copying its speech; c) users teach simple tasks with ease and complex ones with reasonable effort; and d) agents cannot expect users to point to or identify critical features without prompting. In conducting this rather complex simulation, we learned some lessons about using the Wizard of Oz to prototype intelligent agents: a) design of the simulation benefits greatly from prior implementation experience; b) the agent's behavior and dialog capabilities must be based on formal models; c) studies of verbal discourse lead directly to an implementable system; d) the designer benefits greatly by becoming the Wizard; and e) qualitative data is more valuable for answering global concerns, while quantitative data validates accounts and answers fine-grained questions.
A natural semantics for lazy evaluation
Authors: John Launchbury
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

We define an operational semantics for lazy evaluation which provides an accurate model for sharing. The only computational structure we introduce is a set of bindings which corresponds closely to a heap. The semantics is set at a considerably higher level of abstraction than operational semantics for particular abstract machines, so is more suitable for a variety of proofs. Furthermore, because a heap is explicitly modelled, the semantics provides a suitable framework for studies about space behaviour of terms under lazy evaluation.
Trans-dichotomous algorithms for minimum spanning trees and shortest paths
Authors: Michael L. Fredman, Dan E. Willard
Venue: Journal of Computer and System Sciences (1994)

Two algorithms are presented: a linear time algorithm for the minimum spanning tree problem and an O(m + n log n/log log n) implementation of Dijkstra's shortest-path algorithm for a graph with n vertices and m edges. The second algorithm surpasses information theoretic limitations applicable to comparison-based algorithms. Both algorithms utilize new data structures that extend the fusion tree method.
Impossible Shaded Images
Authors: Berthold K. P. Horn, Richard S. Szeliski, Alan L. Yuille
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1993)

It is shown that shaded images that cannot have originated from a uniformly illuminated, smooth continuous surface with uniform albedo exist. The typical condition where this occurs is when a dark area (corresponding to a region of high gradient) is surrounded by a lighter region (with low gradient). For this to correspond to a real surface, it must be established that there is a local extremum or area of lower gradient inside the dark region. This, in turn, will show up as either a light area in the image or an orientation discontinuity in the surface (thus violating either intensity or smoothness constraints). The impossibility of a shaded image can be established by counting the number of extrema inside a region corresponding to an isolated surface patch.
One visual designer's perspective on INTERCHI'93
Authors: Andy Cargile
Venue: ACM SIGCHI Bulletin (1993)

INTERCHI'93---the first combined European INTERACT and American SIG-CHI conference---was for me very much like Amsterdam itself: extremely open-minded and eye-opening. I learned as much from the many colleagues I talked to as from the actual material itself, which seemed to be a fairly even combination of theory and practice, of researchers and practitioners, of the very detailed to the very broad in concept, and of the useful and the less useful. I spent a good deal of time talking with colleagues from various countries and found a wonderful diversity of perspective. In addition to becoming absorbed in the many sexy concepts and new ideas of the more future-oriented material and presentations, I had many substantial discussions with others responsible for making "vision" a reality in a practical way on a day to day basis.
Improving IPC by kernel design
Authors: Jochen Liedtke
Venue: Proceedings of the fourteenth ACM symposium on Operating systems principles (1994)

Inter-process communication (ipc) has to be fast and effective, otherwise programmers will not use remote procedure calls (RPC), multithreading and multitasking adequately. Thus ipc performance is vital for modern operating systems, especially mu;-kernel based ones. Surprisingly, most mu;-kernels exhibit poor ipc performance, typically requiring 100 mu;s for a short message transfer on a modern processor, running with 50 MHz clock rate.In contrast, we achieve 5 mu;s; a twentyfold improvement.This paper describes the methods and principles used, starting from the architectural design and going down to the coding level. There is no single trick to obtaining this high performance; rather, a synergetic approach in design and implementation on all levels is needed. The methods and their synergy are illustrated by applying them to a concrete example, the L3 mu;-kernel (an industrial-quality operating system in daily use at several hundred sites). The main ideas are to guide the complete kernel design by the ipc requirements, and to make heavy use of the concept of virtual address space inside the mu;-kernel itself.As the L3 experiment shows, significant performance gains are possible: compared with Mach, they range from a factor of 22 (8-byte messages) to 3 (4-Kbyte messages). Although hardware specific details influence both the design and implementation, these techniques are applicable to the whole class of conventional general purpose von Neumann processors supporting virtual addresses. Furthermore, the effort required is reasonably small, for example the dedicated parts of the mu;-kernel can be concentrated in a single medium sized module.
Software Process Evolution at the SEL
Authors: Victor Basili, Scott Green
Venue: IEEE Software (1994)

The Software Engineering Laboratory of the National Aeronautics and Space Administration's Goddard Space Flight Center has been adapting, analyzing, and evolving software processes for the last 18 years (1976-94). Their approach is based on the Quality Improvement Paradigm, which is used to evaluate process effects on both product and people. The authors explain this approach as it was applied to reduce defects in code. In examining and adapting reading techniques, we go through a systematic process of evaluating the candidate process and refining its implementation through lessons learned from previous experiments and studies. As a result of this continuous, evolutionary process, we determined that we could successfully apply key elements of the cleanroom development method in the SEL environment, especially for projects involving fewer than 50000 lines of code (all references to lines of code refer to developed, not delivered, lines of code). We saw indications of lower error rates, higher productivity, a more complete and consistent set of code comments, and a redistribution of developer effort. Although we have not seen similar reliability and cost gains for larger efforts, we continue to investigate the cleanroom method's effect on them.
The correctness of an optimized code generation
Authors: Torben Poort Lange
Venue: Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1993)

For a functional programming language with a lazy standard semantics, we define a strictness analysis by means of abstract interpretation. Using the information from the strictness analysis we are able to define a code generation which avoids delaying the evaluation of the argument to an application, provided that the corresponding function is strict. To show the correctness of the code generation, we will adopt the framework of logical relations and define a layer of predicates which finally will ensure that the code generation is correct with respect to the standard semantics.
Audition (abstract): a tool for visual interactive modeling
Authors: Andrew Drinnan, David Morton
Venue: Addendum to the proceedings on Object-oriented programming systems, languages, and applications (Addendum) (1992)

This demonstration presents Audition, an object-oriented language and environment designed to allow the easy creation of visual and interactive programs. It uses a metaphor of Performers and Stages, as first inspired by the XEROX Pam Rehearsal World project. Performers are the main interaction units. They are visible and mouse or message activated; sample types include DisplayPerformers, Turtles, Graphs, and Gauges. Performers are grouped on Stages; stages maintain local name spaces so that Performers can be named and intercommunicate using their local names. While Performers are members of a class, they may also be specialised through the addition of instance-specific behaviour and structure; this may also be inherited from other performers. Just as inheritance models is-kind-of relationships, performers collected on a stage visibly and logically model is-part-of relationships, in a more flexible way than instance variables. An application is usually just a specialised stage and its specialised performers. The performer-stage paradigm gives rise to models that are at once well factored across their participating performers and yet are fully encapsulated within a stage. Audition is a threaded interpreted language implemented in itself. At present we are using Audition to investigate planning aids and simulations for industrial situations.
Inductive logic programming: derivations, successes and shortcomings
Authors: Stephen Muggleton
Venue: ACM SIGART Bulletin (1994)

Inductive Logic Programming (ILP) is a research area which investigates the construction of first-order definite clause theories from examples and background knowledge. ILP systems have been applied successfully in a number of real-world domains. These include the learning of structure-activity rules for drug design, finite-element mesh design rules, rules for primary-secondary prediction of protein structure and fault diagnosis rules for satellites. There is a well established tradition of learning-in-the-limit results in ILP. Recently some results within Valiant's PAC-learning framework have also been demonstrated for ILP systems. In this paper it is argued that algorithms can be directly derived from the formal specifications of ILP. This provides a common basis for Inverse Resolution, Explanation-Based Learning, Abduction and Relative Least General Generalisation. A new general-purpose, efficient approach to predicate invention is demonstrated. ILP is underconstrained by its logical specification. Therefore a brief overview of extra-logical constraints used in ILP systems is given. Some present limitations and research directions for the field are identified.
Interactive Visualization of Earth and Space Science Computations
Authors: William L. Hibbard, Brian E. Paul, David A. Santek, Charles R. Dyer, André L. Battaiola, Marie-Françoise Voidrot-Martinez
Venue: Computer (1994)

Scientists often view computer algorithms as risk-filled black boxes. The barrier between scientists and their computations can be bridged by techniques that make the internal workings of algorithms visible and that allow scientists to experiment with their computations. We describe two interactive systems developed at the University of Wisconsin-Madison Space Science and Engineering Center (SSEC) that provide these capabilities to Earth and space scientists. These visualization packages help scientists see the internal workings of their algorithms and thus understand their computations.
Applications of inductive logic programming
Authors: Ivan Bratko, Ross King
Venue: ACM SIGART Bulletin (1994)

Some applications of Inductive Logic Programming (ILP) are presented. Those applications are chosen that specifically benefit from relational descriptions generated by ILP programs, and from ILP's ability to accommodate background knowledge. Applications included are: drug design, predicting the secondary structure of proteins, and design of finite-element meshes. Some other applications are briefly described. The practical advantages and disadvantages of ILP learning are discussed.
Implementation of a portable nested data-parallel language
Authors: Guy E. Blelloch, Jonathan C. Hardwick, Siddhartha Chatterjee, Jay Sipelstein, Marco Zagha
Venue: Proceedings of the fourth ACM SIGPLAN symposium on Principles and practice of parallel programming (1993)

This paper gives an overview of the implementation of NESL, a portable nested data-parallel language. This language and its implementation are the first to fully support nested data structures as well as nested data-parallel function calls. These features allow the concise description of parallel algorithms on irregular data, such as sparse matrices and graphs. In addition, they maintain the advantages of data-parallel languages: a simple programming model and portability. The current NESL implementation is based on an intermediate language called VCODE and a library of vector routines called CVL. It runs on the Connection Machine CM-2, the Cray Y-MP C90, and serial machines. We compare initial benchmark results of NESL with those of machine-specific code on these machines for three algorithms: least-squares line-fitting, median finding, and a sparse-matrix vector product. These results show that NESL's performance is competitive with that of machine-specific codes for regular dense data, and is often superior for irregular data.
Worst-case bounds for subadditive geometric graphs
Authors: Marshall Bern, David Eppstein
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

We consider graphs such as the minimum spanning tree, minimum Steiner tree, minimum matching, and traveling salesman tour for n points in the d-dimensional unit cube. For each of these graphs, we show that the worst-case sum of the dth powers of edge lengths is O(log n). This is a consequence of a general &ldquo;gap theorem&rdquo;: for any subadditive geometric graph, either the worst-case sum of edge lengths is O(nd&ndash;1)/d) and the sum of dth powers is O(log n), or the sum of edge lengths is &OHgr;(n). We look more closely at some specific graphs: the worst-case sum of d powers is O(1) for minimum matching, but &OHgr;(log n) for traveling salesman tour, which answers a question of Snyder and Steele.
Adoption of OIS by four groups of office workers: an analysis from the perspective of innovation diffusion theory
Authors: Jaak Jurison
Venue: Proceedings of the 1993 conference on Computer personnel research (1993)

This paper analyzes the adoption of six different applications of an integrated office information system (OIS) by four categories of office workers: managers, project engineers, professionals, and secretaries over a three-year time period. The data show a substantial variance across time, workgroups, and applications, in terms of adoption rates and perceptions of technology. The results suggest a model for predicting technology adoption in the long run, based on initial adoption rates and perceptions of technology.
Causal controversy at Le Mont St.-Michel
Authors: Robbert van Renesse
Venue: ACM SIGOPS Operating Systems Review (1993)

As usual, the SIGOPS workshop provided a great platform for interesting discussion. Among other things, a controversy arose around the usefulness of causal ordering in a distributed system. In this paper, I explain causality in non-technical terms, and enumerate some of the most prevalent misconceptions that surrounded causality. Next I present some important examples where causal delivery is a necessary and sufficient ordering of events.
The object-oriented brewery: a comparison of two object-oriented development methods
Authors: Robert C. Sharble, Samuel S. Cohen
Venue: ACM SIGSOFT Software Engineering Notes (1993)

Interest in object-oriented methods has been rapidly increasing, as software developers and project managers try to reduce escalating development and maintenance costs. There is an increasing need to determine if there are differences in effectiveness between various methods of object-oriented software development, and whether techniques from more successful methods can be extracted and applied to improve other methods.This paper reports on research to compare the effectiveness of two methods for the development of object-oriented software. These methods are representative of two dominant approaches in the industry. The methods are the responsibility-driven method and a data-driven method that was developed at The Boeing Company and taught in a course available to the public.Each of the methods was used to develop a model of the same example system. A suite of metrics suitable for object-oriented software was used to collect data for each model, and the data was analyzed to identify differences.The model developed with the responsibility-driven method was found to be much less complex, and specifically to have much less coupling between objects and much more cohesion within an object.
Multiple comparisons with the best for steady-state simulation
Authors: Mingjian Yuan, Barry L. Nelson
Venue: ACM Transactions on Modeling and Computer Simulation (TOMACS) (1993)

Multiple-comparison procedures are useful for comparing the performance of competing systems via simulation. In this paper we extend a particular multiple-comparison procedure, multiple comparisons with the best, to steady-state simulation by using an autoregressive-output-analysis method.
Knowledge, probability, and adversaries
Authors: Joseph Y. Halpern, Mark R. Tuttle
Venue: Journal of the ACM (JACM) (1993)

What should it mean for an agent to know or believe an assertion is true with probability 9.99? Different papers [2, 6, 15] give different answers, choosing to use quite different probability spaces when computing the probability that an agent assigns to an event. We show that each choice can be understood in terms of a betting game. This betting game itself can be understood in terms of three types of adversaries influencing three different aspects of the game. The first selects the outcome of all nondeterministic choices in the system; the second represents the knowledge of the agent's opponent in the betting game (this is the key place the papers mentioned above differ); and the third is needed in asynchronous systems to choose the time the bet is placed. We illustrate the need for considering all three types of adversaries with a number of examples. Given a class of adversaries, we show how to assign probability spaces to agents in a way most appropriate for that class, where &ldquo;most appropriate&rdquo; is made precise in terms of this betting game. We conclude by showing how different assignments of probability spaces (corresponding to different opponents) yield different levels of guarantees in probabilistic coordinated attack.
Parallel logic programming systems
Authors: Jacques Chassin de Kergommeaux, Philippe Codognet
Venue: ACM Computing Surveys (CSUR) (1994)

Parallelizing logic programming has attracted much interest in the research community, because of the intrinsic OR- and AND-parallelisms of logic programs. One research stream aims at transparent exploitation of parallelism in existing logic programming languages such as Prolog, while the family of concurrent logic languages develops language constructs allowing programmers to express the concurrency&mdash;that is, the communication and synchronization between parallel processes&mdash;within their algorithms. This article concentrates mainly on transparent exploitation of parallelism and surveys the most mature solutions to the problems to be solved in order to obtain efficient implementations. These solutions have been implemented, and the most efficient parallel logic programming systems reach effective speedups over state-of-the-art sequential Prolog implementations. The article also addresses current and prospective research issues in extending the applicability and the efficiency of existing systems, such as models merging the transparent parallelism and the concurrent logic languages approaches, combination of constraint logic programming with parallelism, and use of highly parallel architectures.