ppxscal/embedding_network huggingface dataset:
A meta-environment for generating programming environments
Authors: P. Klint
Venue: ACM Transactions on Software Engineering and Methodology (TOSEM) (1993)

Over the last decade, considerable progress has been made in solving the problems of automatic generation of programming/development environments, given a formal definition of some programming or specification language. In most cases, research has focused on the functionality and efficiency of the generated environments, and, of course, these aspects will ultimately determine the acceptance of environment generators. However, only marginal attention has been paid to the development process of formal language definitions itself. Assuming that the quality of automatically generated environments will be satisfactory within a few years, the development costs of formal language definitions will then become the next limiting factor determining ultimate success and acceptance of environment generators. In this paper we describe the design and implementation of a meta-environment (a development environment for formal language definitions) based on the formalism ASF + SDF. This meta-environment is currently being implemented as part of the Centaur system and is, at least partly, obtained by applying environment generation techniques to the language definition formalism itself. A central problem is providing fully interactive editing of modular language definitions such that modifications made to the language definition during editing can be translated immediately to modifications in the programming environment generated from the original language definition. Therefore, some of the issues addressed are the treatment of formalisms with user-definable syntax and incremental program generation techniques.
Functional database query languages as typed lambda calculi of fixed order (extended abstract)
Authors: Gerd G. Hillebrand, Paris C. Kanellakis
Venue: Proceedings of the thirteenth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1994)

We present a functional framework for database query languages, which is analogous to the conventional logical framework of first-order and fixpoint formulas over finite structures. We use atomic constants of order 0, equality among these constants, variables, application, lambda abstraction, and let abstraction; all typed using fixed order (&le; 5) functionalities. In this framework, proposed in [21] for arbitrary order functionalities, queries and databases are both typed lambda terms, evaluation is by reduction, and the main programming technique is list iteration. We define two families of languages: TLI=i or simply-typed list iteration of order i+3 with equality, and MLI=i or ML-typed list iteration of order i+3 with equality; we use i+3 since our list representation of databases requires at least order 3. We show that: FO-queries &sube;TLI=0 &sube;MLI=0 &sube;LOGSPACE-queries &sube;TLI=1 =MLI=1 = PTIME-queries &sube; TLI2, where equality is no longer a primitive in TLI2. We also show that ML type inference, restricted to fixed order, is polynomial in the size of the program typed. Since programming by using low order functionalities and type inference is common in functional languages, our results indicate that such programs suffice for expressing efficient computations and that their ML-types can be efficiently inferred.
Dyn-FO (preliminary version): a parallel, dynamic complexity class
Authors: Sushant Patnaik, Neil Immerman
Venue: Proceedings of the thirteenth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1994)

Traditionally, computational complexity has considered only static problems. Classical Complexity Classes such as NC, P, NP, and PSPACE are defined in terms of the complexity of checking&mdash;upon presentation of an entire input&mdash;whether the input satisfies a certain property.For many, if not most, applications of computers including: databases, text editors, program development, it is more appropriate to model the process as a dynamic one. There is a fairly large object being worked on over a period of time. The object is repeatedly modified by users and computations are performed.Thus a dynamic algorithm for a certain class of queries is one that can maintain an input object, e.g. a database, and process changes to the database as well as answering queries about the current database.Here, we introduce the complexity class, Dynamic First-Order Logic (Dyn-FO). This is the class of properties S, for which there is an algorithm that can perform inserts, deletes and queries from S, such that each unit insert, delete, or query is first-order computable. This corresponds to the sets of properties that can be maintained and queried in first-order logic, i.e. relational calculus, on a relational database.We investigate the complexity class Dyn-FO. We show that many interesting properties are in Dyn-FO including, among others, graph connectivity, k-edge connectivity, and the computation of minimum spanning trees. Furthermore, we show that several NP complete optimization problems admit approximation algorithms in Dyn-FO. Note that none of these problems is in static FO, and this fact has been used to justify increasing the power of query languages beyond first-order. It is thus striking that these problems are indeed dynamic first-order, and thus, were computable in first-order database languages all along.We also define &ldquo;bounded expansion reductions&rdquo; which honor dynamic complexity classes. We prove that certain standard complete problems for static complexity classes, such as AGAP for P remain complete via these new reductions. On the other hand, we prove that other such problems including GAP for NL and 1GAP for L are no longer complete via bounded expansion reductions. Furthermore, we show that a version of AGAP called AGAP+ is not in Dyn-FO unless all of P is contained in parallel linear time.Our results shed light on some of the interesting differences between static and dynamic complexity.
An optimal algorithm for the two-guard problem
Authors: Paul J. Heffernan
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

In this paper we give optimal solutions for two versions of the two-guard problem. Given a simple polygon P with vertices s and t, the straight walk problem asks whether we can move two points monotonically on P from s to t, one clockwise and one counterclockwise, such that the points are always co-visible. In the counter walk problem, both points move clockwise, one from s to t and the other from t to s. We provide &THgr;(n) constructive algorithms for both problems. We obtain our results by examining the structure of the restrictions placed on the motion of the two points, and by employing properties of shortest paths and shortest path trees.
Computer aided conversation for severely physically impaired non-speaking people
Authors: Norman Alm, John Todman, Leona Elder, A. F. Newell
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

This paper reports the development of a computer-aided conversation prosthesis which is designed for severely physically impaired non-speaking people. The research methodology was to model aspects of conversational structure derived from the field of conversation analysis within a prototype conversational prosthesis. The prototype was evaluated in empirical investigations which also suggested successful strategies for carrying out satisfying conversation using such a system. Two versions have been built and tested, one using an able-bodied operator to test the feasibility of creating conversation from prestored material, the second being used by a physically impaired non-speaking operator. The prototype demonstrated the advantages of this interface design in helping the user to carry out natural sounding and satisfying conversations.
History of the Icon programming language
Authors: Ralph E. Griswold
Venue: The second ACM SIGPLAN conference on History of programming languages (1993)

The Icon programming language, which was conceived in 1977, was strongly influenced by the earlier SNOBOL languages and the subsequent SL5. This paper concentrates primarily on the early development of Icon, but also discusses subsequent versions. The motivation, design philosophy, and environmental factors that shaped Icon are emphasized in this paper.
Design considerations in choosing operations for building groupware systems (abstract)
Authors: Atul Prakash, Michael J. Knister
Venue: ACM SIGOIS Bulletin (1993)

We report our experiences from building a prototype toolkit, called DistEdit, for building interactive group editors in distributed environments. Based on our experience in building the toolkit, we found that some design solutions that are commonly used in single-user editors are not necessarily appropriate in group editors. Furthermore, design of group editors requires a better understanding of the semantics of editing operations than in the corresponding single-user editors. These semantics are useful for providing a variety of services, such as undo, concurrency control, and selective replay. This position paper is presented in the context of text editors; however, many of the ideas presented here also apply to other types of group editors.
Continuation-based partial evaluation
Authors: Julia L. Lawall, Olivier Danvy
Venue: ACM SIGPLAN Lisp Pointers (1994)

Binding-time improvements aim at making partial evaluation (a.k.a. program specialization) yield a better result. They have been achieved so far mostly by hand-transforming the source program. We observe that as they are better understood, these hand-transformations are progressively integrated into partial evaluators, thereby alleviating the need for source-level binding-time improvements.Control-based binding-time improvements, for example, follow this pattern: they have evolved from ad-hoc source-level rewrites to a systematic source-level transformation into continuation-passing style (CPS). Recently, Bondorf has explicitly integrated the CPS transformation into the specializer, thus partly alleviating the need for source-level CPS transformation. This CPS integration is remarkably effective but very complex and goes beyond a simple CPS transformation. We show that it can be achieved directly by using the control operators shift and reset, which provide access to the current continuation as a composable procedure.We automate, reproduce, and extend Bondorf's results, and describe how this approach scales up to hand-writing partial-evaluation compilers. The first author has used this method to bootstrap the new release of Consel's partial evaluator Schism. The control operators not only allow the partial evaluator to remain in direct style, but also can speed up partial evaluation significantly.
What's special about spatial?: database requirements for vehicle navigation in geographic space
Authors: Max J. Egenhofer
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Geographic databases are becoming a popular subject for research projects. It is acknowledged that database requirements for such applications as Geographic Information Systems (GISs), computer cartography, remote-sensing image databases, and emergency routing/dispatching are distinct from those for traditional database applications; however, the specific database needs due to the properties of geographic data are frequently overlooked. Here, we describe a specific problem domain, a vehicle navigation system, and analyze the properties of data to be modeled appropriately and managed efficiently by database management systems. Vehicle navigation systems need continuous, fast access to very large databases. Through the combination of real-time access and geographic data, we identify particularly challenging database requirements of this application with respect to data models, query languages, and query processing.
Supporting dynamic displays using active rules
Authors: Oscar Díaz, Arturo Jaime, Norman W. Paton, Ghassan al-Qaimari
Venue: ACM SIGMOD Record (1994)

In a graphical interface which is used to display database objects, dynamic displays are updated automatically as modifications occur to the database objects being visualised. Approaches based on enlarging either the database system or the interface code to provide the appropriate communication, complicates the interaction between the two systems, as well as making later updates cumbersome. In this paper, an approach based on active rules is presented. The declarative and modular description of active rules enables active displays to be supported with minimal changes to the database or its graphical interface. Although this approach has been used to support the link between a database system and its graphical interface, it can easily be adapted to support dynamic interaction between an active database system and other external systems.
Extending the IP internet through address reuse
Authors: Paul F. Tsuchiya, Tony Eng
Venue: ACM SIGCOMM Computer Communication Review (1993)

The two most compelling problems facing the IP Internet are IP address depletion and scaling in routing. This paper discusses the characteristics of one of the proposed solutions---address reuse. The solution is to place Network Address Translators (Nat) at the borders of stub domains. Each Nat box has a small pool of globally unique IP addresses that are dynamically assigned to IP flows going through Nat. The dynamic assignment is coordinated with Domain Name Server operation. The IP addresses inside the stub domain are not globally unique---they are reused in other domains, thus solving the address depletion problem. The pool of IP addresses in Nat is from a subnet administered by the regional backbone, thus solving the scaling problem. The main advantage of Nat is that it can be installed without changes to any existing systems, although FTP will fail in some but not all cases. This paper presents a preliminary design for Nat, and discusses its pros and cons.
The HCV induction algorithm
Authors: Xindong Wu
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

HCV is a heuristic attribute-based induction algorithm based on the newly-developed extension matrix approach. By dividing the positive examples (PE) of a specific class in a given example set into intersecting groups and adopting a set of strategies to find a heuristic conjunctive formula in each group which covers all the group's positive examples and none of the negative examples (NE), it can find a covering formula in form of variable-valued logic for PE against NE in low-order polynomial time. This paper presents the HCV algorithm in detail and provides a performance comparison of HCV with other inductive algorithms such as ID3 and AQ11.
Exploding the interface: experiences of a CSCW network
Authors: John Bowers, Tom Rodden
Venue: Proceedings of the INTERACT '93 and CHI '93 conference on Human factors in computing systems (1993)

The development of human computer interaction has been dominated by the interface both as a design concept and as an artefact of computer systems. However, recently researchers have been re-examining the role of the interface in the user's interaction with the computer. This paper further examines the notion of the interface in light of the experiences of the authors in establishing a network to support cooperative work. The authors argue that the concept of the single interface which provides a focus for interaction with a computer system is no longer tenable and that richer conceptions of the inter-relationships between users and computer systems are needed.
An experience of representing knowledge and data in mechanical design using Smalltalk-80
Authors: Deyi Xue
Venue: ACM SIGPLAN OOPS Messenger (1994)

The experience of representing design knowledge and data in developing an intelligent design system for mechanical devices using the object oriented programming language --- Smalltalk-80 is summarized in this paper. Many object oriented programming techniques, especially the representation of inheritance and class-instance relations, are used for representing the design knowledge and data within the system. The characteristics of Smalltalk-80, including its rapid prototyping and large library properties, make it an excellent tool for this application. It is concluded from this work that object oriented programming language is a good tool for modeling design objects and for representing design knowledge.
Software Project Control: An Experimental Investigation of Judgment with Fallible Information
Authors: Tarek K. Abdel-Hamid, Kishore Sengupta, Daniel Ronan
Venue: IEEE Transactions on Software Engineering (1993)

Software project management is becoming an increasingly critical task in many organizations. While the macro-level aspects of project planning and control have been addressed extensively, there is a serious lack of research on the micro-empirical analysis of individual decision making behavior. The heuristics deployed to cope with the problems of poor estimation and poor visibility that hamper software project planning and control are investigated, and the implications for software project management are examined. A laboratory experiment in which subjects managed a simulated software development project is reviewed. The subjects were given project status information at different stages of the lifecycle and had to assess software productivity in order to dynamically readjust project plans. A conservative anchoring and adjustment heuristic is shown to explain the subjects' decisions quite well. Implications for software project planning and control are presented.
Self-stabilization
Authors: Marco Schneider
Venue: ACM Computing Surveys (CSUR) (1993)

In 1973 Dijkstra introduced to computer science the notion of self-stabilization in the context of distributed systems. He defined a system as self-stabilizing when &ldquo;regardless of its initial state, it is guaranteed to arrive at a legitimate state in a finite number of steps.&rdquo; A system which is not self-stabilizing may stay in an illegitimate state forever. Dijkstra's notion of self-stabilization, which originally had a very narrow scope of application, is proving to encompass a formal and unified approach to fault tolerance under a model of transient failures for distributed systems. In this paper we define self-stabilization, examine its significance in the context of fault tolerance, define the important research themes that have arisen from it, and discuss the relevant results. In addition to the issues arising from Dijkstra's original presentation as well as several related issues, we discuss methodologies for designing self-stabilizing systems, the role of compilers with respect to self-stabilization, and some of the factors that prevent self-stabilization.
Scheduling parallel I/O operations
Authors: Ravi Jain, Kiran Somalwar, John Werth, J. C. Browne
Venue: ACM SIGARCH Computer Architecture News (1993)

The I/O bottleneck in parallel computer systems has recently begun receiving increasing interest. Most attention has focused on improving the performance of I/O devices using fairly low-level parallelism in techniques such as disk striping and interleaving. Widely applicable solutions, however, will require an integrated approach which addresses the problem at multiple system levels, including applications, systems software, and architecture. We propose that within the context of such an integrated approach, scheduling parallel I/O operations will become increasingly attractive and can potentially provide substantial performance benefits.We describe a simple I/O scheduling problem and present approximate algorithms for its solution. The costs of using these algorithms in terms of execution time, and the benefits in terms of reduced time to complete a batch of I/O operations, are compared with the situations in which no scheduling is used, and in which an optimal scheduling algorithm is used. The comparison is performed both theoretically and experimentally. We have found that, in exchange for a small execution time overhead, the approximate scheduling algorithms can provide substantial improvements in I/O completion times.
Top management support in small business information systems implementation: how important is it?
Authors: James Y. L. Thong, Chee-Sing Yap, K. S. Raman
Venue: Proceedings of the 1993 conference on Computer personnel research (1993)

The importance of top management support in information systems (IS) implementation has been emphasized in previous IS studies. But, is it really that important? This paper describes an empirical investigation of the influence of CEO support on IS effectiveness in 114 small businesses. The results show that CEO support has a significantly positive impact on IS effectiveness. However, irrespective of the level of CEO support, external technical expertise, in the forms of consultants and vendors, has a greater impact on IS effectiveness. This finding suggests that the lack of quality technical expertise is more critical than the level of CEO support in small business IS implementation.
Proofs by structural induction using partial evaluation
Authors: Julia L. Lawall
Venue: Proceedings of the 1993 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation (1993)

In this paper we show how partial evaluation can be used in developing proofs about program transformations. Partial evaluation is particularly appropriate for this task because it distinguishes between static and dynamic data. As a realistic example of this technique we prove a theorem arising in our earlier study of the CPS transformation. Our approach requires a partial evaluator that supports the following features: resugaring, partially-static structures, higher-order functions, polyvariance, and filters. In particular, we use Consel's partial evaluator Schism.
Achieving Higher SEI Levels
Authors: Michael K. Daskalantonakis
Venue: IEEE Software (1994)

Two years or more can pass between formal SEI (Software Engineering Institute) assessments using the Capability Maturity Model (CMM). An organization seeking to monitor its progress to a higher SEI level needs a method for internally conducting incremental assessments. The author provides one that has proven successful at Motorola. A method was developed for assessing progress to higher SEI levels that lets engineers and managers evaluate an organization's current status relative to the CMM and identify weak areas for immediate attention and improvement. This method serves as an effective means to ensure continuous process improvement as well as grassroots participation and support in achieving higher maturity levels. This progress-assessment process is not intended as a replacement for any formal assessment instruments developed by the SEI, but rather as an internal tool to help organizations prepare for a formal SEI assessment. Although the author provides examples in terms of CMM version 1.1, both the self-evaluation instrument and the progress-assessment process are generic enough for use with any (similar) later version of the SEI CMM by updating the worksheets and charts used.
Tag-free garbage collection using explicit type parameters
Authors: Andrew Tolmach
Venue: ACM SIGPLAN Lisp Pointers (1994)

We have constructed a practical tag-free garbage collector based on explicit type parameterization of polymorphic functions, for a dialect of ML. The collector relies on type information derived from an explicitly-typed 2nd-order representation of the program, generated by the compiler as a byproduct of ordinary Hindley-Milner type inference. Runtime type manipulations are performed lazily to minimize execution overhead. We present details of our implementation approach, and preliminary performance measurements suggesting that the overhead of passing type information explicitly can be made acceptably small.