ppxscal/embedding_network huggingface dataset:
Object oriented database using frames in second generation APL
Authors: Panagiotis Pantziarka
Venue: ACM SIGAPL APL Quote Quad (1990)

The appeal of Object Oriented systems and methodologies is that they provide conceptually simple and powerful tools to represent the real-world. The essential elements of object orientation include: information hiding, classes, dynamic instantiation of objects, methods and the inheritance of properties by objects. Frames are a way to combine both data and procedures to represent knowledge. This paper describes a frame representation system that is used to create a simple object oriented database. The frame structures are described and it is shown that they can be represented as nested arrays. The inheritance mechanisms are detailed and functions developed to handle the frames. Finally a proposal is made for the further development of frame structured systems in APL.
VISAR: a system for inference and navigation of hypertext
Authors: P. Clitherow, D. Riecken, M. Muller
Venue: Proceedings of the second annual ACM conference on Hypertext (1989)

Hypertext systems have traditionally been constructed by hand. This process can stand improvement in several aspects: it is laborious; requires a human to understand the text and infer all the relationships between the concepts/topics; and while the resulting hypertext may be traversed by a reader in an arbitrary fashion, s/he may still find it difficult to understand the concepts as expressed by the builder of the hypertext. We present a knowledge-intensive assistant for building hypertext fragments from a knowledge base customised both explicitly and implicitly by a user. Such a presentation may clarify relationships between concepts that were present implicitly in multiple sources of information. In the domain of an intelligent information retrieval system, we show how such an assistant may render customised views of knowledge extracted in a manageable form. While the presentation medium of the original system is graphic, we also speculate that presentation of the information in alternative hypermedia appears to be straightforward.
Importance Sampling for Ising Computers Using One-Dimensional Cellular Automata
Authors: P. D. Hortensius, H. C. Card, R. D. McLeod, W. Pries
Venue: IEEE Transactions on Computers (1989)

The authors demonstrate that one-dimensional (1-D) cellular automata (CA) form the basis of efficient VLSI architectures for computations involved in the Monte Carlo simulation of the two-dimensional (2-D) Ising model. It is shown that the time-intensive task of importance sampling the Ising configurations is expedited by the inherent parallelism in this approach. The CA architecture further provides a spatially distributed set of pseudorandom numbers that are required in the local nondeterministic decisions at the various sites in the array. The novel approach taken to random-number generation can also be applied to a variety of other highly nondeterministic algorithms from many fields, such as computational geometry, pattern recognition, and artificial intelligence.
A generalized model for a relational temporal database
Authors: Shashi K. Gadia
Venue: ACM SIGMOD Record (1988)

We propose a generalized relational model for a temporal database which allows time stamping with respect to a Boolean algebra of multidimensional time stamps. The interplay between the various temporal dimensions is symmetric. As an application, a two dimensional model which allows objects with real world and transaction oriented time stamps is discussed. The two dimensional model can be used to query the past states of the database. It can also be used to give a precise classification of the errors and updates in a database, and is a promising approach for querying these errors and updates.
Planar and spherical retarding-field spectrometers for electron-beam testing: Evaluation and comparison
Authors: S. Görlich, P. Keβler, E. Plies
Venue: Microelectronic Engineering (1988)

Two types of retarding-field spectrometers for electron-beam testing are studied: the well-known one with a planar retarding field and a new one with a spherical retarding field and an improved deflection unit. Both spectrometers are of simple design and fit below the final objective lens of the electron-beam tester. The characteristics of these spectrometers, i.e. slope of the S-curve, linearity, transmission, signal-to-noise ratio, optimal operating point are investigated and compared. Special attention was paid to the local field effect. The superiority of the spherical retarding-field spectrometer is demonstrated.
Self-assessment procedure XIX
Authors: R. W. Bickel
Venue: Communications of the ACM (1989)

A self-assessment procedure on the application of copyright law to computer programs
Determining sector visibility of a polygon
Authors: B. Bhattacharya, D. Kirkpatrick, G. Toussaint
Venue: Proceedings of the fifth annual symposium on Computational geometry (1989)

We consider a generalization of notions of external visibility of simple polygons, namely weak external visibility, weak external visibility from a line and monotonicity, that we call sector visibility. Informally, sector visibility addresses the question of external visibility along rays (or sight lines) whose angles are restricted to a sector (wedge) of specified width &sgr;. This provides an interesting measure of the degree of external visibility of a polygon. Our framework also permits a unification and extension of a number of previously unrelated results. Finally, our results uncover a curious complexity discontinuity in this family of problems; algorithms are &THgr;(n) when &sgr; &le; &pgr; or &sgr; = 2&pgr;, but require &OHgr;(n log n) time (at least), when &pgr; < &sgr; < 2&pgr;.
ELF: a tool for automatic synthesis of custom physical CAD software
Authors: E. E. Setliff, R. A. Rutenbar
Venue: Proceedings of the 26th ACM/IEEE Design Automation Conference (1989)

This paper describes how program synthesis techniques can be applied to the generation of technology-sensitive VLSI design tools. We present results from ELF, a synthesis tool for wire-routing software. The ELF synthesis architecture has three key features. First, a very high level language, lacking data structure implementation specifications is used to describe algorithm design styles. Second, routing domain knowledge and generic program synthesis knowledge are used to guide search among candidate design styles for all necessary component algorithms, and to deduce compatible data structure implementations for these components. Third, code generation is used to transform the resulting abstract descriptions of selected algorithms and data structures into final, executable code. Code generation is an incremental, stepwise refinement process. We present experimental results from several correct, fully-functional routers synthesized by ELF from varying high-level specifications.
Parse tree annotations
Authors: James J. Purtilo, John R. Callahan
Venue: Communications of the ACM (1989)

A technique for associating rewrite rules with productions so that many high-level transformations of a source file can be generated easily is described. While eclipsed in power by other editing and compiler generation systems supporting management of both synthesized and inherited attributes, this approach is especially simple to employ and is sufficient in power to deal with a wide class of problems arising from practical applications.
An LR substring parser for noncorrecting syntax error recovery
Authors: G. V. Cormack
Venue: ACM SIGPLAN Notices (1989)

For a context-free grammar G, a construction is given to produce an LR parser that recognizes any substring of the language generated by G. The construction yields a conflict-free (deterministic) parser for the bounded context class of grammars (Floyd, 1964). The same construction yields either a left-to-right or right-to-left substring parser, as required to implement Non-correcting Syntax Error Recovery as proposed by Richter (1985). Experience in constructing a substring parser for Pascal is described.
Computer-aided software engineering: present status and future directions
Authors: M. Chen, J. F. Nunamaker,  Jr., E. S. Weber
Venue: ACM SIGMIS Database (1989)

The authors examine the current status of Computer-Aided Software Engineering (CASE) and discuss the benefits it promises to deliver in the future. First, an extended life-cycle model is presented. Next, basic functions of a CASE environment and the authors' classification scheme for analyzing CASE products are discussed. Following this, the authors draw implications from the results of empirical CASE studies and propose strategies for adapting CASE technologies. The paper concludes with a discussion of future research and development directions. These include the use of CASE in integrating organization and information systems modeling, in adding value to Executive Information Systems (EIS), and in fostering user-developer collaboration.
Toward embedded controllers for real-time applications of artificial intelligence
Authors: Jean-Claude Heudin, Jean-Pierre Courrier, Christophe Metivier
Venue: Proceedings of the 2nd international conference on Industrial and engineering applications of artificial intelligence and expert systems - Volume 1 (1989)

Process control is one of the priviledged topics of Computer Science applications. The fast evolution of high technologies permits to deal progressively with more complex domains. On the other hand, control theory seems to be inadequate to meet the challenge posed by a dramatic increase in systems complexity. In this paper, we will first split the complexity in a composite notion, and propose a solution to face complexity in process control applications: a Symbolic-dedicated processor.
Design of LMT: a prolog-based machine translation system
Authors: Michael C. McCord
Venue: Computational Linguistics (1989)

LMT (logic-based machine translation) is an experimental English-to-German MT system, being developed in the framework of logic programming. The English analysis uses a logic grammar formalism, Modular Logic Grammar, which allows logic grammars to be more compact, and which has a modular treatment of syntax, lexicon, and semantics. The English grammar is written independently of the task of translation. LMT uses a syntax transfer method for translation, although the English syntactic analysis trees contain some results of semantic choices and show deep grammatical relations. Semantic type checking with Prolog inference is done during analysis and transfer. The transfer algorithm uses logical variables and unification to good advantage; transfer works in a simple left-to-right, top-down way. After transfer, the German syntactic generation component produces a surface structure tree by application of a system of tree transformations. These transformations use an augmentation of Prolog pattern matching. LMT has a single lexicon, containing both source and transfer information, as well as some idiosyncratic target morphological information. There is a compact external format for this lexicon, with a lexical preprocessing system that applies defaults and compiles it into an internal format convenient for the syntactic components. During lexical preprocessing, English morphological analysis can be coupled with rules that synthesize new transfer entries.
LU decomposition of banded matrices and the solution of linear systems on hypercubes
Authors: D. W. Walker, T. Aldcroft, A. Cisneros, G. C. Fox, W. Furmanski
Venue: Proceedings of the third conference on Hypercube concurrent computers and applications - Volume 2 (1989)

We describe the solution of linear systems of equations, Ax = b, on distributed-memory concurrent computers whose interconnect topology contains a two-dimensional mesh. A is assumed to be an M&times;M banded matrix. The problem is generalized to the case in which there are nb distinct right-hand sides, b, and can thus be expressed as AX = B, where X and B are both M&times;nb matrices. The solution is obtained by the LU decomposition method which proceeds in three stages: (1) LU decomposition of the matrix A, (2) forward reduction, (3) back substitution. Since the matrix A is banded a simple rectangular subblock decomposition of the matrices A, X, and B over the nodes of the ensemble results in excessive load imbalance. A scattered decomposition is therefore used to decompose the data. The sequential and concurrent algorithms are described in detail, and models of the performance of the concurrent algorithm are presented for each of the three stages of the algorithm. In order to ensure numerical stability the algorithm is extended to include partial pivoting. Performance models for the pivoting case are also given. Results from a 128-node Caltech/JPL Mark II hypercube are presented, and the performance models are found to be a good agreement with these data. Indexing overhead was found to contribute significantly to the total concurrent overhead.
Testing the Completeness of Specifications
Authors: Pankaj Jalote
Venue: IEEE Transactions on Software Engineering (1989)

A system is described that tests for the completeness of axiomatic specifications of abstract data types. For testing, the system generates a set of test cases and an implementation of the data type from the specifications. The generated implementation is such that if the specifications are not complete, the implementation is not complete, and the behavior of all of the sequences of valid operations on the data type is not defined. This implementation is tested with the generated test cases to detect the incompleteness of specifications. The system is implemented on a VAX system running Unix.
The Xerox Star: A Retrospective
Authors: Jeff Johnson, Teresa L. Roberts, William Verplank, David C. Smith, Charles H. Irby, Marian Beard, Kevin Mackey
Venue: Computer (1989)

A description is given of the Xerox 8010 Star information system, which was designed as an office automation system. The idea was that professionals in a business or organization would have workstations on their desks and would use them to produce, retrieve, distribute, and organize documentation, presentations, memos, and reports. All of the workstations in an organization would be connected via Ethernet and would share access to file servers, printers, etc. The distinctive features of Star are identified, and changes to the original design are examined. A history of Star development is included. Some lessons learned from designing Star are related.
On-line tutorials: What kind of inference leads to the most effective learning?
Authors: J. B. Black, J. S. Bechtold, M. Mitrani, J. M. Carroll
Venue: ACM SIGCHI Bulletin (1989)

This paper presents an empirical study comparing the effectiveness of four different versions of an on-line database tutorial, each of which calls upon the student to perform a different kind of inference. The general-to-specific version presents instructions in the form of general rules, from which the students expected to infer how to apply the rule in the give context. The explanation-to-specific version supplies information about the functional organization of the database program in addition to general rules. The specific-to-specific condition gives an example of the use of a command; the student must infer how to apply the command in a slightly different context. The control version gives explicit instructions. The best performance on a post-test consisting of realistic tasks was obtained from the general-to-specific and explanation-to-specific conditions.
A common schema for dynamic programming and branch and bound algorithms
Authors: Paul Helman
Venue: Journal of the ACM (JACM) (1989)

A new model for dynamic programming and branch and bound algorithms is presented. The model views these algorithms as utilizing computationally feasible dominance relations to infer the orderings of application objects, thereby implicitly enumerating a finite solution space. The formalism is broad enough to apply the computational strategies of dynamic programming and branch and bound to problems with nonassociative objects, and can model both oblivious and nonoblivious algorithms, as well as parallel algorithms. The model is used to classify computations based, in part, on the types of computationally feasible dominances that they employ. It is demonstrated that the model is computationally precise enough to support the derivation of lower bounds on the number of operations required to solve various types of problems.
Demonic memory for process histories
Authors: P. R. Wilson, T. G. Moher
Venue: ACM SIGPLAN Notices (1989)

Demonic memory is a form of reconstructive memory for process histories. As a process executes, its states are regularly checkpointed, generating a history of the process at low time resolution. Following the initial generation, any prior state of the process can be reconstructed by starting from a checkpointed state and re-executing the process up through the desired state, thereby exploiting the redundancy between the states of a process and the description of that process (i.e., a computer program). The reconstruction of states is automatic and transparent. The history of a process may be examined as though it were a large two-dimensional array, or address space-time, with a normal address space as one axis and steps of process time as the other. An attempt to examine a state that is not physically stored triggers a &ldquo;demon&rdquo; which reconstructs that memory state before access is allowed. Regeneration requires an exact description of the original execution of the process. If the original process execution depends on non-deterministic events (e.g., user input), these events are recorded in an exception list, and are replayed at the proper points during re-execution. While more efficient than explicitly storing all state changes, such a checkpointing system is still prohibitively expensive for many applications; each copy (or snapshot) of the system's state may be very large, and many snapshots may be required. Demonic memory saves both space and time by using a virtual copy mechanism. (Virtual copies share unchanging data with the objects that they are copies of, only storing differences from a prototype or original [MiBK86].) In demonic memory, the snapshot at each checkpoint is a virtual copy of the preceding checkpoint's snapshot. Hence it is called a virtual snapshot. In order to make the virtual snapshot mechanism efficient, state information is initially saved in relatively large units of space and time, on the order of pages and seconds, with single-word/single-step regeneration undertaken only as needed. This permits the costs of indexing and lookup operations to be amortized over many locations.
Development and documentation of computer programs in undergraduate computer science programs
Authors: Linda L. Deneen, Keith R. Pierce
Venue: ACM SIGCSE Bulletin (1988)

Until recently, introductory programming classes in the Department of Computer Science, University of Minnesota, Duluth, concentrated on writing code. Not until the junior or senior year were students required to adhere to basic principles of software engineering. As might be expected, by their junior year students' bad habits, like coding while designing or inserting comments last, were firmly entrenched and difficult, if not impossible, to undo. The solution, it seemed to us, was to prevent bad habits right from the start. Consequently, we developed guidelines for designing and documenting the entire programming effort, from problem statement to post mortem. The guidelines include such steps as: algorithm development in high-level pseudocode with stepwise refinements, structure diagrams with data flow, detailed test descriptions, testing results, and a description of all known bugs. For a given assignment, the instructor chooses the steps to be completed, allowing for flexibility and appropriateness in the design and documentation. Results have been extremely positive. Students start earlier and produce better organized solutions. More students solve the problems correctly. Most importantly, students develop design and documentation skills in the freshman year that carry through and are improved over their four-year stay. Because of this initial success, our department has adopted these guidelines uniformly in all programming classes. In this paper we will describe our guidelines and give some details of their use. We will discuss the philosophy that led us to develop these guidelines and present our observations of their effectiveness.
Module Allocation of Real-Time Applications to Distributed Systems
Authors: Catherine E. Houstis
Venue: IEEE Transactions on Software Engineering (1990)

An allocation model for mapping a real-time application to certain k-processor multiprocessor systems is developed and analyzed. Its objective is minimizing the total processing time of the application by exploiting the parallelism of the application-architecture pair. The model is formulated in terms of the performance characteristics of the system and the resource requirements of the computation involved. Experience with the model suggests that it can be used effectively for the performance evaluation of application-distributed system pairss.
&ldquo;Topologies&rdquo;&mdash;distributed objects on multicomputers
Authors: Karsten Schwan, Win Bo
Venue: ACM Transactions on Computer Systems (TOCS) (1990)

Application programs written for large-scale multicomputers with interconnection structures known to the programmer (e.g., hypercubes or meshes) use complex communication structures for connecting the applications' parallel tasks. Such structures implement a wide variety of functions, including the exchange of data or control information relevant to the task computations and/or the communications required for task synchronization, message forwarding/filtering under program control, and so on. Topology is a programming and operating system construct that allows programmers to describe and efficiently implement such functionality as distributed objects with well-defined operational interfaces. As with abstract data types, topologies may be reused by any application desiring their functionality. However, in contrast to other research in parallel or distributed object-based operating systems, internally, a topology may be an entirely distributed implementation of the object's functionality, consisting of a communication graph and type-specific computations, which are triggered by messages traversing the graph. Sample computations may perform additions or minimizations of the values traversing a topology, thereby computing a global sum or minimum. Similarly, computations may concatenate or filter messages in order to implement program monitoring, I/O, file storage, or virtual terminal services. Topologies are implemented as an extension of the Intel iPSC hypercube's operating system kernel and have been used with several, large-scale parallel application programs.