OSM-CAT: A software application to generate contribution summaries from OpenStreetMap XML

OpenStreetMap (OSM) is currently the most extensive and widely-used example of Volunteered Geographical Information (VGI) available on the Internet. The aim of the OSM project is to provide a free and openly accessible spatial database. The data is provided by volunteers, who collect and contribute it to the OSM database using a variety of techniques and methods. OSM data is then most commonly used and accessed via a user-friendly webbased map on www.openstreetmap.org. The spatial data corresponding to any OSM mapped area can be exported in a special XML based format, namely OSM-XML. This provides a convenient and dedicated transport format which matches the OSM databases' model. Using these OSM-XML files one should be able to extract information about contribution patterns and tagging summaries for the data. However, the simplicity of OSM-XML is also potentially its greatest disadvantage. Processing OSM-XML data files efficiently can be problematic given that mapped areas can produce complex, large files. In this thesis we present the design and implementation of a new Java-based software application called the OpenStreetMap Contributor Analysis Tool (OSM-CAT) for computing contribution summaries from OSM-XML. OSM-CAT allows users to process OSM-XML data efficiently, and automatically produces a detailed summary of the contents of the dataset. This analysis places specific emphasis on 'interesting' statistics, such as who contributed to the OSM data in a chosen area, what types of contributions were made to the OSM data, when these contributions were made, and the accuracy of map feature tagging. While similar tools exist that do some of these tasks, OSM-CAT provides GIS researchers and interested individuals with a complete and integrated overview of contributions to OSM, corresponding to the input OSM-XML datasets. We present a full analysis of OSM-CAT on a large set of OSMXML datasets, and discuss its usefulness to the OSM community and beyond. We close the thesis with some conclusions, and set out a number of issues for consideration as future work. A comprehensive appendix is provided with additional information for those wishing to use OSM-CAT

BSML: A Binding Schema Markup Language for Data Interchange in Problem Solving Environments (PSEs)

We describe a binding schema markup language (BSML) for describing data interchange between scientific codes. Such a facility is an important constituent of scientific problem solving environments (PSEs). BSML is designed to integrate with a PSE or application composition system that views model specification and execution as a problem of managing semistructured data. The data interchange problem is addressed by three techniques for processing semistructured data: validation, binding, and conversion. We present BSML and describe its application to a PSE for wireless communications system design

Application of Model-driven engineering to multi-agent systems: a language to model behaviors of reactive agents

Many users of multi-agent systems (MAS) are very commonly disinclined to model and simulate using current MAS platforms. More specifically, modeling the dynamics of a system (in particular the agents' behaviors) is very often a challenge to MAS users. This issue is more often observed in the domain of socio-ecological systems (SES), because SES domain experts are rarely programmers. Indeed, the majority of MAS platforms were not conceived taking into consideration domain-experts who are non-programmers. Most current MAS tools are not dedicated to SES, or nor do they possess an easily understandable formalism to represent the behaviors of agents. Moreover, because it is platform-dependent, a model realized in a given MAS platform cannot be properly used on another platform due to incompatibility between MAS platforms. To overcome these limitations, we propose a domain-specific language (DSL) to describe the behaviors of reactive agents, regardless of the MAS platform used for simulation. To achieve this result, we used model-driven engineering (MDE), an approach that provides tools to develop DSLs from a meta-model (abstract syntax), textual editors with syntax highlighting (for the concrete syntax) and code generation capabilities (for source-code generation of a model). As a result, we implemented a language and a textual editor that allow SES domain experts to describe behaviors in three different ways that are close to their natural expression: as equations when they are familiar with these, as a sequence of activities close to natural language or as an activity diagram to represent decisions and a sequence of behaviors using a graphic formalism. To demonstrate interoperability, we also developed code generators targeting two different MAS platforms (Cormas and Netlogo). We tested the code generators by implementing two SES models with the developed DSL. The generated code was targeted to both MAS platforms (Cormas and Netlogo), and successfully simulated in one of them. We conclude that the MDE approach provides adequate tools to develop DSL and code generators to facilitate MAS modeling and simulation by non-programmers. Concerning the DSL developed, although the behavioral aspect of MAS simulation is part of the complexity of modeling in MAS, there are still other essential aspects of model and simulation of MAS that are yet to be explored, such as model initialization and points of view on the model simulated worl

VisualLISA: a visual environment to develop attribute grammars

The focus of this paper is on crafting a new visual language for attribute grammars (AGs), and on the development of the associated programming environment. We present a solution for rapid development of VisualLISA editor using DEViL. DEViL uses traditional attribute grammars, to specify the language’s syntax and semantics, extended by visual representations to be associated with grammar symbols. From these specifications a visual programming environment is automatically generated. In our case, the environment allows us to edit a visual description of an AG that is automatically translated into textual notations, including an XML-based representation for attribute grammars (XAGra), and is intended to be helpful for beginners and rapid development of small AGs. XAGra allows us to use VisualLISA with other compiler-compiler tools

A Program Visualization System That Supports the Program Understanding Process.

The goal of this research is to provide a graphical system that supports the program understanding process by representing the program\u27s control flow, the code and the identifiers local to a specific point within the program. By having more information local to the point of interest, the programmer can maintain continuity in developing program understanding. The programmer can see loops, procedure calls, and other structures with respect to their execution order and can view them in the environment or the context in which they will execute. The Peec system supplies a graphical representation of the program\u27s control flow in which the control structures are represented as tiers. The tiers are arranged in a three-dimensional space representing the program\u27s operational flow. The body of the procedure or function is nested within the reference tier so that the programmer views the routine local to its reference point. Also, a list of live identifiers is displayable for the current tier element. The advantage is that the routine\u27s text and the identifier list are local to the area of study and the programmer does not have to look elsewhere for the program text and the identifier definition. The programmer can maintain a continuity in developing program understanding using information local to the point of interest. The Peec system consists of the Peec compiler which transforms a Pascal program into tier and identifier information, and the Peec environment for modeling the program\u27s operational flow image. The Peec environment provides the programmer many interactive capabilities. These capabilities consist of browsing the flow model, displaying text, displaying identifiers and transforming the three-dimensional flow model into appropriate views. These features are aimed at assisting the programmer in the processing of developing program understanding

Natural language semantics and compiler technology

This paper recommends an approach to the implementation of semantic representation languages (SRLs) which exploits a parallelism between SRLs and programming languages (PLs). The design requirements of SRLs for natural language are similar to those of PLs in their goals. First, in both cases we seek modules in which both the surface representation (print form) and the underlying data structures are important. This requirement highlights the need for general tools allowing the printing and reading of expressions (data structures). Second, these modules need to cooperate with foreign modules, so that the importance of interface technology (compilation) is paramount; and third, both compilers and semantic modules need "inferential" facilities for transforming (simplifying) complex expressions in order to ease subsequent processing. But the most important parallel is the need in both fields for tools which are useful in combination with a variety of concrete languages -- general purpose parsers, printers, simplifiers (transformation facilities) and compilers. This arises in PL technology from (among other things) the need for experimentation in language design, which is again parallel to the case of SRLs. Using a compiler-based approach, we have implemented NLL, a public domain software package for computational natural language semantics. Several interfaces exist both for grammar modules and for applications, using a variety of interface technologies, including especially compilation. We review here a variety of NLL, applications, focusing on COSMA, an NL interface to a distributed appointment manager

Conversational natural language interaction for place-related knowledge acquisition

We focus on the problems of using Natural Language inter- action to support pedestrians in their place-related knowledge acquisi- tion. Our case study for this discussion is a smartphone-based Natu- ral Language interface that allows users to acquire spatial and cultural knowledge of a city. The framework consists of a spoken dialogue-based information system and a smartphone client. The system is novel in com- bining geographic information system (GIS) modules such as a visibility engine with a question-answering (QA) system. Users can use the smart- phone client to engage in a variety of interleaved conversations such as navigating from A to B, using the QA functionality to learn more about points of interest (PoI) nearby, and searching for amenities and tourist attractions. This system explores a variety of research questions involving Natural Language interaction for acquisition of knowledge about space and place

The Larch Environment - Python programs as visual, interactive literature

The Larch Environment' is designed for the creation of programs that take the form of interactive technical literature. We introduce a novel approach to combined textual and visual programming by allowing visual, interactive objects to be embedded within textual source code, and segments of source code to be further embedded within those objects. We retain the strengths of text-based source code, while enabling visual programming where it is bene�cial. Additionally, embedded objects and code provide a simple object-oriented approach to extending the syntax of a language, in a similar fashion to LISP macros. We provide a rapid prototyping and experimentation environment in the form of an active document system which mixes rich text with executable source code. Larch is supported by a simple type coercion based presentation protocol that displays normal Java and Python objects in a visual, interactive form. The ability to freely combine objects and source code within one another allows for the construction of rich interactive documents and experimentation with novel programming language extensions