Search

One key aspect of data-centric applications is the manipu- lation of persistent data repositories, which is moving fast from querying a centralized relational database to the ad- hoc combination of constellations of data sources. Query languages are being typefuly integrated in host, general purpose, languages in order to increase reasoning and optimizing capabilities of interpreters and compilers. However, not much is being done to integrate and orches- trate different and separate sources of data. We present a common data manipulation language, that abstracts the nature and localization of the data-sources. We define its semantics and a type directed compilation, query optimization, and query orchestration mechanism to be used in development tools for heterogeneous environments. We provide type safety and language integration. Our approach is also suitable for an interactive query construction environment by rich user interfaces that pro- vide immediate feedback on data manipulation operations. This approach is currently the base for the data layer of a development platform for mobile and web applications.

Programming language researchers often study real-world projects to see how language features have been adopted and are being used. Typically researchers choose a small number of projects to study, due to the immense challenges associated with finding, downloading, storing, processing, and querying large amounts of data. The Boa programming language and infrastructure was designed to solve these challenges and allow researchers to focus on simply asking the right questions. Boa provides a domain-specific language to abstract details of how to mine hundreds of thousands of projects and also abstracts how to efficiently query that data. We have previously used this platform to perform a large study of the adoption of Java's language features over time. In this demonstration, we will show you how we used Boa to quickly analyze billions of AST nodes and study the adoption of Java's language features.

Programmers combine different programming languages because it allows them to use the most suitable language for a given problem, to gradually migrate existing projects from one language to another, or to reuse existing source code. However, existing cross-language mechanisms suffer from complex interfaces, insufficient flexibility, or poor performance. We present the TruffleVM, a multi-language runtime that allows composing different language implementations in a seamless way. It reduces the amount of required boiler-plate code to a minimum by allowing programmers to access foreign functions or objects by using the notation of the host language. We compose language implementations that translate source code to an intermediate representation (IR), which is executed on top of a shared runtime system. Language implementations use language-independent messages that the runtime resolves at their first execution by transforming them to efficient foreign-language-specific operations. The TruffleVM avoids conversion or marshaling of foreign objects at the language boundary and allows the dynamic compiler to perform its optimizations across language boundaries, which guarantees high performance. This paper presents an implementation of our ideas based on the Truffle system and its guest language implementations JavaScript, Ruby, and C.

Several scientific domains operate on mesh data structures. Computations on meshes share a set of basic abstractions which relates to topological and geometric structure of meshes. Due to the complexity of modeling and querying meshes, the database community has neglected the need for a dedicated mesh database and in particular a high-level mesh query language. Currently, such computations is done by using general-purpose programming languages. Such implementations are tightly coupled with dataset characteristics and thus are less reusable, their maintenance cost is high, and their performance is limited to the memory size. In this paper, we describe syntax and semantic of a high-level query language for scientific meshes (called MQuery) with a level of abstraction that can express queries based on topological and geometric navigations. The language is build on top of a graph-based conceptual mesh data model. We report our results comparing two implementations of the language on top of relational and graph databases with a mesh library.

Nowadays most of people of developed economy countries interact with software every day. As a result of computer systems expansion to all scope of people's activity the problem of transition from visual and command interfaces to natural language user interfaces is thrown into the sharp relief. Computational linguistics and natural language processing methods are described in this article. Methods of natural language manipulation are applied in machine translation software systems, systems of search and exchange the data, text annotation and expert systems. Prototype of natural language user interface to structured data source is developed. As a result it is convert natural language user's query to SQL query to database. Natural language user interface is created to predefined subject field. User interface interacts to database that contain information about existent program libraries and frameworks. Consequently, using natural language processing methods it is possible to develop user natural language user interface providing capability to interact with machine.

Offering end users, experts on the domain, means to explore and query data stored in the information systems they work with can generate large benefits for organizations and society. Frequently, expressing ad-hoc queries with a query language is complex for end users, even when they use visual languages or graphical interfaces. GraphTQL a new visual query language for data graphs that aims to facilitate end-users formulating complex queries was developed. The design process of GraphtTQL followed the User-Centered Design Approach (UCD). The results of interviews and usability tests with end users are presented.

International audience; Multistore systems have been recently proposed to provide integrated access to multiple, heterogeneous data stores through a single query engine. In particular, much attention is being paid on the integration of unstructured big data typically stored in HDFS with relational data. One main solution is to use a relational query engine that allows SQL-like queries to retrieve data from HDFS, which requires the system to provide a relational view of the unstructured data and hence is not always feasible. In this paper, we introduce a functional SQL-like query language that can integrate data retrieved from different data stores and take full advantage of the functionality of the underlying data processing frameworks by allowing the ad-hoc usage of user defined map/filter/reduce operators in combination with traditional SQL statements.Furthermore, the query language allows for optimization by enabling subquery rewriting so that filter conditions can be pushed inside and executed at the data store as early as possible. Our approach is validated with two data stores and a representative query that demonstrates the usability of the query language and evaluates the benefits from query optimization.

Tools that support development of parsers often concentrate on concrete syntax, leaving abstract syntax defined only implicitly. On the other hand there are projectional language workbenches that give central role to language model (abstract syntax) at the cost of locking a language to the concrete tool. In this paper we present YAJCo parser generator that uses model-centered approach to language definition while preserving textual representation. Abstract syntax of a language is expressed using object-oriented model in a general-purpose language with additional information and concrete syntax provided in form of annotations. In the paper we describe how abstract syntax, concrete syntax and semantics of the language are defined using YAJCo. We also describe how this method supports language composition and iterative development.

In the present investigation we pretend to make a Spanish natural language translator to SQL using both the database schema and domain information, which is entered through a CSV file. For that end, the system uses prepositions, articles and main adverbs of Spanish language as part of their analysis and an approximation algorithm is used, it means, according to the words that are understood for the user input, the system will try to generate an SQL statement. Therefore, the problem wanted to be solved with this research is the difficulty that non-technical users have when doing queries to a database, implementing, for that reason, an interface in natural language.

We introduce a new declarative language called SELECTSCRIPT. As its name suggests, it is a scripting language inspired primarily by SQL and its relational algebra. It is intended to be used for complex queries on different kinds of world models. Scripts can be dynamically generated and executed, or embedded into the code of foreign programming languages. A first interpreter was therefore developed for Python. Adapting the ideas of language-oriented programming, which enables developers to create their own domain-specific language, we developed a language stub that can be easily adapted and extended to comply with any (discrete) robotic world model or robotic simulator. We will further show how simple SELECT-statements can be used to extract any kind of valuable information in various return formats, thereby going beyond traditional SQL capabilities.

In the LanguageLab language workbench, we build on a component-based approach to language specification that facilitates the specification of all aspects of a computer language in a consistent manner, taking into account best practices in meta-modelling and language design. The workbench allows operation on a suitable abstraction level, and also focuses on user-friendliness and a low threshold to getting started, in order to make it useful for teaching of meta-modelling and language design and specification. The platform is open for third party language modules and facilitates rapid prototyping of DSLs, re-use of language modules, and experiments with multiple concrete syntaxes. The platform also allows interested parties to develop LanguageLab modules that can further add to the features and capabilities of the LanguageLab platform.

Although most programming languages naturally share several language features, they are typically implemented as a monolithic product. Language features cannot be plugged and unplugged from a language and reused in another language. Some modular approaches to language construction do exist but composing language features requires a deep understanding of its implementation hampering their use. The choose and pick approach from software product lines provides an easy way to compose a language out of a set of language features. However, current approaches to language product lines are not sufficient enough to cope with the complexity and evolution of real world programming languages. In this work, we propose a general light-weight bottom-up approach to automatically extract a feature model from a set of tagged language components. We applied this approach to the Neverlang language development framework and developed the AiDE tool to guide language developers towards a valid language composition. The approach has been evaluated on a decomposed version of Javascript to highlight the benefits of such a language product line.

Language extension enables integration of new language constructs without invasive changes to a base language (e. g., C). Such extensions help to build more reliable software by using proper domain-specific abstractions. Language workbenches significantly reduce the effort for building such extensible languages by synthesizing a fully-fledged IDE from language definitions. However, in contemporary tools, this synthesis does not include interactive debugging for programs written with the base language or its extensions. This paper describes a generic framework for extensible debuggers that enables debugging of the language extensions by defining mappings between the base language and the language extensions. The architecture is designed for extensibility, so debug support for future extensions can be contributed with little effort. We show an implementation of our approach for mbeddr, which is an extensible version of the C programming language. We also discuss the debugger implementation for non-trivial C extensions such as components. Finally, the paper discusses the extent to which the approach can be used with other base languages, debugger backends and language workbenches.

Nowadays, time interval data is ubiquitous. The requirement of analyzing such data using known techniques like on-line analytical processing arises more and more frequently. Nevertheless, the usage of approved multidimensional models and established systems is not sufficient, because of modeling, querying and processing limitations. Even though recent research and requests from various types of industry indicate that the handling and analyzing of time interval data is an important task, a definition of a query language to enable on-line analytical processing and a suitable implementation are, to the best of our knowledge, neither introduced nor realized. In this paper, we present a query language based on requirements stated by business analysts from different domains that enables the analysis of time interval data in an on-line analytical manner. In addition, we introduce our query processing, established using a bitmap-based implementation. Finally, we present a performance analysis and discuss the language, the processing as well as the results critically.

Tool support for iterative language development is crucial when we treat a domain-specific language as a dynamic element in the software development lifecycle. We present YAJCo language processor generator and its approach to iterative development of DSLs on the case study of the Karel the Robot language. YAJCo is built upon existing parsing technologies and it reuses programmer experience in the field of object- and aspect-oriented programming paradigms and existing tooling infrastructure widely used for system development (e.g. IDE).

It is simple to query a relational database because all columns of the tables are known and the language SQL is easily applicable. In NoSQL, there usually is no fixed schema and no query language. In this article, we present NotaQL, a data-transformation language for wide-column stores. NotaQL is easy to use and powerful. Many MapReduce algorithms like filtering, grouping, aggregation and even breadth-first-search, PageRank and other graph and text algorithms can be expressed in two or three short lines of code.

The Object Constraint Language (OCL) is commonly used for constraints in meta-model-based language specifications. However, it may be advantageous to have a domain-specific constraint meta-language optimised for language specifications. A survey of OCL usage in language specifications has been performed, in order to gain an understanding of common constraint patterns. This is used as a starting point for defining a new meta-language for language constraints, Language Constraint Language (LCL), that has an intuitive graphical syntax.

Design of a data quality-aware information management framework and system.Users measure data quality based on an extensible set of data profiling algorithms.Query language, system architecture and heuristic optimization approach developed.System design based on seamless extensions to SQL and relational database systems.Applied in e-Business scenarios and potential for big data profiling discussed. This paper describes the design and implementation of the Data Quality Query System (DQ2S), a query processing framework and tool incorporating data quality profiling functionality in the processing of queries involving quality-aware query language extensions. DQ2S supports the combination of performance and quality-oriented query optimizations, and a query processing platform that enables advanced data profiling queries to be formulated based on well established query language constructs, often used to interact with relational database management systems. DQ2S encompasses a declarative query language and a data model that provides users with the capability to express constraints on the quality of query results as well as query quality-related information; a set of algebraic operators for manipulating data quality-related information, and optimization heuristics. The proposed query language and algebra represent seamless extensions to SQL and relational database engines, respectively. The constructs of the proposed data model are implemented at the user's view level and are internally mapped into relational model constructs. The quality-aware extensions and features are extremely useful when users need to assess the quality of relational data sets and define quality constraints for acceptable data prior to using candidate data sources in decision support systems and conducting big data analytical tasks.

Translingual retrieval relies on processing a source language to retrieve digital document content in a target language. From the perspective of successful browsing digital catalogues, probability of retrieving the full text document in a language other than the query language is close to zero owning to the fact that it is not only the library collection, but especially a problem of matching the index terms with the query keywords which are assumed to be their translation equivalents. In addition, hardly any digital library system is incorporated with a translation component. As a result, such a matching is rather coincidental. Our approach to the translingual document retrieval problem is to build a metadata language model that based on a digital document computes such a word sequence which ranks the document collection on the basis of the probability of generating a particular query keyword alignment.

Today, database is considered as one of the major source of information. Data stored in database can be accessed by using SQL queries. Those who are expert in SQL language can access information from database but non-technical user cannot retrieve data from database such as MySQL and oracle. There is need to provide natural language interface to database for non-technical users. In this paper we have discussed design and implementation of a system using modified word co-occurrence matrix method which will provide access to database using queries in English language.

A pattern for information system implementation is proposed. The pattern is based on the commonly accepted object-oriented methodologies of design and development oriented toward widely used imperative programming languages. At the same time, this pattern makes it possible to fully use the power of declarative possibilities of the DBMS query language. The presented estimations demonstrate much higher performance of the applications obtained compared to those created by means of commonly accepted techniques.

A database session is a sequence of requests presented to the database system by a user or an application to achieve a certain task. Session identification is an important step in discovering useful patterns from database trace logs. The discovered patterns can be used to improve the performance of database systems by prefetching predicted queries, rewriting the current query or conducting effective cache replacement.In this paper, we present an application of a new session identification method based on statistical language modeling to database trace logs. Several problems of the language modeling based method are revealed in the application, which include how to select values for the parameters of the language model, how to evaluate the accuracy of the session identification result and how to learn a language model without well-labeled training data. All of these issues are important in the successful application of the language modeling based method for session identification. We propose solutions to these open issues. In particular, new methods for determining an entropy threshold and the order of the language model are proposed. New performance measures are presented to better evaluate the accuracy of the identified sessions. Furthermore, three types of learning methods, namely, learning from labeled data, learning from semi-labeled data and learning from unlabeled data, are introduced to learn language models from different types of training data. Finally, we report experimental results that show the effectiveness of the language model based method for identifying sessions from the trace logs of an OLTP database application and the TPC-C Benchmark.

As the number and diversity of distributed Web databases on the Internet exponentially increase, it is difficult for user to know which databases are appropriate to search. Given database language models that describe the content of each database, database selection services can provide assistance in locating databases relevant to the information needs of users. In this paper, we propose a database selection approach based on statistical language modeling. The basic idea behind the approach is that, for databases that are categorized into a topic hierarchy, individual language models are estimated at different search stages, and then the databases are ranked by the similarity to the query according to the estimated language model. Two-stage smoothed language models are presented to circumvent inaccuracy due to word sparseness. Experimental results demonstrate that such a language modeling approach is competitive with current state-of-the-art database selection approaches.

Motivation: Many areas of modern biology are concerned with the management, storage, visualization, comparison and analysis of networks, but no appropriate query language for such complex data structures yet exists. Results: We have designed and implemented the pathway query language (PQL) for querying large protein interaction or pathway databases. PQL is based on a simple graph data model with extensions reflecting properties of biological objects. Queries match subgraphs in the database based on node properties and paths between nodes. The syntax is easy to learn for anybody familiar with SQL. As an important feature, a query may require a certain structure in the database to exist but return a different subgraph. We have tested PQL queries on networks of up to 16 000 nodes and found it to scale very well. Availability: The code is available on request from the author. Contact: leser@informatik.hu-berlin.de

Two probabilistic approaches to cross-lingual retrieval are in wide use today, those based on probabilistic models of relevance, as exemplified by INQUERY, and those based on language modeling. INQUERY, as a query net model, allows the easy incorporation of query operators, including a synonym operator, which has proven to be extremely useful in cross-language information retrieval (CLIR), in an approach often called structured query translation. In contrast, language models incorporate translation probabilities into a unified framework. We compare the two approaches on Arabic and Spanish data sets, using two kinds of bilingual dictionaries-one derived from a conventional dictionary, and one derived from a parallel corpus. We find that structured query processing gives slightly better results when queries are not expanded. On the other hand, when queries are expanded, language modeling gives better results, but only when using a probabilistic dictionary derived from a parallel corpus.We pursue two additional issues inherent in the comparison of structured query processing with language modeling. The first concerns query expansion, and the second is the role of translation probabilities. We compare conventional expansion techniques (pseudo-relevance feedback) with relevance modeling, a new IR approach which fits into the formal framework of language modeling. We find that relevance modeling and pseudo-relevance feedback achieve comparable levels of retrieval and that good translalion probabilities confer a small but significant advantage.

We are interested in evolution scenarios for language-based functionality. We identify different dimensions along which such functionality can evolve, including the following: (i) coding style; (ii) coding details; (iii) data model; (iv) crosscutting concerns; and (v) patches. We focus at language interpreters as examples of language-based functionality, but similar scenarios exist for type checkers, static analyses, program transformations, and other sorts of language-based functionality. Our experiences are based on using rule-based programming (with Prolog) for the implementation of language-based functionality, while evolutionary transformations of the functionality are perceived as meta-programs.

This paper investigates the development of a natural language (NL) interface for mixed initiative dialogues within a constrained domain and demonstrates the applicability of the functional approach to NL system development. The system consists of two major components, a natural language subsystem comprises a general-purpose parser that interprets a 'plug and play' tagged BNF grammar (which may be ambiguous), to parse natural language input and extract semantic information. The knowledge-based subsystem uses the semantic tags extracted by the natural language subsystem to generate a focused query to select the most appropriate script for a guided dialogue with the user. The system was written entirely in a purely functional language, which resulted in a surprisingly small and simple program.

Automation systems improve the productivity of works which relate to product design, facilities management, fault processing and quality evaluation. In these systems, the description language for monitoring and control process is called new control language. These are five flow control languages : IL, ST, FBD, SFC and LD. IL and ST are based on left form. FBD, SFC and LD are based on graphic form. Generally, a software which monitors and controls a system is allowed to use just one flow control language. It is impossible to use more than two languages for simulation in the same system environment. In this paper, we analyzed the characteristics of flow control languages and the process of programming in the legacy system. In addition, for the Integrated processing of languages, we propose Extended ST based on the high-level ST language. Based on this research, we implement a graphical language editor and EST-IL convertor. The graphical language editor makes sequence rules, and converts graphical language into EST. EST-IL convertor has a function to convert EST into IL which is similar to assembly language. As the result of this paper, we present a scheme which integrates all the flow control language processing based on IL.

The design of a specialised query language for content based image retrieval provides a means of addressing many of the problems associated with commonly used query paradigms such as query-by-example and query-by-sketch. By basing such a language on an extensible ontology, which encompasses both high-level and low-level image properties and relations, one can go a long way towards bridging the semantic gap between user models of saliency and relevance and those employed by a retrieval system. This paper discusses these issues and illustrates the design and use of an ontological retrieval language through the example of the OQUEL query language. The retrieval process takes place entirely within the ontological domain defined by the syntax and semantics of the user query. Since the system does not rely on the pre-annotation of images with sentences in the language, the format of text queries is highly flexible. The language is also extensible to allow for the definition of higher-level terms such as ‘cars’, ‘people’, etc. on the basis of existing language constructs through the use of Bayesian inference networks. The matching process utilises automatically extracted image segmentation and classification information and can incorporate any other feature extraction mechanisms or contextual knowledge available at processing time to satisfy a given user request.

In recent years large amounts of electronic texts have become available. While the first of these corpora had only a low level of annotation, the more recent ones are annotated with refined syntactic information. To make these rich annotations accessible for linguists, the development of query systems has become an important goal. One of the main difficulties in this task consists in the choice of the right query language, a language which at the same time should be powerful enough to let users formulate the queries they want and which should be efficiently evaluable to keep query response times short. There is a widespread belief that such a query language does not exist. It is therefore the aim of this paper to show that there is indeed a powerful query language that can be efficiently evaluated. We propose the use of monadic second-order logic as a query language. We show that a query in this language can be evaluated in linear time in the size of a tree in the corpus. We also provide examples of complicated linguistic queries expressed in monadic second-order logic thereby demonstrating the high expressive power of the language.

Mesh data has been a common form of data produced and searched in scientific simulations, and has been growing rapidly in the size thanks to the increasing computing power. Today, there are visualization tools that assist scientists to explore and examine the data, but their query capabilities are limited to a small set of fixed visualization operations, which is far too short to meet the needs of most users. Thus, it is imperative to provide ad hoc query tools for them.In this paper, we propose an ad hoc query language MeshSQL, which has been extended from ANSI SQL99 to support the features unique to simulation mesh data, such as temporality, spatial regions, statistics, and similarity. After classifying Mesh-SQL queries based on three criteria related to efficient implementations of the queries, we present the syntax and semantics of MeshSQL, and support them with examples. We also discuss implementing MeshSQL queries in SQL99 in an object-relational database system that allows incorporating user-defined types and functions. To our knowledge, MeshSQL is the first and the only query language for simulation mesh data.

In this paper we propose a set-oriented rule-based method definition language for object-oriented databases. Most existing object-oriented database systems exploit a general-purpose imperative object-oriented programming language as the method definition language. Because methods are written in a general-purpose imperative language, it is difficult to analyze their properties and to optimize them. Optimization is important when dealing with a large amount of objects as in databases. We therefore believe that the use of an ad hoc, set-oriented language can offer some advantages, at least at the specification level. In particular, such a language can offer an appropriate framework to reason about method properties. In this paper, besides defining a set-oriented rule-based language for method definition, we formally define its semantics, addressing the problems of inconsistency and non-determinism in set-oriented updates. Moreover, we characterize some relevant properties of methods, such as conflicts among method specifications in sibling classes and behavioral refinement in subclasses. Copyright © 2003 John Wiley & Sons, Ltd.

This paper describes the rapid adaptation for surprise languages of a flexible and robust Information Extraction system based on GATE, a portable Natural Language Processing infrastructure. Our experiences show that even without a native speaker and in the absence of training data, we can quickly customize the system to a new language. We adapted the default English system for the Cebuano language in 10 days, achieving an F measure of 77.5%.

Motivation: A new method is developed to query a relational database in natural language (NL). Results: The method, based on a semantic approach, interprets grammatical and lexical units of a natural language into concepts of subject domain, which are given in a conceptual scheme. The conceptual scheme is mapped formally onto the logical scheme. We applied the method to query the FlyEx database in natural language. FlyEx contains information on the expression of segmentation genes in Drosophila melanogaster. The method allows formulation of queries in various natural languages simultaneously, and is adaptive to changes in the knowledge domain and user’s views. It provides optimal transformation of queries from natural language to SQL, as well as visualization of information as a hyperscheme. The method does not require specification of all possible language constructions as well as a standard grammar accuracy in formulation of NL queries. Availability: http://urchin.spbcas.ru/NLP/NLP.html Contact: samson@spbcas.ru Keywords: natural language processing, relational databases, conceptual scheme, segmentation genes, D.melanogaster, query optimization. *To whom correspondence should be addressed.

Managers, in today's corporations, rely increasingly on the use of databases to obtain insights and updated information to make their decisions. This paper describes a flexible query interface based on fuzzy logic. Hence, queries in natural language with pre-defined syntactical structures are performed, and the system uses a fuzzy natural language process to provide answers. This process uses the fuzzy translation rules of the meaning representation language PRUF, proposed by Zadeh (Intern. J. Man-Machine Studies 10 (1978) 395). The interface was built for a relational database of the 500 biggest non-financial Portuguese companies. The attributes considered are the economic and financial indicators. Examples of pseudonatural language queries, such as "is company X very profitable?" or "are most private companies productive?", are presented to show the capabilities of this human-oriented interface.

The Common Language Runtime (CLR) is language and platform-neutral, and provides the underlying infrastructure for the Microsoft .NET Framework. A key innovation in the CLR is its support for multiple programming languages, enabling programming language integration at the runtime level to a much greater degree than is currently possible.

We present pml B , a programming language that includes primitive sets and associated operations. The language is equipped with a precise type discipline that statically captures dynamic properties of sets, allowing runtime optimizations. We demonstrate the utility of pml B by showing how it can serve as a practical implementation language for higher-level programming language based security systems, and characterize pml B by comparing the expressiveness of pml B sets with enumerations.

We present a visual language for querying and transforming XML data. The language is based on a visual document metaphor and the notion of document patterns and rules. It combines a dynamic form-based interface for defining queries and transformation rules with powerful pattern matching capabilities and offers thus a highly expressive visual language. The design of the visual language is specifically targeted at end users.

The a Everyday language computing (ELC) is a new computational paradigm that all people, from small children to aged persons, can access and use computing systems with his/her own everyday language. As a way to realize ELC, we proposed a framework of language-based operating system (LOS), and we are now working intensively to develop the fundamental part of it. In this paper, we report our status of research on LOS. One of the main components of LOS is the semiotic base, which is a database of linguistic knowledge based on Systemic Functional Linguistic Theory. We explain the architecture of the semiotic base and corpus experiments conducted to determine the contents of it. A client's secretary agent is a user interface of LOS which realizes everyday language communication between a user and the system. We explain a client model that realizes personalized communication and the plan module that manages the structure of dialogue. In LOS, all kinds of information processing are done through everyday language. Language protocol is a computer protocol based on everyday language, and language-based application is a kind of agent software that provides services through language. We explain the characteristics of language protocol, the structure of language-based application programming interface (LAPI), and text interpretation process of language-based applications. Finally, we discuss prospects of this project and mention future work that remains to be done. We argue that by processing meaning of language rather than processing numbers, we attempt to provide a more human-like computer system and an intelligent computational environment to all people.

A natural language query interface is very desirable for a geographic information system (GIS). It converts natural language queries (sentences) into a formal query language. A key task in building a natural language query interface is handling uncertainty and impreciseness. Grammatical errors and parsing ambiguity cause uncertainty. A natural language query may contain imprecise terms that have to be processed before an executable query can be generated. In this paper, a three–step technique is presented that can be used to correct grammatically incomplete natural language queries, solve parsing ambiguity, and translate imprecise conditions into executable selection conditions.

Algebraic compilers provide a powerful and convenient mechanism for specifying language translators. With each source language operation one associates a computation for constructing its target language image; these associated computations, called derived operations, are expressed in terms of operations from the target language. Sometimes the target language is not powerful enough to specify the required translation and one may then need to extend the target language algebras with more computationally expressive operations or elements. A better solution is to package these extensions in a specification language which can be composed with the target language to ensure that all operations and elements needed or desired for performing the translation are provided. In the example in this paper, we show how imperative and functional specification languages can be composed with a target language to implement a temporal logic model checker as an algebraic compiler and show how specification languages can be seen as components to be combined with a source and target language to generate an algebraic compiler.

There are many CALL resources available today but often they need to be adapted for level or culture. CALL practitioners would like to reuse currently existing material rather than reinvent the wheel, but often this is not possible. Thus, they end up building CALL material, both language content and software, from scratch. This is inefficient in terms of CALL practitioners’ time and as Felix (1999) points out, there is no point ‘doing badly’ what has already been done well. Why can’t we reuse what already exists? Often the language content is hard-wired in the software and cannot be modified or the CALL material comes as an executable which is hard or impossible to change. Authoring tools can provide a degree of flexibility, but often focus on particular parts of the language learning process (e.g. interactive exercises) and the associated language content cannot, in general, easily be exported into other formats and presentation software. One solution to this problem is provided by XML technologies. They provide a strict separation between data and processing. Thus, three types of reuse are possible: reuse of the data processing engine (i.e. the XSL processing files), reuse of the language content structure (i.e. the XML data files) and reuse the linguistic resources (i.e. the language content). In this paper, an example is given of a CALL template that has been developed using XML technologies. The template provides a structure into which the language content can be slotted and a processing engine to act upon the data to create CALL material. The template was developed for the production of CALL materials for Endangered Languages (ELs), but could be used for MCTLs (Most Commonly Taught Languages) and LCTLs (Less Commonly Taught Languages) also. It has been used to develop a language learning course for Nawat (a language of El Salvador), Akan (a Ghanaian language) and Irish, demonstrating the reusability of the language content structure as well as proving the reusability of the processing engine provided by the template. A further reusable feature is the ability to create courseware in different media (Internet, CD and print) from the same source language content.

This paper discusses a mathematical concept of language that models both artificial and natural languages and thus provides a framework for a unified language processing methodology. This concept of a language is regarded as a communication tool that allows language users to develop knowledges, while interacting with their universe of discourse, and to communicate with each other, while exchanging knowledges. Criteria for consistent usage of a language are established using a Galois connection between language syntax and language semantics. Solutions to ambiguity, paraphrase, attitude, and other problems concerning the relationship between syntax and semantics are addressed. A general schema for language specification is introduced and algorithms that perform language generation and language analysis are discussed as universal tools defined by the specification schema. Language transformations performed by various kinds of translators are examined and correctness criteria of these translators are defined using the language Galois connection.The paper is structured as follows: Section1 introduces the framework and justifies the necessity of a unified methodology for language processing. Section2 presents the mathematical concept of a language. Section3 illustrates the mathematical concept of a language with three kinds of language structures: natural language, logical language, and programming language. Section4 discusses the algebraic mechanism of language specification that unifies the methodology for language processing tool development. Section5 formalizes the criterion for the consistency of the language usage, defines the architecture of a unified language processing system, and shows how the consistency criteria for language usage can be employed as correctness criteria for the algorithms performing various language transformations.

A unified query language (UQL) in terms of UML is proposed based on the Object Constraint Language (OCL), which is a part of the UML specification. The semantics of the UQL, its scope, and interfaces based on this language are discussed. Processing of a UQL query is described including its transformation to XQuery, optimization, decomposition, execution of query parts against local data, and formation of the final result.

In this paper we present a graphical query language for XML. The language, based on a simple form of graph grammars, permits us to extract data and reorganize information in a new structure. As with most of the current query languages for XML, queries consist of two parts: one extracting a subgraph and one constructing the output graph. The semantics of queries is given in terms of graph grammars. The use of graph grammars makes it possible to define, in a simple way, the structural properties of both the subgraph that has to be extracted and the graph that has to be constructed. We provide an example-driven comparison of our language w.r.t. other XML query languages, and show the effectiveness and simplicity of our approach.

International audience; The Rule Query Language (RQL) is an SQL-likepattern mining language that extends and generalizes functionaldependencies to new and unexpected rules. It brings to the dataanalysts’ desktop a convenient tool to discover logical implica-tions between attributes of the database. Such implications mayreveal data quality problems or surprising correlations betweenattributes over some part of the database. The computation ofRQL queries is based on a query rewriting technique that pushesas much processing as possible to the underlying DBMS. Thiscontribution is an attempt to bridge the gap between patternmining and databases and facilitates the use of data miningtechniques by SQL-aware analysts and students

With the increased use of computer applications, database is gaining prime importance in every field for information retrieval. Large number of people with non technical background is dealing with these applications. However, database access is difficult for such users. The paper discussed a prototype, developed to retrieve the data from the database. NLIDB architecture is one which converts Hindi language query into database query language. The sentence is processed syntactically using karaka or post positions and language syntax, followed by semantic analysis. The formed SQL query is executed on the database and result is displayed to the user in Hindi language. Testing is done on Employee database. The system eliminates the need to have a fixed pattern and allows the user to write the same Hindi language query in different pattern.

The realization of a language design requires multiple artifacts that redundantly encode the same information. This entails significant effort for language implementors, and often results in late detection of errors in language definitions. In this paper we present a proof-of-concept language designer's workbench that supports generation of IDEs, interpreters, and verification infrastructure from a single source. This constitutes a first milestone on the way to a system that fully automates language implementation and verification.

Users often describe what they want to accomplish with an application in a language that is very different from the application's domain language. To address this gap between system and human language, we propose modeling an application's domain language by mining a large corpus of Web documents about the application using deep learning techniques. A high dimensional vector space representation can model the relationships between user tasks, system commands, and natural language descriptions and supports mapping operations, such as identifying likely system commands given natural language queries and identifying user tasks given a trace of user operations. We demonstrate the feasibility of this approach with a system, CommandSpace, for the popular photo editing application Adobe Photoshop. We build and evaluate several applications enabled by our model showing the power and flexibility of this approach.