ppxscal/embedding_network huggingface dataset:
Bibliography on spatiotemporal databases
Authors: Khaled K. Al-Taha, Richard Thomas Snodgrass, Michael D. Soo
Venue: ACM SIGMOD Record (1993)

Spatial and temporal databases are important and well-established sub-disciplines of database research. Some 350 papers in temporal databases have appeared, authored by almost 300 researchers. The literature on spatial databases is also substantial; the bibliography of Samet's landmark book on spatial data structures lists 823 references.
Object-orientation and Ada: the expected impact of Ada9X on a computer science/software engineering degree
Authors: Douglas D. Grant
Venue: ACM SIGPLAN OOPS Messenger (1993)

This presentation discusses the evolution of the curriculum in object-oriented methods in the main undergraduate degree in the Department of Computer Science at Swinburne University of Technology in Melbourne, Australia. The degree has a strong Software Engineering emphasis, and object-oriented analysis and design methods are complemented by a programming curriculum which uses Ada. The forthcoming Ada9X will have a substantial impact on the curriculum.
File access patterns in public FTP archives and an index for locality of reference
Authors: Silvano Maffeis
Venue: ACM SIGMETRICS Performance Evaluation Review (1993)

Global filesystems and new file transfer protocols are a great need and challenge in the presence of drastically growing networks. In this paper we present results obtained from an investigation of access to public files which took place over three months. This work visualizes first results on the popularity of public ftp files, on common operations (deletions, updates and insertions) to public file-archives and on encountered filesizes. An index for measuring locality of reference to a resource is also proposed. The results show that most file transfers relate to only a small fraction of the files in an archive and that a considerable part of the operations to public files are updates of files. Further results are presented and interpreted in the paper.
Evaluation of signature files as set access facilities in OODBs
Authors: Yoshiharu Ishikawa, Hiroyuki Kitagawa, Nobuo Ohbo
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Object-oriented database systems (OODBs) need efficient support for manipulation of complex objects. In particular, support of queries involving evaluations of set predicates is often required in handling complex objects. In this paper, we propose a scheme to apply signature file techniques, which were originally invented for text retrieval, to the support of set value accesses, and quantitatively evaluate their potential capabilities. Two signature file organizations, the sequential signature file and the bit-sliced signature file, are considered and their performance is compared with that of the nested index for queries involving the set inclusion operator (&sube;). We develop a detailed cost model and present analytical results clarifying their retrieval, storage, and update costs. Our analysis shows that the bit-sliced signature file is a very promising set access facility in OODBs.
Multiple-view CASE support for object-oriented design (abstract)
Authors: Shang-cheng Chyou
Venue: Addendum to the proceedings on Object-oriented programming systems, languages, and applications (Addendum) (1992)

Object-Oriented Programming (OOP) has been recognized to have great potential in producing high quality, large reusable software. However, we often find it difficult to write good C++ or Smalltalk programs. Without good program designs we will not reap the benefits of OOP. On the other hand, Object-Oriented Design (OOD) is considerably more complex than that of the traditional design disciplines such as Structured Design. Therefore, without the help of powerful CASE tools, we may not achieve the benefits of OOD and OOP. This demonstration will present TurboCASE, a multi-methodology supporting CASE tool that supports both Object-Oriented Analysis (OOA) and OOD. TurboCASE provides multiple views to help software designers create good OOD models. TurboCASE allows you to create and maintain Class Hierarchy, Class Collaboration, Class Definition, and Class Design Diagrams. The Class Hierarchy Diagram not only shows the class hierarchy, but also helps resolve how polymorphism works. The class Collaboration Diagram gives three levels of abstraction showing how objects communicate with each other. The Class Definition Diagram shows the methods and instance variables of the class, as well as providing the ability to browse the capabilities of the class inherited from the class hierarchy. The Class Design Diagram allows you to design a class similar to that of the Structured Chart with full support of the method signature specification. These diagrams are integrated through a project database, thereby providing multiple views of the software design. TurboCASE also provides intelligent help to refine the design such as abstracting the common behaviors of classes into an abstracted class. Subsystems can be designed top-down as well as bottom-up by abstracting from system components. These capabilities greatly reduce the complexities of the designs and help achieve optimal solutions.
On the numerical inversion of Laplace transforms: comparison of three new methods on characteristic problems from applications
Authors: Dean G. Duffy
Venue: ACM Transactions on Mathematical Software (TOMS) (1993)

Three frequently used methods for numerically inverting Laplace transforms are tested on complicated transforms taken from the literature. The first method is a straightforward application of the trapezoidal rule to Bromwich's integral. The second method, developed by Weeks [22], integrates Bromwich's integral by using Laguerre polynomials. The third method, devised by Talbot [18], deforms Bromwich's contour so that the integrand of Bromwich's integral is small at the beginning and end of the contour. These methods are also applied to joint Laplace-Fourier transform problems. All three methods give satisfactory results; Talbot's, however, has an accurate method for choosing required parameters.
Module types, module variables, and their use as a universal encapsulation mechanism
Authors: Atanas Radenski
Venue: ACM SIGPLAN Notices (1994)

The objective of this paper is to develop a universal encapsulation mechanism which can serve as a single substitute for classes, packages, records and subroutines. The proposed mechanism, the module type, is based on a modification of the traditional meaning of the concept of type. A module type defines a collection of entities, such as constants, types, variables, and optionally, a module body. A module type can be used to declare module variables. The body of a module variable can be activated by a module call.It is demonstrated how module types can implement classes, and how module variables can serve the need for packages, subroutines, and records.The concept of module type is embedded in an experimental language whose main features are briefly described in the paper. A prototype compiler for this language has been developed. The implementation scheme is also discussed.Module types and module variables have uncomplicated and intuitively clear semantics. As a result, they are simple to use, and they allow more efficient implementation compared to traditional encapsulation mechanisms.The paper outlines a programming language experiment and is not aimed at a formal theoretical study of module types.
A distributed system security architecture: applying the transport layer security protocol
Authors: Mohammad Mirhakkak
Venue: ACM SIGCOMM Computer Communication Review (1993)

A great deal of attention has been given to the development of Open Systems Interconnection (OSI) security protocols in recent years. However, limited work has been dedicated to using these protocols to develop security architectures for securing distributed systems consisting of trusted computer systems communicating via untrusted networks. This paper presents an overview of the Transport Layer Security Protocol (TLSP) and discusses its application to the development of a security architecture for a generic distributed system that uses the OSI transport layer protocol. In addition, the paper discusses the security services that can be achieved as a result of employing the TLSP in a distributed system. It also examines the security functions that are expected from the end-systems, and addresses the security management functions that are required for the operation of the TLSP.
Authentication and revocation in SPM extended abstract
Authors: Claudio Calvelli, Vijay Varadharajan
Venue: ACM SIGOPS Operating Systems Review (1993)

SPM formalism can be used to specify the protection structure of a system, and it also provides an algorithm to decide if some privileges can be granted to some subjects. This paper extends the model to take into account authentication and revocation. The authentication extension gives an algorithm to find out which authentication steps must be taken by a subject in order to gain some privileges. The revocation extension allows to decide whether certain privileges can be given back after they have been revoked. The two extensions are independent in the sense that each one corresponds to a change to a different part of the decision algorithm.
Information extraction as a basis for high-precision text classification
Authors: Ellen Riloff, Wendy Lehnert
Venue: ACM Transactions on Information Systems (TOIS) (1994)

We describe an approach to text classification that represents a compromise between traditional word-based techniques and in-depth natural language processing. Our approach uses a natural language processing task called &ldquo;information extraction&rdquo; as a basis for high-precision text classification. We present three algorithms that use varying amounts of extracted information to classify texts. The relevancy signatures algorithm uses linguistic phrases; the augmented relevancy signatures algorithm uses phrases and local context; and the case-based text classification algorithm uses larger pieces of context. Relevant phrases and contexts are acquired automatically using a training corpus. We evaluate the algorithms on the basis of two test sets from the MUC-4 corpus. All three algorithms achieved high precision on both test sets, with the augmented relevancy signatures algorithm and the case-based algorithm reaching 100% precision with over 60% recall on one set. Additionally, we compare the algorithms on a larger collection of 1700 texts and describe an automated method for empirically deriving appropriate threshold values. The results suggest that information extraction techniques can support high-precision text classification and, in general, that using more extracted information improves performance. As a practical matter, we also explain how the text classification system can be easily ported across domains.
Call by name, assignment, and the lambda calculus
Authors: Martin Odersky, Dan Rabin, Paul Hudak
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

We define an extension of the call-by-name lambda calculus with additional constructs and reduction rules that represent mutable variables and assignments. The extended calculus has neither a concept of an explicit store nor a concept of evaluation order; nevertheless, we show that programs in the calculus can be implemented using a single-threaded store. We also show that the new calculus has the Church-Rosser property and that it is a conservative extension of classical lambda calculus with respect to operational equivalence; that is, all algebraic laws of the functional subset are preserved.
Synthesis of extended transaction models using ACTA
Authors: Panos K. Chrysanthis, Krithi Ramamritham
Venue: ACM Transactions on Database Systems (TODS) (1994)

ACTA is a comprehensive transaction framework that facilitates the formal description of properties of extended transaction models. Specifically, using ACTA, one can specify and reason about (1) the effects of transactions on objects and (2) the interactions between transactions. This article presents ACTA as a tool for the synthesis of extended transaction models, one which supports the development and analysis of new extended transaction models in a systematic manner. Here, this is demonstrated by deriving new transaction definitions (1) by modifying the specifications of existing transaction models, (2) by combining the specifications of existing models, and (3) by starting from first principles. To exemplify the first, new models are synthesized from atomic transactions and join transactions. To illustrate the second, we synthesize a model that combines aspect of the nested- and split-transaction models. We demonstrate the latter by deriving the specification of an open-nested-transaction model from high-level requirements.
Collecting more garbage
Authors: Pascal Fradet
Venue: Proceedings of the 1994 ACM conference on LISP and functional programming (1994)

We present a method, adapted to polymorphically typed functional languages, to detect and collect more garbage than existing GCs. It can be applied to strict or lazy higher order languages and to several garbage collection schemes. Our GC exploits the information on utility of arguments provided by polymorphic types of functions. It is able to detect garbage that is still referenced from the stack and may collect useless parts of otherwise useful data structures. We show how to partially collect shared data structures and to extend the type system to infer more precise information. We also present hoe this technique can plug several common forms of space leaks.
Undecidability of static analysis
Authors: William Landi
Venue: ACM Letters on Programming Languages and Systems (LOPLAS) (1992)

Static analysis of programs is indispensable to any software tool, environment, or system that requires compile-time information about the semantics of programs. With the emergence of languages like C and LISP, static analysis of programs with dynamic storage and recursive data structures has become a field of active research. Such analysis is difficult, and the static-analysis community has recognized the need for simplifying assumptions and approximate solutions. However, even under the common simplifying assumptions, such analyses are harder than previously recognized. Two fundamental static-analysis problems are may alias and must alias. The former is not recursive (is undecidable), and the latter is not recursively enumerable (is uncomputable), even when all paths are executable in the program being analyzed for languages with if statements, loops, dynamic storage, and recursive data structures.
The workspace manager: a change control system for APL
Authors: Rexford H. Swain Daniel F. Jonusz
Venue: ACM SIGAPL APL Quote Quad (1993)

This paper describes the Workspace Manager (WSM), a tool that helps to support and add discipline to APL system development and maintenance efforts.The WSM acts as a repository of APL objects (variables, functions, and operators). Programmers use WSM tools to find where objects are used, edit objects, save changed objects, and request that objects be installed into (or erased from) production workspaces.Periodically, the WSM installs new releases of production workspaces by merging new and changed objects into existing workspaces.Audit trails are maintained for all of these activities, making it possible to review the change history of an object, compare different versions of an object, compare different releases of a workspace, revert to an old release of a workspace, and so on.
Graphical user interfaces and ease of use: some myths examined
Authors: Michael C. Zanino, Ritu Agarwal, Jayesh Prasad
Venue: Proceedings of the 1994 computer personnel research conference on Reinventing IS : managing information technology in changing organizations: managing information technology in changing organizations (1994)

Graphical user interfaces (GUIs) are on their way to becoming the most pervasive interface for desktop systems at least partly because of conventional wisdom about their ease of use. Such an assumption may have been kindled by vendors' claims about the inherent usability of such interfaces although previous research on the productivity gains from GUIs has yielded mixed results. This paper reports the results of a field study of 230 users of a popular GUI, Microsoft Corporation's Windows. The study examined Windows' ease of use&mdash;an important factor contributing to eventual productivity. The results indicate that contrary to popular belief GUIs are not universally easy to use&mdash;certain types of individuals are likely to find them easier to use than others. Organizational roles and management initiatives can also influence perceptions of ease of use. The findings also suggest that ease of use is enhanced through opportunities for self training rather than traditional, formal training.
Concurrent Object Oriented 'C' (cooC)
Authors: Rajiv Trehan, Nobuyuki Sawashima, Akira Morishita, Ichiro Tomoda, Toru Imai, Ken-Ichi Maeda
Venue: ACM SIGPLAN Notices (1993)

Concurrent Object Oriented C (cooC) is a language based on the premise that an object not only provides an encapsulation boundary but should also form a process boundary; each object acts concurrently. Upon this basic model various control regimes can be applied to provide different execution and service policies. The cooC language model employs wait-when-necessary communication and affords shared resource protection (via exclusive method invocation). The cooC runtime provides for several execution paradigms for object and method invocation. Varying runtime parameters (number of threads and a mail queue size) allow for: sequential compatible evaluation; fine and coarse grain concurrency; and eager and lazy evaluation, cooC is an extension to C. The underlying syntax of cooC is the same as that of Objective-C; moreover, Objective-C objects are cooC objects which are to be evaluated with a sequential runtime and employ no special synchronisation. The CooC compiler converts cooC into C and also supports C++. Hence cooC is a superset of C, C++ and Objective-C. We present cooC's concurrency object model, runtime and support for various execution and service policies.
Original Contribution: A convergent generator of neural networks
Authors: Pierre Courrieu
Venue: Neural Networks (1993)

This article presents a new algorithm for the automatic generation of neural architectures and supervised learning. Given a set of examples, the algorithm generates an architecture and synaptic weights that are adapted to the sampled problem. The algorithm supports any type and amount of numerical input and output. The learning/generation process is guaranteed to converge in a strictly finite number of steps. With the exception of certain a priori nonoptimal architectures, all architectures without internal loops are potentially accessible, and the algorithm tends to generate architectures of minimal complexity, giving it high generalization performance in the learned domain.
Achieving principled communication amid conflict
Authors: T. R. Girill
Venue: ACM SIGDOC Asterisk Journal of Computer Documentation (1994)

In his essay on "Ethics and Technical Communication: A Rhetorical Perspective," Gregory Clark shows how "both professionals and academicians in technical communication demand an ethics to guide their work that is both practical and responsible" (Clark, 1987, p. 195). Unfortunately, each group's assumptions about the scope and character of ethics differ so much that neither group finds the other's analysis acceptable. Clark finds flaws on all sides. He argues that a third alternative, based on shared understanding and rhetorical cooperation, "is likely to work in both the individual and the collective interest of all people involved in a communication process" (Clark, p. 195).
High performance parallel logic simulations on a network of workstations
Authors: Naraig Manjikian, Wayne M. Loucks
Venue: ACM SIGSIM Simulation Digest (1993)

An approach for high performance parallel logic simulation on a local area network of workstation computers is discussed in this paper. The single, shared transmission medium often found in such networks places limitations on parallel execution, hence a reduction in the frequency of synchronization is pursued by combining a circuit partitioning methodology with a specific synchronization constraint. A consequence of the partitioning methodology is replication of objects between blocks of a partition. A partitioning procedure based on iterative improvement is described for reducing replication while preserving load balance. Two interprocessor synchronization techniques for parallel simulation are studied: conservative and optimistic synchronization. Experiments conducted on three large sequential circuits indicate that reasonable speedup is achievable for well-balanced partitions, and that optimistic synchronization provides a modest improvement in performance over conservative synchronization.
Writing efficient C++ programs (abstract)
Authors: Scott Meyers
Venue: Addendum to the proceedings on Object-oriented programming systems, languages, and applications (Addendum) (1992)

Writing Efficient C++ Programs Scott Meyers, Brown University This tutorial teaches the competing meanings of high performance; the characteristics of object-oriented systems that can decrease performance; how to locate and eliminate computational bottlenecks in C++ programs; and the trade-offs between high performance and system reusability, maintainability, and portability. It describes in detail the factors that affect the performance of C++ software. Whether your primary concern is high system speed, small system size, fast recompilation, or a combination of these, this tutorial provides you with the tools necessary to come up with an appropriate object- oriented design, to implement it efficiently in C++, and to fine-tune it for maximum performance. The reasons for bottlenecks in C++ programs are often surprising. Contrary to popular belief, virtual functions usually exact a negligible performance cost, while unexpected calls to constructors and destructors frequently hamstring applications. This tutorial teaches you what is really important if you want to deliver high performance, and the techniques you need to achieve it.
Finding maximal subfields
Authors: Susan Landau
Venue: ACM SIGSAM Bulletin (1993)

The problem: Given a field K with a finite extension K( alpha;), K( alpha;) described in terms of the minimal polynomial of alpha; over K, find all maximal subfields of K( alpha;) containing K. (K is assumed to be characteristic zero.)