Search

Programs often consist of parts that are written in different languages because sub-problems lend themselves to being implemented in a particular language. However, multi-language programs often suffer from poor performance, complex cross-language interfaces, or insufficient flexibility. We propose a novel approach for composing multiple language implementations in a seamless way. Foreign objects of one language can be used like regular objects in another language. Our interoperability mechanism targets language implementations that run on the same VM and have the same style of intermediate representation (IR), e.g., an abstract syntax tree (AST). For accessing foreign objects we generate foreign-language-specific IR patterns that we insert into the IR of the host application. Thus we avoid converting or marshalling foreign objects at the language border. Our mechanism also allows the just-in-time compiler of the host VM to inline and optimize across language borders.

In facility management for plants and buildings, needs of facility diagnosis for saving energy or facility management cost by analyzing time series data from sensors of equipments in facilities have been increasing. This paper proposes a relation-based stream query language TPQL (Trend Pattern Query Language) for expressing constraints in time series data for anomalies detection in facilities. The features of TPQL are the following. (1) TPQL introduces a convolution operator into a stream query language in order to describe constraints over sliding window. A convolution operator which takes a window function as an argument can express various domain dependent functions extracting feature over sliding windows such as duration constraint and hunting constraint. (2) TPQL introduces time-interval based join into stream query language in order to join time series data with different sampling rates.

A range of context-management systems in the past have motivated the need for development support of context-aware applications. They typically provide APIs and query languages for context analysis. Reacting to context changes, however, is either not at all or only to a limited extend supported by adhering to constraints of a framework.In this paper, we present a context-management system that combines context reasoning with context-dependent behavior by taking advantage of language approaches to dynamic adaptation, such as aspect- and context-oriented programming. Our framework is open for different levels of integration with programming language extensions and offers a dynamic, strategy-based aggregation of local and distributed context sources. As a first step, we implemented a query library for the JCop language. We present its API and show the implementation of an example application.

This paper describes XSQirrel, a new XML query language that transforms a document into a sub-document, i.e. a tree where the root-to-leaf paths are a subset of the root-to-leaf paths from the original document.We show that this type of queries is extremely useful for various applications (e.g. web services) and that the currently existing query languages are poorly equipped to express, reason and evaluate such queries. In particular, we emphasize the need to be able to compose such queries. We present the XSQirrel language with its syntax, semantics and two language specific operators, union and composition.For the evaluation of the language, we leverage well established query technologies by translating XSQirrel expressions into XPath programs, XQuery queries or XSLT stylesheets.We provide some experimental results that compare our various evaluation strategies. We also show the runtime benefits of query composition over sequential evaluation.

The paper presents our researches in formation of methodology for accomplishment database management system with a restricted Bulgarian natural language interface. It is proposed a method for formulation of the query constructions in a restricted Bulgarian natural language, which is based on the elegant theory of the relational algebra. Within the framework of researches it is introduced system tools for formulation of the user's query. It is proposed an algorithm for response generation, which includes semantic analysis of a user's query and method for direct access to data.

The paper proposes a three-dimensional matrix model for representation of entities, attributes, relationships and attribute values of databases in order to access them through menus with predefined fields when posing queries.It is discussed that the databases, described by the proposed model can be synonymously defined by the structures, used in the modern object-oriented programming languages, such as classes, objects and dynamical arrays.

The development of the artificial intelligence techniques, the multimedia and Internet technologies increase the interest to new computer-based teaching and learning systems. This paper presents an internal declarative language implemented in a multimedia knowledge-testing system. The focus of the paper is on the environment architecture as well as the syntax and semantic of the proposed language.

While much recent research has focussed on extending databases beyond the traditional relational model, relatively little has been done to develop database tools for querying data organized in (multidimensional) arrays. The scientific computing community has made little use of available database technology. Instead, multidimensional scientific data is typically stored in local files conforming to various data exchange formats and queried via specialized access libraries tied in to general purpose programming languages.To allow such data to be queried using known database techniques, we design and implement a query language for multidimensional arrays. Our main design decision is to treat arrays as functions from index sets to values rather than as collection types. This leads to clean syntax and semantics as well as simple but powerful optimization rules.We present a calculus for arrays that extends standard calculi for complex objects. We derive a higher-level comprehension style query language based on this calculus and describe its implementation, including a data driver for the NetCDF data exchange format. Next, we explore some optimization rules obtained from the equational laws of our core calculus. Finally, we study the expressiveness of our calculus and prove that it essentially corresponds to adding ranking to a query language for complex objects.

A new kind of data model has recently emerged in which the database is not constrained by a conventional schema. Systems like ACeDB, which has become very popular with biologists, and the recent Tsimmis proposal for data integration organize data in tree-like structures whose components can be used equally well to represent sets and tuples. Such structures allow great flexibility y in data representation.What query language is appropriate for such structures? Here we propose a simple language UnQL for querying data organized as a rooted, edge-labeled graph. In this model, relational data may be represented as fixed-depth trees, and on such trees UnQL is equivalent to the relational algebra. The novelty of UnQL consists in its programming constructs for arbitrarily deep data and for cyclic structures. While strictly more powerful than query languages with path expressions like XSQL, UnQL can still be efficiently evaluated. We describe new optimization techniques for the deep or "vertical" dimension of UnQL queries. Furthermore, we show that known optimization techniques for operators on flat relations apply to the "horizontal" dimension of UnQL.

We present a model for querying textual databases by both the structure and contents of the text. Our goal is to obtain a query language which is expressive enough in practice while being efficiently implementable, features not present at the same time in previous work. We evaluate our model regarding expressivity and efficiency. The key idea of the model is that a set-oriented query language based on operations on nearby structure elements of one or more hierarchi es is quite expressive and efficiently implementable, being a good tradeoff between both goals.

The full integration of information retrieval (IR) features into a database management system (DBMS) has long been recognized as both a significant goal and a challenging undertaking. By full integration we mean: i) support for document storage, indexing, retrieval, and update, ii) transaction semantics, thus all database operations on documents have the ACID properties of atomicity, consistency, isolation, and durability, iii) concurrent addition, update, and retrieval of documents, and iv) database query language extensions to provide ranking for document retrieval operations. It is also necessary for the integrated offering to exhibit scaleable performance for document indexing and retrieval processes, To identify the implementation requirements imposed by the desired level of integration, we layered a representative IR application on Oracle Rdb and then conducted a number of database load and document retrieval experiments. The results of these experiments suggest that infrastructural extensions are necessary to obtain both the desired level of IR integration and scaleable performance. With the insight gained from our initial experiments, we developed an approach, called cooperative indexing, that provides a framework to achieve both scalability and full integration of IR and RDBMS technology. Prototype implementations of system-level extensions to support cooperative indexing were evaluated with a modified version of Oracle Rdb. Our experimental findings validate the cooperative indexing scheme and suggest alternatives to further improve performance.

We present a general purpose query interface for inexpert users based on the manipulation of icons. The user perceives the reality of interest as structured in classes and attributes while the system internally maintains a schema rich of semantic information. The query language, fully visual, is based on the select and project paradigm that has been proven to be easy to understand. No path specification is required for composing a query. Automatic feedbacks based on natural language generation and cardinality constraints analysis help the user in specifying his/her requests.

We present a language for querying list-based complex objects. The language is shown to express precisely the polynomial-time generic list-object functions. The iteration mechanism of the language is based on a new approach wherein, in addition to the list over which the iteration is performed, a second list is used to control the number of iteration steps. During the iteration, the intermediate results can be moved to the output list as well as reinserted into the list being iterated over. A simple syntactic constraint allows the growth rate of the intermediate results to be tightly controlled which, in turn, restricts the expressiveness of the language to PTIME.

Data-parallelism provides a clean conceptual framework for parallel programming. We are developing two programming languages: a high level equational language, called EL*, and a low-level implementation language. Both languages exploit data-parallelism instead of control-parallelism. EL* is a declarative data-parallel language. EL* programs are high-level equational specifications that use extensive pattern-matching and recursion. The language's syntax and semantics are intended to be clear and simple. Recursive forms are restricted to enable translation to efficient data-parallel operations. EL* programs are compiled into FP*, a variant of Backus's FP, where parallel operations are more explicit and low-level. The target language has a rich set of functions for performing communication, and computation. It also has a powerful set of combining forms that generate large highly-parallel functions from smaller program units. Prototype compilers have been implemented for both languages, and they demonstrate good performance. Several linear algebra and non-numeric problems have been programmed with relative ease using EL*. We are currently developing compilation techniques for a wider range of scientific problems that have more complex parallel solutions, and are continuing to expand the language's scope.

Many object-oriented programming language implementations have been extended to support persistence, distribution or atomicity by integrating the necessary additional support with the language''s runtime library. We argue that a better approach is to provide a Generic Runtime library (the GRT) which implements that part of the support which is independent of any language. The GRT should be designed to interface to a language''s existing runtime in such a way that the language''s local object reference format and invocation mechanism can be retained. Hence existing compilers do not necessarily have to be modified, and a range of different object-oriented languages can be supported simultaneously. This approach has significant merits including: the ease with which a language can be extended; the sophistication of the underlying support immediately available to a language implementer; and the ability to support fine-grained language interworking.

We demonstrate the benefits of applying high-level language paradigms to the design and implementation of communications software for distributed systems. We focus on a set of language mechanisms including modularity and first class functions. We discuss three case studies: a remote procedure call system, a distributed Linda system, and a protocol processing system. The qualitative and quantitative benefits of such a structured use of high-level language mechanisms are analyzed and applied as the basis of a programming methodology for distributed systems

Most natural language based document retrieval systems use the syntax structures of constituent phrases of documents as index terms. Many of these systems also attempt to reduce the syntactic variability of natural language by some normalisation procedure applied to these syntax structures. However, the retrieval performance of such systems remains fairly disappointing. Some systems therefore use a meaning representation language to index and retrieve documents. In this paper, a system is presented that uses Horn Clause Logic as meaning representation language, employs advanced techniques from natural Language Processing to achieve incremental extensibility, and uses methods from Logic Programming to achieve robustness in the face of insufficient data.

Following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identified several key problems in the design of a concurrency model compatible with the mechanisms of object-oriented programming. We propose an approach to language design in which an executable notation describing the behaviour of communicating agents is extended by syntactic patterns that encapsulate language constructs. We indicate how various language models can be accommodated, and how mechanisms such as inheritance can be modeled. Finally, we introduce a new notion of types that characterizes concurrent objects in terms of their externally visible behaviour.

A natural language interface built for a task-oriented activity is described. The activity is operator control of equipment as required by a multi-robot experiment. TODUS, a Task-Oriented Discourse Understanding System, is an utterance-based natural language understanding system with extensive linguistic coverage. It is compact, efficient, runs on a popular PC chip and accepts spoken language. TODUS' novel architecture, an annotated session transcript and implementation data are provided. Various mechanisms which support natural language task dialog are discussed and future plans are presented.

This paper explores the use of commands in a query language as an abstract data type (ADT) in data base management systems Basically, an ADT facility allows new data types, such as polygons, lines, money, time, arrays of floating point numbers, bit vectors, etc, to supplement the built-in data types in a data base system. In this paper we demonstrate the power of adding a data type corresponding to commands in a query language We also propose three extensions to the query language QUEL to enhance its power in this augmented environment.

The query optimizer is an important system component of a relational database management system (DBMS). It is the responsibility of this component to translate the user-submitted query - usually written in a non-procedural language - into an efficient query evaluation plan (QEP) which is then executed against the database. The research literature describes a wide variety of optimization strategies for different query languages and implementation environments. However, very little is known about how to design and structure the query optimization component to implement these strategies. This paper proposes a first step towards the design of a modular query optimizer . We describe its operations by transformation rules which generate different QEPs from initial query specifications. As we distinguish different aspects of the query optimization process, our hope is that the approach taken in this paper will contribute to the more general goal of a modular query optimizer as part of an extensible database management system.

One need not create a natural language understanding system in order to create a hypertext data base that can be traversed with unconstrained natural language. The task is simplified because the computer creates a constrained context, imposes a non-negotiable topic, and elicits simple questions. Two small hypertext data bases describing the authors' organization and the terms and rules of baseball were implemented on an IBM PC. When ten untrained people were allowed to search through these data bases, 59 per cent of their queries were answered correctly by the first data base and 64 per cent by the second.

In the framework of an application dealing with classified advertisement matching, a dedicated user interface has been designed and implemented. Its major originality relies on the user's language which is neither an artificial one, nor the usual natural language, but in fact the ad language. Beyond the language itself, the interface provides some facilities such as paraphrasing or explanations when needed. An expert system approach has been adopted and the interface is built up from the knowledge given by experts. They are in charge of describing what are acceptable ads, from both syntax and semantics points of view … Although designed in the context of ad matching, that interface may interestingly be adapted to other retrieving systems. We especially think that an adlike language is well-suited to ask questions since it is based on natural simple expressions. A given sentence involves terms that stand for elementary conditions applying to instances of a logical object contained inside the information system. This approach defines a complete interface, involving both a language and aiding capabilities. Moreover, the query language, although less powerful, represents a compromise between artificial languages and the usual natural language, with respect to ergonomics and analysis complexity.

Recently, attention has been focused on temporal databases , representing an enterprise over time. We have developed a new language, Tquel , to query a temporal database. TQuel was designed to be a minimal extension, both syntactically and semantically, of Quel, the query language in the Ingres relational database management system. This paper discusses the language informally, then provides a tuple relational calculus semantics for the TQuel statements that differ from their Quel counterparts, including the modification statements. The three additional temporal constructs defined in Tquel are shown to be direct semantic analogues of Quel's where clause and target list. We also discuss reducibility of the semantics to Quel's semantics when applied to a static database. TQuel is compared with ten other query languages supporting time.

The End-User Friendly Interface to Data Management (EUFID) is a processing system of programs which permits users to query a database in a natural English-like way. The EUFID system translates the user's question into a query expressed in the query language of the target DataBase Management System (DBMS). EUFID makes use of two very different views of the applications data: that of the users, and that of the DBMS. This paper describes the mapping of query statements from one view to the other. Mapping is discussed in general terms as well as in terms of the specific algorithms of EUFID. Examples are given.

This paper describes a prototype DBMS, called VERTUR, which supports relational data structures and can be used inter-actively through a query language. The query language referred to as TURDIL is based on Turkish Language and is defined by a regular grammar. VERTUR has a fully integrated data dictionary which contains definitions of relations and user-views based on relations, along with information on data-access privileges.

Query-by-Example is a query language for use by non-programmers querying a relational data base. In an earlier paper, the features of this language were introduced; however, it was assumed that the data base was already defined and available to the user.In the first part of this paper we demonstrate that the operations of Query-by-Example can be used not only to query the data base but also to define it, including data descriptions and declarations of various integrity constraints. This is an attempt to provide the user with a simplified, unified interface for a variety of functions.In the second part of this paper it is shown how one can make preliminary interrogations to retrieve a subset of the data base needed for the formulation of a specific query. This becomes very useful in cases where the data-base is very large and the user's initial task of scanning the tables for the ones relevant to his specific query becomes by itself horrendous.

DIAL is a problem-oriented and high-level programming language oriented towards database applications. It integrates into a unified framework database primitives and computational facilities, so that an application programmer will deal with a single coherent language. The design of DIAL is based on the premise that in order to have a meaningful impact on the construction of application software, a database programming language should eschew generality and focus on what is unique about the application domain in question. To that end, DIAL seeks to embody features that naturally express the most common and frequently recurring patterns encountered in database applications programs.A number of its features distinguish DIAL from other contemporary related efforts. Data description plays a primary role in DIAL, in that a substantial amount of application semantics is expressed in the database schema rather than in procedure definitions; to achieve this end, DIAL employs a higher-level data model (the SDM) as its data description mechanism. Facilities for conducting user-system dialogues are also embedded in the language. Specialized control structures are provided to allow for succinct and direct expression of the algorithmic structure of procedures that utilize the database. High-level mechanisms (called controllers) are used to specify an application system's required behavior in the face of multiple concurrent users and aborted transactions.DIAL has been applied to two realistic and substantial systems, a purchasing application and a job-shop scheduler. Continued validation studies of the language are underway, as are an implementation effort and the design of an allied program development system.

A major thrust of artificial intelligence research is how to build knowledge of the application domain into computer systems. We investigate how the user himself can introduce his own expert knowledge into his data base system through rapid language extension so that it may then respond intelligently to his curt queries and commands.Illustrations of rapid language extension using the REL System are presented and discussed.

A generalized high level query language has been developed for use with a network data base, as defined by the CODASYL DBTG report. Of particular interest is the capability of manipulating graphical entities with this language. The system was developed to supportan offshore oil lease information project where one must formulate queries pertaining to proximity of graphical entities. To facilitate such requests new relational operators were defined and implemented. Thus compound Boolean expressions can be formed which involve graphical as well as non-graphical criteria. Since one goal of the information system is to produce selectively colored maps via an FR80 microfilm recorder, the query language syntax provides the user with a comprehensive thematic cartography capability. The query language is designed to isolate the user from the underlying network structure of the data base. In order to accomplish this generalized pathfinding and accessing algorithms had to be developed. Pathfinding is facilitated through an adjacency matrix involving all record types in the data base, while accession is controlled by examining the local owner-member relation for current record types. Besides querying, the system provides the usual complement of data base management system functions, i.e. deletion, updating, reporting, etc.

Natural Language questions differ from most existing formal query languages in that they tend to admit a wider range of responses than their formal counterparts, and provide cues for selecting among the variety of appropriate responses. These differences reflect the fact that in Natural Language conversation, a respondent is expected to take an active role in the process of selecting and organizing responses, in contrast to formal query systems, where control of the interaction typically resides with the user or applications program. This paper explores some specific ways in which Natural Language questions are particularly well suited for their environment, and discusses the potential role of similar capabilities in formal query systems, particularly with respect to Natural Language Data Base query systems.

The programming language PLAIN has been designed to support the construction of interactive information systems within the framework of a systematic programming methodology. One of the key goals of PLAIN has been to achieve an effective integration of programming language and database management concepts, rather than either the functional interface to database operations or the low-level database navigation operations present in other schemes. PLAIN incorporates a relational database definitional facility, along with low-level and high-level operations on relations. This paper describes those features informally, showing how the database operations are combined with programming language notions such as type checking, block structure, expression evaluation, and iteration. A brief description of the implementation status is included.

Regular Expression Compiler (REC) is a programming language of extremely simple structure. It is a goto-less language which has very appealing transfer of control operations. It is a generalized language which can be implemented for special purpose applications by a proper choice of operators and predicates. This paper describes REC language and one of its "symbol manipulation" implementations, REC/SM. The language has been enormously successful from the users satisfaction point of view. And like BLISS, it has once again proved that the well-publicized inconvenience of programming without a goto is a myth.

We see a trend toward extending object-oriented languages in the direction of databases, and, at the same time, toward extending database systems with object-oriented ideas. On the surface, these two activities seem to be moving in a consistent direction. However, at a deeper level, we see difficulties that may inhibit their ending up at the same point. We feel that many of these difficulties are a result of the underlying assumptions that are inherent in the fields of programming language and database systems research. Many of these assumptions are historical and contribute to a set of cultural biases that often prevent the two communities from interacting as effectively as possible. The purpose of this paper is to try to uncover some of the cultural presuppositions that have inhibited development of a fully integrated database programming language. We have identified database and language features that seem to be difficult to reconcile. We try to uncover the basic problems in these two areas that these features were intended to solve. In order to resolve these problems, we attempt to distinguish fundamental differences from historical artifacts.

This paper describes how a general purpose programming language supporting the notion of data abstraction can be used as a data definition and manipulation language for database management systems. The examples used here are based on a functional data model and on a database system called NDB. However, the approach is not limited to or biased towards any particular data model or architecture. The strong typing properties of the data abstraction language are carried over to the realm of database manipulation operations and provide useful consistency checking. The advantage of the approach is that the user deals with but one database programming language, thereby avoiding a separate query and host language.

A great deal of interest has developed in structured programming [Dahl, Dijkstra, and Hoare, 1972] during the past few years. This paper is concerned with some experiences obtained in the use of a structured programming language in the computer science curriculum at the University of Maryland. The language used was SIMPL-X [Basili, 1973], a language designed and implemented at the University of Maryland. SIMPL-X was designed to be a transportable, extendable, compiler-writing language that was to be the base language for a family of programming languages. It is, in fact, being used for that purpose as the SIMPL-X compiler [Basili and Turner, 1973] is written in SIMPL-X, and a compiler for the graph algorithmic language GRAAL [Rheinboldt, Basili, and Mesztenyi, 1972] is presently being designed as an extension of the SIMPL-X compiler.

This paper presents a graphical query language for semantic data models. This language is based on a generic semantic model. It is integrated in the CANDID system, which is a graphical interface fur the manipulation of databases. Any schema is represented by a graph divided into families of object types. The graphical query language makes it possible to express a request by describing with a graph an object solution of the request. A request is sometimes expressed in several stages. A stage corresponds to the expression of a simpler subrequest. This language is also characterized by the absence of boolean operators and quantifiers, which are replaced by manipulations on Venn diagrams. Since a request in fact defines derived elements, almost all of a request can be incorporated into the schema. CANDID has been designed to be adapted to any DBMS which has deduction mechanisms.

Machine language decompilation is the translation of machine (assembly) language instruction sequences into statements in a high-level algebraic language such as PL/1. This process can be viewed as the inverse of compilation. Decompilation can be used as an aid for program conversion and program documentation. A general methodology for decompilation that is independent of a particular source and target language is presented. The basic approach is to map the source machine language to a high-level representation, which is relatively machine and language independent, and then translate to the chosen target language. An experimental decompiler was implemented to translate Knuth's MIXAL assembly language into PL/1.

The paper describes the application of automatic program generation methodology in generating file conversion programs. The system, accepts as input descriptions of source and target files in a Data Description Language (DDL) and data manipulation specifications in a Data Manipulation Language (DML). It produces as an output a conversion program in PL/1 capable of converting the source file and producing the target file.

The Hierarchic Query Language (HQL) is a sophisticated query language designed to give "non-programmers" convenient access to the data contained within an IMS-like hierarchic data base. In this paper we outline a particular perception of transactions against collections of data arranged in a hierarchic structure, and show how that perception might be reflected in the syntax and semantics of a user-oriented query language.

This paper describes the structure and implementation of an interactive list processing language so small that its interpreter can be programmed in a few days but powerful enough to allow definition of many high level language features. Since its programs are executed by a threaded sequence of machine language routines, the system is suitable for efficient implementation on microcomputers, and possibly even in hardware.