ppxscal/embedding_network huggingface dataset:
Where VHDL fits within the CAD environment
Authors: J. Hines
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper discusses the relationship of the VHSIC Hardware Description Language (VHDL), the Electronic Design Interchange Format (EDIF), and the Initial Graphics Exchange Specification (IGES) in a Computer Aided Design (CAD) environment.
The design of &not; 1NF relational databases into nested normal form
Authors: Mark A. Roth, Henry F. Korth
Venue: ACM SIGMOD Record (1987)

We develop new algorithms for the design of non first normal form relational databases that are in nested normal form. Previously, a set of given multivalued dependencies and those multivalued dependencies implied by given functional dependencies were used to obtain a nested normal form decomposition of a scheme. This method ignored the semantic distinction between functional and multivalued dependencies and utilized only full multivalued dependencies in the design process. We propose new algorithms which take advantage of this distinction, and use embedded multivalued dependencies to enhance the decomposition. This results in further elimination of redundancy due to functional dependencies in nested normal form designs.
Constrained Delaunay triangulations
Authors: L. P. Chew
Venue: Proceedings of the third annual symposium on Computational geometry (1987)

Given a set of n vertices in the plane together with a set of noncrossing edges, the constrained Delaunay triangulation (CDT) is the triangulation of the vertices with the following properties: (1) the prespecified edges are included in the triangulation, and (2) it is as close as possible to the Delaunay triangulation. We show that the CDT can be built in optimal &Ogr;(n log n) time using a divide-and-conquer technique. This matches the time required to build an arbitrary (unconstrained) Delaunay triangulation and the time required to build an arbitrary constrained (nonDelaunay) triangulation. CDTs, because of their relationship with Delaunay triangulations, have a number of properties that should make them useful for the finite-element method. Applications also include motion planning in the presence of polygonal obstacles in the plane and constrained Euclidean minimum spanning trees, spanning trees subject to the restriction that some edges are prespecified.
The DUNIX distributed operating system
Authors: Ami Litman
Venue: ACM SIGOPS Operating Systems Review (1988)

DUNIX is an operating system that integrates several computers, connected by a packet switching network, into a single UNIX machine. As far as the users and their software can tell, the system is a single large computer running UNIX. This illusion is created by cooperation of the computers' kernels. The kernels' mode of operation is novel. The software is procedure call oriented. The code that implements a specific system call (e.g., open) does not know whether the object in question (the file) is local or remote. That uniformity makes the kernel small and easy to maintain. The system behaves gracefully under subcomponents' failures. Users which do not have objects (files, processes, tty, etc) in a given computer are not disturbed when that computer crashes. The system administrator may switch a disk from a "dead" computer to a healthy one, and remount the disk under the original path-name. After the switch, users may access files in that disk via the same old names. DUNIX exhibits surprisingly high performance. For a compilation benchmark, DUNIX is faster than 4.2 BSD, even if in the DUNIX case all the files in question are remote. Currently, in Bell Communications Research we have an installation running DUNIX over five DEC VAX computers connected by an Ethernet. This installation speaks TCP/IP and is on the Internet network.
Flex: A High-Level Language for Specifying Customized Microprocessors
Authors: Douglas E. Comer, Narain H. Gehani
Venue: IEEE Transactions on Software Engineering (1985)

Researchers at Bell Labs have recently developed a silicon compiler, named Plex, that automatically generates VLSI layouts of high performance and area efficient microprocessors. Plex takes as input a specification of the function to be executed and generates a complete mask-level layout of a customized microprocessor to execute that function. The Plex microprocessor interacts with the external world, via input and output wires, and interrupts. The dedicated function performed by a Plex microprocessor typically involves real-time handling of inputs and interrupts-and the real-time generation of output signals.
Deterministic and stochastic modeling of parallel garbage collection: towards real-time criteria
Authors: O. Ridoux
Venue: Proceedings of the 14th annual international symposium on Computer architecture (1987)

The study of garbage collection for a logic programming language machine has exhibited fundamental differences with the more popular functional programming garbage collection. These differences yield behaviours that cannot be observed with classical models. We give two new models, (one is determistic and the other stochastic) which take into account these behaviours. We argue that the stochastic model is also suitable for more classical garbage collector, and that it overcomes deterministic models for the study of the real-time property for parallel garbage collector. Finally, we argue that the methodology used to build and solve the stochastic model can be applied to the stochastic modeling of other systems.
Acquisition of knowledge from data
Authors: G C M Wiederhold, M Walker, R Blum, S Downs
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

The work described here addresses two problems: information overload of database users, and knowledge acquisition for use in Al systems. We have implemented programs that use artificial intelligence techniques to prepare high-level, intelligent summaries of databases, and that use empirical databases in turn, in combination with statistical and Al methods, to generate new domain knowledge base. Both programs are examples of the aquisition of knowledge from data: the Summarization Module fuses large amounts of data succinctly, the Discovery Module extracts new knowledge present implicitly in data. We describe the implementation of our programs and outline planned extensions which combine both approaches. This work is distinguished from current knowledge engineering approaches in that we prime the system with expert knowledge, and then use factual data to learn more about the domain.
CHESHIRE: an object-oriented integration of VLSI CAD tools
Authors: L.-P. Demers, P. Jacques, S. Fauvel, E. Cerny
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

We present an approach to the integration of VLSI CAD tools through the uniformization of interactions with design cells at both the user and the program levels. The integration model is based on the concept of objects applied to circuit cells. User interactions are achieved through a desk-top-like graphics interface. Regrouping of related or equivalent cell-objects into tissues represented by a generic cell helps with their management. Late binding of specific version cells then encourages exploration of the design space. To test the integration concept, a data base and tools for symbolic layout were developed.
The Interrogator: Protocol Secuity Analysis
Authors: Jonathan K. Millen, Sidney C. Clark, Sheryl B. Freeman
Venue: IEEE Transactions on Software Engineering (1987)

The Interrogator is a Prolog program that searches for security vulnerabilities in network protocols for automatic cryptographic key distribution. Given a formal specification of the protocol, it looks for message modification attacks that defeat the protocol objective. It is still under developement, but is has been able to rediscover a known vulnerability in a published protocol. It is implemented in LM-Prolog on a Lisp Machine, with a graphical user interface.
The influence of BASIC on performance in introductory computer science courses using Pascal
Authors: Linda McGee, Gerasimoula Polychronopoulos, Carroll Wilson
Venue: ACM SIGCSE Bulletin (1987)

Results are presented testing the hypothesis that knowledge of BASIC has a positive effect on performance in introductory Pascal courses. During the Fall 1985 term, two computer science courses were surveyed at the University of Illinois, and students' final course grades were analyzed based on their programming background. In CS 121 surveys were given out in both lecture sections, with students being expected to mail surveys back on their own. The largest lecture section of five was surveyed for CS 105. The surveys were distributed to students and collected at the end of class. The data for the course for computer science majors (CS 121, which is a requirement) show no grade differences based on prior background. The data for the course for non-majors (CS 105, which is only required for finance majors and is an alternate choice for a few others) show significantly higher grades for students with background in BASIC in comparison to students with no programming background.
Fragmentation: a technique for efficient query processing
Authors: Giovanni Maria Sacco
Venue: ACM Transactions on Database Systems (TODS) (1986)

A &ldquo;divide and conquer&rdquo; strategy to compute natural joins by sequential scans on unordered relations is described. This strategy is shown to always he better than merging SCBIIS when both relations must he sorted before joining, and generally better in practical cases when only the largest relation mutt be sorted.
A specification language for direct-manipulation user interfaces
Authors: Robert J. K. Jacob
Venue: ACM Transactions on Graphics (TOG) (1986)

A direct-manipulation user interface presents a set of visual representations on a display and a repertoire of manipulations that can be performed on any of them. Such representations might include screen buttons, scroll bars, spreadsheet cells, or flowchart boxes. Interaction techniques of this kind were first seen in interactive graphics systems; they are now proving effective in user interfaces for applications that are not inherently graphical. Although they are often easy to learn and use, these interfaces are also typically difficult to specify and program clearly. Examination of direct-manipulation interfaces reveals that they have a coroutine-like structure and, despite their surface appearance, a peculiar, highly moded dialogue. This paper introduces a specification technique for direct-manipulation interfaces based on these observations. In it, each locus of dialogue is described as a separate object with a single-thread state diagram, which can be suspended and resumed, but retains state. The objects are then combined to define the overall user interface as a set of coroutines, rather than inappropriately as a single highly regular state transition diagram. An inheritance mechanism for the interaction objects is provided to avoid repetitiveness in the specifications. A prototype implementation of a user-interface management system based on this approach is described, and example specifications are given.
The Source of Authority for Commercial Access Control
Authors: Jonathan D. Moffett, Morris S. Sloman
Venue: Computer (1988)

The authors discuss the need for protection in commercial organizations, and the way in which control principles have met this need, despite having evolved before computer systems came into use. The basis for these principles is the concept of authority and how it is designated within an organization. A simulation model for access control, written in Prolog, is presented.
Classification of dialog techniques
Authors: Jakob Nielsen
Venue: ACM SIGCHI Bulletin (1987)

Program designers invent new dialog techniques all the time, but these techniques are often not documented in formal scientific papers. Several years of this has led to the current state where very few people would be able to list, say all the different kinds of menus. The CHI+GI'87 workshop on classification of dialog techniques was intended to remedy this problem somewhat by coming up with a classification scheme according to which existing and new dialog techniques could be cataloged.
Partitioning and Mapping Algorithms into Fixed Size Systolic Arrays
Authors: Dan I Moldovan, Jose A. B Fortes
Venue: IEEE Transactions on Computers (1986)

A technique for partitioning and mapping algorithms into VLSI systolic arrays is presented in this paper. Algorithm partitioning is essential when the size of a computational problem is larger than the size of the VLSI array intended for that problem. Computational models are introduced for systolic arrays and iterative algorithms. First, we discuss the mapping of algorithms into arbitrarily large size VLSI arrays. This mapping is based on the idea of algorithm transformations. Then, we present an approach to algorithm partitioning which is also based on algorithm transformations. Our approach to the partitioning problem is to divide the algorithm index set into bands and to map these bands into the processor space. The partitioning and mapping technique developed throughout the paper is summarized as a six step procedure. A computer program implementing this procedure was developed and some results obtained with this program are presented.
Factors affecting readability
Authors: Chris Hallgren
Venue: Proceedings of the 4th annual international conference on Systems documentation (1986)

No one has found a way to really help writers create readable prose. Robert Gunning developed a method for calculating the 'Fog Index' and Rudolph Flesch worked out more than one formula for measuring the simplicity of writing. By one of Flesch's formulas (the one without personal pronouns), Ronald S. Lemos in the February, 1985 issue of Communications of the ACM (CACM) was able to prove that CACM required two less years of school to read than Datamation. Statistics can prove anything. I have no idea what Sophomore in High School could read the CACM cover to cover and even understand most of it. Flesch's book 'The Art of Plain Talk' was given to me at a Yourdon Systems Analysis course. The Instructor handed it to each of us, saying something like &ldquo;read this and you'll be a manager in no time&rdquo; (supposedly, management is handed to the least efficient person who can also write well). The book is full of examples, mostly journalistic, showing how good writers evoke human interest. Of course, these writers had human events, thoughts and feelings as their focal points, not software, I doubt whether any of the graduates of that week ever used Flesch as a reference for grading their own documentation. How would Bernard Shaw have documented software? Or Mingus played it? This paper addresses these burning issues.
OTM: specifying office tasks
Authors: F. H. Lochovsky, J. S. Hogg, A. O. Mendelzon, S. P. Weiser
Venue: Proceedings of the ACM SIGOIS and IEEECS TC-OA 1988 conference on Office information systems (1988)

While there are many difficulties in computerizing office tasks, two of the major ones are a lack of appropriate end-user facilities for specifying office tasks and inadequate system-level support for managing office tasks. We are investigating these two issues within the Office Task Manager (OTM) project at the University of Toronto. To address the user-level aspects of specifying office tasks, we believe that a programming-by-example approach to office task specification holds much promise for providing office workers with facilities to help them computerize their own office activities. We outline our approach to such a facility in this paper. To address the system-level aspects of managing office tasks, we believe that object-oriented environments, because of their ability to combine data and operations on the data, can provide the support required for managing office tasks. In this paper, we also outline how office data and tasks are encoded and managed as objects. Initially, we are addressing the problem of supporting structured office tasks and our approach to this problem is the emphasis of this paper.
An architecture for intelligent assistance in software development
Authors: G. E. Kaiser, P. H. Feiler
Venue: Proceedings of the 9th international conference on Software Engineering (1987)

We define an architecture for a software engineering environment that behaves as an intelligent assistant. Our architecture consists of three key aspects: an objectbase, a model of the software development activities, and controlled automation. Our objectbase is adapted from other research, but our model is unique in that is consists primarily of rules that define the preconditions and multiple postconditions of software development activities. Our most significant contribution is opportunistic processing, whereby the environment performs software development activities through controlled automation. This is accomplished by a forward and backward chaining interpretation of the rule set. Activities are automatically carried out at some time between when their preconditions are satisfied and when their postconditions are required. Automation is controlled through strategies that guide the assistant in choosing an appropriate point for carrying out each activity.
Neptune: a hypertext system for CAD applications
Authors: Norman Delisle, Mayer Schwartz
Venue: ACM SIGMOD Record (1986)

Even though many of the essential notions of hypertext were first contained in the description of a &ldquo;memex,&rdquo; written by Vannevar Bush in 1945 [Bus45], there are today only a few scattered implementations of hypertext, let alone any serious use of it in a CAD environment. In what follows, we describe what hypertext is all about. We describe a prototype hypertext system, named Neptune, that we have built. We show how it is useful, especially its broad applicability to CAD.
Limitations of Graham-Glanville style code generation
Authors: D Spector, P K Turner
Venue: ACM SIGPLAN Notices (1987)

In recent years, the Graham-Glanville approach to code generation has become an increasingly important influence on new compiler writing projects. Initial enthusiasm prompted by the early research results has now fueled projects with more practical goals and requirements. This paper reports on the early results of a long-term project that is applying the Graham-Glanville method to the creation of an industrial-quality multi-language, multi-target compiler system. Much of the resulting code generation system deals with matters that are not fully handled by the Graham-Glanville method. We present a derailed list of the limitations encountered and, for each, the extension or modification that was invented to deal with it.Our conclusion is that the Graham-Glanville method does not always fulfill its early promise of generating locally-optimal code. Production-quality retargetable compiler generation still requires clever organization and many sophisticated algorithms to achieve this goal in the presence of register allocation and cost analysis.
How many addressing modes are enough?
Authors: F. Chow, S. Correll, M. Himelstein, E. Killian, L. Weber
Venue: ACM SIGARCH Computer Architecture News (1987)

Programs naturally require a variety of memory-addressing modes. It isn't necessary to provide them in hardware, however, if a compiler can synthesize them from a few primitive modes. This not only simplifies the hardware, but also permits the compiler to use its understanding of the program to economize on the modes which it uses. We present some compilation techniques that allow the compiler to deal effectively with a single addressing mode in a target RISC processor. We also give measurements to show the benefits of such techniques, and to support our assertion that a single addressing mode is adequate for a general purpose processor, provided that mode incorporates both a pointer and an offset.
An expert system application in semicustom VLSI design
Authors: R. L. Steele
Venue: Proceedings of the 24th ACM/IEEE Design Automation Conference (1987)

This paper describes the implementation of a prototype expert system that provides standard cell design advice in the areas of performance, manufacturability, testability, and overall design quality, from a netlist description of an application specific integrated circuit (ASIC) design. The system is currently being developed on a Symbolics Lisp Machine using a hybrid AI programming language, called Proteus. The language integrates both known and novel AI programming techniques into a robust vehicle for the implementation of knowledge-based systems. Knowledge representation schemes, inference mechanisms, and knowledge acquisition techniques will be presented, including representative examples from within the knowledge base.
Single-Site and Distributed Optimistic Protocols for Concurrency Control
Authors: M. A. Bassiouni
Venue: IEEE Transactions on Software Engineering (1988)

The authors consider that, in spite of their advantage in removing the overhead of lock maintenance and deadlock handling, optimistic concurrency control methods have been applied less in practice than locking schemes. Two complementary approaches are introduced that may help render the optimistic approach practically viable. For the high-level approach, integration schemes can be utilized so that the database management system is provided with a variety of synchronization methods each of which can be applied to the appropriate class of transactions. The low-level approach seeks to increase the concurrency of the original optimistic method and improve its performance. The author examines the low-level approach in depth, and presents algorithms that aim at reducing back-ups and improve throughput. Both the single-site and distributed networks are considered. Optimistic schemes using time-stamps for fully duplicated and partially duplicated database networks are presented, with emphasis on performance enhancement and on reducing the overall cost of implementation.
Design by objectives
Authors: T Gilb
Venue: ACM SIGSOFT Software Engineering Notes (1987)

We have developed a set of co-operative methods and languages for describing a software engineering problem, its solutions and its intermediary products. The main characteristic of the method, known as Design by Objectives (DBO), is its ability to deal with all system attributes quantitatively. The DBO method is based on specification and design languages which are written, unambiguous, structured, integrated with each other flexible in when and where to apply them, capable of being scaled up or down to suit project viewpoint and scale of project, and capable of being applied to all aspects of system design, including all possible components of a software system. Since 1979 we have built a series of experimental personal computer automated support systems based on the DBO languages, in an attempt to see how they might be constructed and what value they might give the user. In addition many elements of the DBO languages have been put to extensive industrial use by the authors, their clients and by other users of the methods, including several computer manufacturers.