ppxscal/embedding_network huggingface dataset:
Identification of complete data flow diagrams
Authors: Federico Vazquez
Venue: ACM SIGSOFT Software Engineering Notes (1994)

The Structure Design is generated with Data Flow Diagrams (DFD). DFD have been used for more than ten years, and they are still popular. The main drawback of DFD is the lack of mathematical foundation. The great demand for bigger and more sophisticated computer systems makes necessary the formulation of a formal theory for DFD. This theory will provide a way of checking consistency and completeness. Universal Algebra has become a useful and important tool in theoretical computer science. Universal Algebra is used in this paper to represent DFD, to generate DFD, to prove consistency and completeness and to define complete DFD. A process decomposition is defined in strict mathematical way; the famous Birkoff's Variety Theorem is used to prove consistency in the process decomposition; a definition of minimal DFD is given; a relation between Universal Algebra concepts and DFD is defined; and a definition of complete (well-defined) DFD is given. The DFD are defined using basic concepts of Universal Algebra theory. The results from this paper can be incorporated in any of the CASE tools used to generate DFD.
Database method schemas and object creation
Authors: Karl Denninghoff, Victor Vianu
Venue: Proceedings of the twelfth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1993)

The expressiveness of various object-oriented languages is investigated with respect to their ability to create new objects. We focus on database method schemas (dms), a model capturing the data manipulation capabilities of a large class of deterministic methods in object-oriented databases. The results clarify the impact of various language constructs on object creation. Several new constructs based on expanded notions of deep equality are introduced. In particular, we provide a tractable construct which yields a language complete with respect to object creation. The new construct is also relevant to query complexity. For example, it allows expressing in polynomial time some queries, like counting, requiring exponential space in dms alone.
Mathematical software for Sturm-Liouville problems
Authors: Steven Pruess, Charles T. Fulton
Venue: ACM Transactions on Mathematical Software (TOMS) (1993)

Software is described for the Sturm-Liouville eigenproblem. Eigenvalues, eigenfunctions, and spectral density functions can be estimated with global error control. The method of approximating the coefficients forms the mathematical basis. The underlying algorithms are briefly described, and several examples are presented.
Lower bounds on messages and rounds for network authentication protocols
Authors: Li Gong
Venue: Proceedings of the 1st ACM conference on Computer and communications security (1993)

The encrypted key exchange (EKE) protocol is augmented so that hosts do not store cleartext passwords. Consequently, adversaries who obtain the one-way encrypted password file may (i) successfully mimic (spoof) the host to the user, and (ii) mount dictionary attacks against the encrypted passwords, but cannot mimic the user to the host. Moreover, the important security properties of EKE are preserved&mdash;an active network attacker obtains insufficient information to mount dictionary attacks. Two ways to accomplish this are shown, one using digital signatures and one that relies on a family of commutative one-way functions.
Constructing the next 100 database management systems: like the handyman or like the engineer?
Authors: Andreas Geppert, Klaus R. Dittrich
Venue: ACM SIGMOD Record (1994)

While the number of database management systems (DBMSs) increases and the various DBMSs get more and more complex, no uniform method for DBMS construction exists. As a result, developers are forced to start more or less from scratch again for every desired system, resulting in a waste of time, effort, and cost. Hence, the database community is challenged with the development of an appropriate method, i.e. the time-saving application of engineering principles (e.g., reuse). Problems related to a construction method are described, as well as approaches towards solutions.
Polymorphic type inference and abstract data types
Authors: Konstantin Läufer, Martin Odersky
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1994)

Many statically typed programming languages provide an abstract data type construct, such as the module in Modula-2. However, in most of these languages, implementations of abstract data types are not first-class values. Thus, they cannot be assigned to variables, passed as function parameters, or returned as function results. Several higher-order functional languages feature strong and static type systems, parametric polymorphism, algebraic data types, and explicit type variables. Most of them rely on Hindley-Milner type inference instead of requiring explicit type declarations for identifiers. Although some of these languages support abstract data types, it appears that none of them directly provides light-weight abstract data types whose implementations are first-class values. We show how to add significant expressive power to statically typed functional languages with explicit type variables by incorporating first-class abstract types as an extension of algebraic data types. Furthermore, we extend record types to allow abstract components. The components of such abstract records are selected using the dot notation. Following Mitchell and Plotkin, we formalize abstract types in terms of existentially quantified types. We give a syntactically sound and complete type inference algorithm and prove that our type system is semantically sound with respect to standard denotational semantics.
Privacy considerations in CSCW: report on the CSCW'92 workshop
Authors: Andrew Clement
Venue: ACM SIGCHI Bulletin (1993)

A central feature of CSCW applications is the electronic capture and dissemination of detailed personal information. Whether using e-mail, computer conferencing facilities, group decision support systems, media spaces, active badges, or other computerized means for aiding collective work activities, fine-grained information about individual's performance and behaviour is made available to others. This poses important questions about how the people involved may control information about themselves---information which can play an important role in fundamental notions of personal and collective dignity, identity and autonomy.
An automated tool for analyzing completeness of equational specifications
Authors: Deepak Kapur
Venue: Proceedings of the 1994 ACM SIGSOFT international symposium on Software testing and analysis (1994)

Books on software engineering methodologies talk about the significance and need for designing consistent and complete specifications during the requirement analysis and design stages of a software development cycle. There is, however, little (or at best very limited) discussion of methods for ensuring these structural properties of specifications. In this paper, we discuss methods for checking completeness of equational specifications. Some of these methods were earlier proposed in somewhat different form in the context of developing the so-called inductionless induction method for automating proofs by induction using completion procedures. These methods are implemented in our theorem prover Rewrite Rule Laboratory (RRL), and have been tried on a number of examples of specifications of data abstractions. In case a specification is incomplete, these methods can aid in making them complete by generating templates which are not specified. Templates can also be helpful in distinguishing between intentional and unintentional incompleteness in specifications. Further, these methods can be used to generate test cases for checking specifications and verifying implementations of specifications. These methods are illustrated on examples which exhibit their power as well as limitations.
Engineering a simple, efficient code-generator generator
Authors: Christopher W. Fraser, David R. Hanson, Todd A. Proebsting
Venue: ACM Letters on Programming Languages and Systems (LOPLAS) (1992)

Many code-generator generators use tree pattern matching and dynamic programming. This paper describes a simple program that generates matchers that are fast, compact, and easy to understand. It is simpler than common alternatives: 200&ndash;700 lines of Icon or 950 lines of C versus 3000 lines of C for Twig and 5000 for burg. Its matchers run up to 25 times faster than Twig's. They are necessarily slower than burg's BURS (bottom-up rewrite system) matchers, but they are more flexible and still practical.
Combinatorics of Maximal Minors
Authors: David Bernstein, Andrei Zelevinsky
Venue: Journal of Algebraic Combinatorics: An International Journal (1993)

We continue the study of the Newton polytope &prod;m,n of the product of all maximal minors of an m &times; n-matrix of indeterminates. The vertices of &prod;m,n are encoded by coherent matching fields &Lambda; &equals; (&Lambda;&sigma;), where &sigma; runs over all m-element subsets of columns, and each &Lambda;&sigma; is a bijection &sigma; &rarr; &lsqb;m&rsqb;. We show that coherent matching fields satisfy some axioms analogous to the basis exchange axiom in the matroid theory. Their analysis implies that maximal minors form a universal Gr&ouml;bner basis for the ideal generated by them in the polynomial ring. We study also another way of encoding vertices of &prod;m,n for m &le; n by means of &ldquo;generalized permutations&rdquo;, which are bijections between (n &minus; m + 1)&ndash;element subsets of columns and (n &minus; m + 1)&ndash;element submultisets of rows.
Cost/performance of a parallel computer simulator
Authors: Babak Falsafi, David A. Wood
Venue: Proceedings of the eighth workshop on Parallel and distributed simulation (1994)

This paper examines the cost/performance of simulating a hypothetical target parallel computer using a commercial host parallel computer. We address the question of whether parallel simulation is simply faster than sequential simulation, or if it is also more cost-effective. To answer this, we develop a performance model of the Wisconsin Wind Tunnel (WWT), a system that simulates cache-coherent shared-memory machines on a message-passing Thinking Machines CM-5. The performance model uses Kruskal and Weiss's fork-join model to account for the effect of event processing time variability on WWT's conservative fixed-window simulation algorithm. A generalization of Thiebaut and Stone's footprint model accurately predicts the effect of cache interference on the CM-5. The model is calibrated using parameters extracted from a fully-parallel simulation (p=N), and validated by measuring the speedup as the number of processors (p) ranges from one to the number of target nodes (N. Together with simple cost models, the performance model indicates that for target system sizes of 32 nodes and larger, parallel simulation is more cost-effective than sequential simulation. The key intuition behind this result is that large simulations require large memories, which dominate the cost of a uniprocessor; parallel computers allow multiple processors to simultaneously access this large memory.
One is not enough: multiple views in a media space
Authors: William W. Gaver, Abigail Sellen, Christian Heath, Paul Luff
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

Media spaces support collaboration, but the limited access they provide to remote colleagues' activities can undermine their utility. To address this limitation, we built an experimental system in which four switchable cameras were deployed in each of two remote offices, and observed participants using the system to collaborate on two tasks. The new views allowed increased access to task-related artifacts; indeed, users preferred these views to more typical &ldquo;face-to-face&rdquo; ones. However, problems of establishing a joint frame of reference were exacerbated by the additional complexity, leading us to speculate about more effective ways to expand access to remote sites.
A Combinatorial Characterization of Hermitian Curves
Authors: J. A. Thas
Venue: Journal of Algebraic Combinatorics: An International Journal (1992)

A unital U with parameter q is a 2 &minus; (q3 + 1, q + 1, 1) design. If a point set U in PG(2, q2) together with its (q + 1)-secants forms a unital, then U is called a Hermitian arc. Through each point p of a Hermitian arc H there is exactly one line L having with H only the point p in common&semi; this line L is called the tangent of H at p. For any prime power q, the absolute points and nonabsolute lines of a unitary polarity of PG(2, q2) form a unital that is called the classical unital. The points of a classical unital are the points of a Hermitian curve in PG(2, q2).Let H be a Hermitian arc in the projective plane PG(2, q2). If tangents of H at collinear points of H are concurrent, then H is a Hermitian curve. This result proves a well known conjecture on Hermitian arcs.
Automatic array alignment in data-parallel programs
Authors: Siddhartha Chatterjee, John R. Gilbert, Robert Schreiber, Shang-Hua Teng
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

Data-parallel languages like Fortran 90 express parallelism in the form of operations on data aggregates such as arrays. Misalignment of the operands of an array operation can reduce program performance on a distributed-memory parallel machine by requiring nonlocal data accesses. Determining array alignments that reduce communication is therefore a key issue in compiling such languages. We present a framework for the automatic determination of array alignments in data-parallel languages such as Fortran 90. Our language model handles array sectioning, reductions, spreads, transpositions, and masked operations. We decompose alignment functions into three constituents: axis, stride, and offset. For each of these subproblems, we show how to solve the alignment problem for a basic block of code, possibly containing common subexpressions. Alignments are generated for all array objects in the code, both named program variables and intermediate results. The alignments obtained by our algorithms are more general than those provided by the &ldquo;owner-computes&rdquo; rule. Finally, we present some ideas for dealing with control flow, replication, and dynamic alignments that depend on loop induction variables.
TAE Plus: Transportable Applications Environment Plus: a user interface development environment
Authors: Martha R. Szczur, Sylvia B. Sheppard
Venue: ACM Transactions on Information Systems (TOIS) (1993)

The Transportable Applications Environment Plus (TAE Plus) is a NASA-developed user interface development environment (UIDE) for the rapid prototyping, evaluation, implementation, and management of user interfaces. TAE Plus provides an intuitive What You See Is What You Get (WYSIWYG) WorkBench for designing an application's user interface. The WorkBench supports the creation and sequencing of displays, including real-time, data-driven display objects. Users can define context-sensitive help for a target application. They can rehearse the user interface and also generate code automatically. In addition TAE Plus contains application services for the runtime manipulation and management of the user interface. Based on Motif and the MIT X Window System, TAE Plus runs on a variety of Unix- or VMS-based workstations. TAE Plus is an evolving system. User-defined requirements and new technology guide the development of each new version. Advances in virtual operating systems, human factors, computer graphics, command language design, standardization, and software portability are monitored and incorporated as they become available.
Teaching mathematics using technology strategies
Authors: Robert Lipton
Venue: ACM SIGCUE Outlook (1994)

This article explores alternate ways that technology can be utilized to teach mathematics. This is accomplished by examining the concept of the computer classroom, which is the integration of computers and their associated technologies in the teaching process. In conclusion, a comprehensive solution, based on research, is outlined and specified.
The pessimism behind optimistic simulation
Authors: George Varghese, Roger Chamberlain, William E. Weihl
Venue: ACM SIGSIM Simulation Digest (1994)

In this paper we make an analogy between the time that storage must be maintained in an optimistic simulation and the blocking time in a conservative simulation. By exploring this analogy, we design two new Global Virtual Time (GVT) protocols for Time Warp systems. The first protocol is based on null message clock advancement in conservative approaches. Our main contribution is a new protocol inspired by Misra's circulating marker scheme for deadlock recovery. It is simple enough to be implemented in hardware, takes no overhead in the normal path, can be made to work over non-FIFO links, and its overhead can be dynamically tuned based on computational load.
A simple balanced search tree
Authors: Porter Eugene Smith, James H. Graham
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

This paper provides a simple data structure and algorithm to create a balanced binary search tree that may be useful as an index for stored data or for other purposes. Its search and insertion time complexities are both O(log N) where N is the number of keys that it contains. The interesting feature of this data structure is that it is easy to visualize and understand. This structure could provide a friendly introduction to the study of balanced tree structures. Performance characteristics are sufficient that it could be appropriate in medium sized applications where small code size is important.
How using busses in multicomputer programs affects conservative parallel simulation
Authors: Mary L. Bailey, Michael A. Pagels, Kachung Kevin Wong
Venue: ACM SIGSIM Simulation Digest (1993)

In this paper we consider the effect of using bus interconnection structures on the overheads present in conservative parallel simulations of multicomputer programs. We use a modified version of the Poker Programming Environment to empirically measure the overhead in three parallel algorithms using buses. We discuss the sources of overhead and compare them with those found using point-to-point communication. Preliminary results indicate that the overheads encountered using a bus interconnection structure were not predicted by our previous results using point-to-point communications.
SIGMOD goes online: new member services via Internet
Authors: Marianne Winslett
Venue: ACM SIGMOD Record (1993)

ACM SIGMOD is pleased to announce a new set of on line services for members, including on line copies of portions of the SIGMOD Record (including all funding columns since 1991, and wider coverage of the Record beginning with this issue), an archive of recent conference announcements, and a database of funding information. These services are fully functional and ready for use today. The remainder of this message explains how to access the services, and why you should access them in the manner suggested.
Extending record typing to type parametric modules with sharing
Authors: Maria Virginia Aponte
Venue: Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages (1993)

We extend term unification techniques used to type extensible records in order to solve the two main typing problems for modules in Standard ML: matching and sharing. We obtain a type system for modules based only on well known unification problems, modulo some equational theories we define. Our formalization is simple and has the elegance of polymorphic type disciplines based on unification. It can be seen as a synthesis of previous work on module and record typing.
An exploratory evaluation of three interfaces for browsing large hierarchical tables of contents
Authors: Richard Chimera, Ben Shneiderman
Venue: ACM Transactions on Information Systems (TOIS) (1994)

Three different interfaces were used to browse a large (1296 items) table of contents. A fully expanded stable interface, expand/contract interface, and multipane interface were studied in a between-groups experiment with 41 novice participants. Nine timed fact retrieval tasks were performed; each task is analyzed and discussed separately. We found that both the expand/contract and multipane interfaces produced significantly faster times than the stable interface for many tasks using this large hierarchy; other advantages of the expand/contract and multipane interfaces over the stable interface are discussed. The animation characteristics of the expand/contract interface appear to play a major role. Refinements to the multipane and expand/contract interfaces are suggested. A predictive model for measuring navigation effort of each interface is presented.
A simple encoder for fieldbus applications
Authors: Raja Prasad, Ulloa Gonzalo
Venue: ACM SIGCOMM Computer Communication Review (1993)

In this paper we present a Simple Encoder for Fieldbus applications. The Simple Encoder is tailored to support the special kind of data transfer in a Fieldbus. The encoding rules have been simplified to such an extent that only required information between peers are exchanged, so that the coding/decoding process does not cause any significant delay during real time operation of the network. The PDUs obtained are upto 55% shorter than PDUs of Basic Encoding Rules, BER, and the Simple Encoder is upto four times faster than BER encoder.
The evolution of an interface for choreographers
Authors: Tom W. Calvert, Armin Bruderlin, Sang Mah, Thecla Schiphorst, Chris Welman
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

This paper describes the evolution of the interface to Life Forms, a compositional tool for the creation of dance choreography, and highlights some of the important lessons we have learned during a six year design and implementation period. The lessons learned can be grouped into two categories: 1) Process, and 2) Architecture of the Interface. Our goal in developing a tool for choreography has been to provide computer-based creative design support for the conception and development of dance. The evolution was driven by feedback from the choreographers and users who were members of the development team, combined with our knowledge of current thinking on design and composition. Although the interface evolved in a relatively unconstrained way, the resulting system has many of the features that theoretical discussion in human interface design has projected necessary. The Life Forms interface has evolved incrementally with one major discontinuity where adoption of a new compositional primitive required a completely new version.
Boundaries, identity, and aggregation (abstract): plurality issues in multiagent systems
Authors: Les Gasser
Venue: ACM SIGOIS Bulletin (1992)

Larger, more complex, and more adaptive multi-agent systems will require us to think carefully about several new issues. Three of these are boundaries, identity, and aggregation. The difficulty of dealing with these is compounded without a clear idea of the nature of plurality and action-at-a-distance: the general impossibility of global viewpoints and shared perspectives due to the necessity of localized interpretations. This paper discusses these issues, giving special attention to some qualitative empirical data from studies of large-scale, integrated organizational computing. The paper also gives some initial analyses of computational mechanisms that begin to represent dynamic aggregation and distributed identity management along the theoretical lines discussed here.