A visual language compiler

The SIL-ICON compiler is a software system for the specification, interpretation, prototyping, and generation of icon-oriented systems. The system design of the SIL-ICON compiler is presented. The icon system G, the icon dictionary ID, the operator dictionary OD, and the extended task action grammar ETAG are described. An application example to design a text editor using the Heidelberg icon set is also presented in detail     

Using a frame-based language for information retrieval

With the advent of the information society, many researchers are turning to artificial intelligence techniques to provide effective retrieval over large bodies of textual information. In the CODER system, the mission of which is to provide an environment for experiments in applying AI to information retrieval, a factual representation language (FRL) serves as a tool for knowledge engineering and experimentation. the FRL is a hybrid AI language supporting strong typing for attribute values, a frame system, and Prolog-like relational structures. Inheritance is enforced throughout, and the semantics of type subsumption and object matching are formally defined. A collection of type and object managers called the knowledge administration complex implements this common language for storing knowledge and communicating it within the system. Storage of large numbers of complete knowledge objects (statements in the language) is supported by a system of external knowledge bases. Of the three types of knowledge structures in the language, the frame facility has proven most useful in the retrieval domain. This article discusses the frame construct itself, the implementation of the relevant portions of the knowledge administration complex and external knowledge bases, and the use of frames in retrieval research. It closes with a discussion of the utility of the FRL.     

A visual user interface for map information retrieval based onsemantic significance

User-interface facilities of a map information system HI-MAP that provide visual feedback to the user are presented. The facilities include semantic panning and zooming, overlaying of thematic maps, etc., and are available through an interactive menu system. HI-MAP retrieves map elements in a specified region on the basis of their relevance and their categorical classification. It has a data structure that includes logical and physical hierarchies for the management of semantic relationships and graphic map elements. The software for implementing these facilities is well modularized, and a variety of interfacing modes can be realized by simple communication between modules. The system contributes toward a reduction of the difficulties in obtaining what is really required from databases     

Relevance- and interface-driven clustering for visual information retrieval

Search results of spatio-temporal data are often displayed on a map, but when the number of matching search results is large, it can be time-consuming to individually examine all results, even when using methods such as filtered search to narrow the content focus. This suggests the need to aggregate results via a clustering method. However, standard unsupervised clustering algorithms like $K$-means (i) ignore relevance scores that can help with the extraction of highly relevant clusters, and (ii) do not necessarily optimize search results for purposes of visual presentation. In this article, we address both deficiencies by framing the clustering problem for search-driven user interfaces in a novel optimization framework that (i) aims to maximize the relevance of aggregated content according to cluster-based extensions of standard information retrieval metrics and (ii) defines clusters via constraints that naturally reflect interface-driven desiderata of spatial, temporal, and keyword coherence that do not require complex ad-hoc distance metric specifications as in $K$-means. After comparatively benchmarking algorithmic variants of our proposed approach – RadiCAL – in offline experiments, we undertake a user study with 24 subjects to evaluate whether RadiCAL improves human performance on visual search tasks in comparison to $K$-means clustering and a filtered search baseline. Our results show that (a) our binary partitioning search (BPS) variant of RadiCAL is fast, near-optimal, and extracts higher-relevance clusters than $K$-means, and (b) clusters optimized via RadiCAL result in faster search task completion with higher accuracy while requiring a minimum workload leading to high effectiveness, efficiency, and user satisfaction among alternatives.     

Visual language implementation through standard compiler–compiler techniques

We present a technique for implementing visual language compilers through standard compiler generation platforms. The technique exploits eXtended Positional Grammars (XPGs, for short) for modeling the visual languages in a natural way, and uses a set of mapping rules to translate an XPG specification into a translation schema. This lets us generate visual language parsers through standard compiler–compiler techniques and tools like YACC. The generated parser accepts exactly the same set of visual sentences derivable through the application of XPG productions. The technique represents an important achievement, since it enables us to perform visual language compiler construction through standard compiler–compilers rather than specific compiler generation tools. This makes our approach particularly appealing, since compiler–compilers are widely used and rely on a well-founded theory. Moreover, the approach provides the basis for the unification of traditional textual language technologies and visual language compiler technologies.     

VIRTUE: A visual tool for information retrieval performance evaluation and failure analysis

Objective: Information Retrieval (IR) is strongly rooted in experimentation where new and better ways to measure and interpret the behavior of a system are key to scientific advancement. This paper presents an innovative visualization environment: Visual Information Retrieval Tool for Upfront Evaluation (VIRTUE), which eases and makes more effective the experimental evaluation process.Methods: VIRTUE supports and improves performance analysis and failure analysis.Performance analysis: VIRTUE offers interactive visualizations based on well-known IR metrics allowing us to explore system performances and to easily grasp the main problems of the system.Failure analysis: VIRTUE develops visual features and interaction, allowing researchers and developers to easily spot critical regions of a ranking and grasp possible causes of a failure.Results: VIRTUE was validated through a user study involving IR experts. The study reports on (a) the scientific relevance and innovation and (b) the comprehensibility and efficacy of the visualizations.Conclusion: VIRTUE eases the interaction with experimental results, supports users in the evaluation process and reduces the user effort.Practice: VIRTUE will be used by IR analysts to analyze and understand experimental results.Implications: VIRTUE improves the state-of-the-art in the evaluation practice and integrates visualization and IR research fields in an innovative way.     

NL ∩ IR: Natural language for information retrieval

Neither natural language processing nor information retrieval is any longer a young field, but the two areas have yet to achieve a graceful interaction. Mainly, the reason for this incompatibility is that information retrieval technology depends upon relatively simple but robust methods, while natural language processing involves complex knowledge-based systems that have never approached robustness. We provide an analysis of areas in which natural language and information retrieval come together, and describe a system that joins the two fields by combining technology, choice of application area, and knowledge acquisition techniques.     

An optimizing compiler for the icon programming language

Compiling code for the Icon programming language presents several challenges, particularly in dealing with types and goal-directed expression evaluation. In order to produce optimized code, it is necessary for the compiler to know much more about operations than is necessary for the compilation of most programming languages. This paper describes the organization of the Icon compiler and the way it acquires and maintains information about operations. The Icon compiler generates C code, which makes it portable to a wide variety of platforms and also allows the use of existing C compilers for performing routine optimizations on the final code. A specially designed implementation language, which is a superset of C, is used for writing Icon's run-time system. This language allows the inclusion of information about the abstract semantics of Icon operations and their type-checking and conversion requirements. A translator converts code written in the run-time language to C code to provide an object library for linking with the code produced by the Icon compiler. The translation process also automatically produces a database that contains the information the Icon compiler needs to generate and optimize code. This approach allows easy extension of Icon's computational repertoire, alternate computational extensions, and cross compilation.     

A shape-based visual interface for text retrieval

We describe a shape-based visual interface for information retrieval and interactive exploration that exploits shape recognition. Our exploratory system uses procedurally generated shapes coupled with an underlying text-retrieval engine. A visual interface based on 3D shapes (glyphs) enhances traditional text-based queries and summarization. Our interface lets users visualize multidimensional relationships among documents and perceive more information than with conventional text-based interfaces. It promotes information overview and drill-down in support of analysis. Before describing our visual interface and application, we introduce information retrieval within the context of data mining and provide a brief overview of procedural shape generation. We then describe our current system and give a few relevant examples. Finally, we offer some ideas for future enhancements and direction     

A visual programming language for XML manipulation

XML data flow has reached beyond the world of computer science and has spread to other areas such as data communication, e-commerce and instant messaging. Therefore, manipulating this data by non-expert programmers is becoming imperative and has emerged two alternatives. On one hand, Mashups have emerged a few years ago, providing users with visual tools for web data manipulation but not necessarily XML specific. Mashups have been leaning towards functional composition but no formal definitions have yet been defined. On the other hand, visual languages for XML have been emerging since the standardization of XML, and mostly relying on querying XML data for extraction or structure transformations. These languages are mainly based on existing textual XML languages, they have limited expressiveness and do not provide non-expert programmers with means to manipulate XML data. In this paper, we define a generic visual language called XCDL based on Colored Petri Nets allowing non-expert programmers to compose manipulation operations. The XML manipulations range from simple data selection/projection to data modification (insertion, removal, obfuscation, etc.). The language is oriented to deal with XML data (XML documents and fragments), providing users with means to compose XML oriented operations. The language core syntax is presented here along with an implemented prototype based on it.     

A visual language for explaining probabilistic reasoning

We present an explanation-oriented, domain-specific, visual language for explaining probabilistic reasoning. Explanation-oriented programming is a new paradigm that shifts the focus of programming from the computation of results to explanations of how those results were computed. Programs in this language therefore describe explanations of probabilistic reasoning problems. The language relies on a story-telling metaphor of explanation, where the reader is guided through a series of well-understood steps from some initial state to the final result. Programs can also be manipulated according to a set of laws to automatically generate equivalent explanations from one explanation instance. This increases the explanatory value of the language by allowing readers to cheaply derive alternative explanations if they do not understand the first. The language is composed of two parts: a formal textual notation for specifying explanation-producing programs and the more elaborate visual notation for presenting those explanations. We formally define the abstract syntax of explanations and define the semantics of the textual notation in terms of the explanations that are produced.     

Towards a verified compiler prototype for the synchronous language SIGNAL

SIGNAL belongs to the synchronous languages family which are widely used in the design of safety-critical real-time systems such as avionics, space systems, and nuclear power plants. This paper reports a compiler prototype for SIGNAL. Compared with the existing SIGNAL compiler, we propose a new intermediate representation (named S-CGA, a variant of clocked guarded actions), to integrate more synchronous programs into our compiler prototype in the future. The front-end of the compiler, i.e., the translation from SIGNAL to S-CGA, is presented. As well, the proof of semantics preservation is mechanized in the theorem prover Coq. Moreover, we present the back-end of the compiler, including sequential code generation and multithreaded code generation with time-predictable properties. With the rising importance of multi-core processors in safetycritical embedded systems or cyber-physical systems (CPS), there is a growing need for model-driven generation of multithreaded code and thus mapping on multi-core. We propose a time-predictable multi-core architecture model in architecture analysis and design language (AADL), and map the multi-threaded code to this model.     

Design and correctness of a compiler for a non-procedural language

Summary Design and correctness proof of a compiler for Lucid, a non-procedural proof-oriented programming language, are given. Starting with the denotational semantics of Lucid, an equivalent operational semantics is derived, and from it the design of compiling algorithms. The algorithms are proved to compile correctly a subset of the language. A discussion of the design choices and of the subset restrictions gives insight into the nature of Lucid as well as into the problem of compiling related non-procedural languages.Work supported by the National Research Council of Canada     

A unified interface for integrating information retrieval

In this paper, we propose a unified interface and a flexible architecture for querying various information sources on the Internet and the WWW using both a popular object model and a data model. We propose an Integrated Information Retrieval (IIR) service based on the Common Object Service Specification (COSS) for Common Object Request Broker Architecture (CORBA) and apply the Document Type Definition (DTD) of eXtensible Markup Language (XML) to define the metadata of information sources for sharing the ontology between mediator and wrappers. The objective of using the IIR design is not only to provide programmers with a uniform interface for coding a software application that can query a variety of information sources on the Internet, but also to create a flexible and extensible environment that easily allows system developers to add new or updated wrappers to the system.