Creating interactive web data applications with spreadsheets

Web services – a new breed of self-contained, self-describing, modular applications published, located, and invoked across the Web – handle functions, from simple requests to complicated business processes. They are defined as network-based application components with a services-oriented architecture (SOA) using standard interface description languages and uniform communication protocols. SOA enables organizations to grasp and respond to changing trends and to adapt their business processes rapidly without major changes to the IT infrastructure. The Inaugural International Conference on Next-Generation Web Services Practices (NWeSP'05) attracted researchers who are also the world's most respected authorities on the semantic Web, Web-based services, and Web applications and services. NWeSP'05 was held in cooperation with the IEEE Computer Society Task Force on Electronic Commerce, the Technical Committee on Internet, and the Technical Committee on Scalable Computing. This special issue presents eight papers focused on different aspects of Web services and their applications. Papers were selected based on fundamental ideas and concepts rather than the thoroughness of techniques employed. Papers are organized as follows: <I>Taher et al.</I> present the first paper, on a Quality of Service Information and Computational framework (QoS-IC) supporting QoS-based service selection for SOA. The framework's functionality is expanded using a QoS constraints model that establishes an association relationship between different QoS properties and is used to govern QoS-based service selection in the underlying algorithm. Using a prototype implementation, the authors demonstrate how QoS constraints improve QoS-based service selection and save consumers valuable time. Due to the complex infrastructure of web applications, response times perceived by clients may be significantly longer than desired. To overcome some of the current problems, <I>Vilas et al.</I>, in the second paper, propose a cache-based extension of the architecture that enhances the current web services architecture, which is mainly based on program-logic or protocol-dependent optimization. In the third paper, Jo and Yoo present authorization for securing XML sources on the Web. One of the disadvantages of existing access control is that the DOM tree must be loaded into memory while all XML documents are parsed to generate the DOM tree, such that a lot of memory is used in repetitive search for tree to authorize access to all nodes in the DOM tree. The complex authorization evaluation process required thus lowers system performance. Existing access control fails to consider information structure and semantics sufficiently due to basic HTML limitations. The authors overcome some of these limitations in the proposed model. In the fourth paper, Jung and Cho propose a novel behavior-network-based method for Web service composition. The behavior network selects services automatically through internal and external links with environmental information from sensors and goals. An optimal service is selected at each step, resulting in a globally optimal service sequence for achieving preset goals. The authors detail experimental results for the proposed model by comparing them with rule-based system and user tests. <I>Kong et al.</I> present an efficient method in the fifth paper for merging heterogeneous ontologies – no ontology building standard currently exists – and the many ontology-building tools available are based on different ontology languages, mostly focusing on how to create, edit and infer the ontology efficiently. Even ontologies about the same domain differ because ontology experts hold different view points. For these reasons, interoperability between ontologies is very low. The authors propose merging heterogeneous domain ontologies by overcoming some of the above limitations. In the sixth paper, Chen and Che provide polynomial-time tree pattern query minimization algorithm whose efficiency stems from two key observations: (i) Inherent redundant "components" usually exist inside the rudimentary query provided by the user, and (ii) nonedundant nodes may become redundant when constraints such as co-occurrence and required child/descendant are given. They show that the algorithm obtained by first augmenting the input tree pattern using constraints, then applying minimization, invariably finds a unique minimal equivalent to the original query. Chen and Che present a polynomial-time algorithm for tree pattern query (TPQ) minimization without XML constraints in the seventh paper. The two-part algorithm is a dynamic programming strategy for finding all matching subtrees within a TPQ. The algorithm consists of one for subtree recognization and a second for subtree deletion. In the last paper, <I>Bagchi et al.</I> present the mobile distributed virtual memory (MDVM) concept and architecture for cellular networks containing server-groups (SG). They detail a two-round randomized distributed algorithm to elect a unique leader and co-leader of the SG that is free of any assumption about network topology, and buffer space limitations and is based on dynamically elected coordinators eliminating single points of failure. As guest editors, we thank all authors featured in this special issue for their contributions and the referees for critically evaluating the papers within the short time allotted. We sincerely believe that readers will share our enjoyment of this special issue and find the information it presents both timely and useful.

Programming language definitions assign formal meaning to complete programs. Programmers, however, spend a substantial amount of time interacting with incomplete programs - programs with holes, type inconsistencies and binding inconsistencies - using tools like program editors and live programming environments (which interleave editing and evaluation). Semanticists have done comparatively little to formally characterize (1) the static and dynamic semantics of incomplete programs; (2) the actions available to programmers as they edit and inspect incomplete programs; and (3) the behavior of editor services that suggest likely edit actions to the programmer based on semantic information extracted from the incomplete program being edited, and from programs that the system has encountered in the past. This paper serves as a vision statement for a research program that seeks to develop these missing semantic foundations. Our hope is that these contributions, which will take the form of a series of simple formal calculi equipped with a tractable metatheory, will guide the design of a variety of current and future interactive programming tools, much as various lambda calculi have guided modern language designs. Our own research will apply these principles in the design of Hazel, an experimental live lab notebook programming environment designed for data science tasks. We plan to co-design the Hazel language with the editor so that we can explore concepts such as edit-time semantic conflict resolution mechanisms and mechanisms that allow library providers to install library-specific editor services.

Live programming is an activity in which the programmer edits code while observing the result of the program. It has been exercised mainly for pedagogical and artistic purposes, where outputs of a program are not straightforwardly imagined. While most live programming environments so far target programs that explicitly generate visual or acoustic outputs, we believe that live programming is also useful for data structure programming, where the programmer often has a hard time to grasp a behavior of programs. However, it is not clear what features a live programming environment should provide for such kind of programs. In this paper, we present a design of live programming environment for data structure programming, identify the problems of synchronization and mental map preservation, and propose solutions based on a calling-context sensitive identification technique. We implemented a live programming environment called Kanon, and tested with 13 programmers.

The Web, as we know it, is a collection of human readable pages that are virtually unintelligible to computer programs. For that reason, it has been called the “eyeball” Web. While the Web emerged as a World Wide repository of digitized information, by and large, the very same information is not available for automatic computation. In recent years two parallel efforts emerged that have the potential of overcoming this paradox: the first effort is the Semantic Web which provides the tools for the explicit markup of the content of Web pages; the second effort is the development of Web Services which results in a Web where programs act as independent agents to become the producers and consumers of information and enable automation of business transactions.In this talk I will focus on research that attempts to bridge the gap between the Web as we know it, the Semantic Web and Web services. Under this approach, I propose the vision of Web services as autonomous goal-directed agents which select other agents to interact with, and flexibly negotiate their interaction model, acting at times in client server mode, or at other times in peer to peer mode. The resulting Web services, that I call Autonomous Semantic Web services, utilize ontologies and semantically annotated Web pages to automate the fulfillment of tasks and transactions with other Web agents. In particular, Autonomous Semantic Web services use the Semantic Web to support capability based discovery and interoperation at run time. A first step towards this vision is the development of formal languages and inference mechanisms for representing and reasoning with core concepts of Web services. DAML-S (the Darpa Agent Markup Language for Services) is the first attempt to define such a language. I will give a brief overview of DAML-S and its relations with the Semantic Web and Web services. In addition, I will provide concrete examples of computational models of how DAML-S can be viewed as the first step in bridging the gap between the Semantic Web and current proposed industry standards for Web services. I will provide concrete examples of DAML-S in action, discuss challenges still open in the bridging between the Semantic Web and Web services and provide a roadmap to get us from today’s Web to the Web of autonomous Semantic Web services.KeywordsFormal LanguageCore ConceptDigitize InformationAutomatic ComputationBusiness TransactionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Heatmap is a powerful visualization method on two-dimensional data to reveal patterns shared by subsets of rows and columns. In R, there are many packages that make heatmaps. Among them, ComplexHeatmap provides rich tools for constructing highly customizable heatmaps. It can easily establish connections between information from multiple sources by automatically concatenating and adjusting multiple heatmaps as well as complex annotations, which makes it widely applied in data analysis in various fields, especially in Bioinformatics. Nevertheless, the limit of ComplexHeatmap still exists. It only generates static plots which restricts deeper inspections on complex heatmaps, e.g., to look into a subset of rows and columns when a specific pattern of interest is observed from the heatmap. In this work, we described a new R/Bioconductor package InteractiveComplexHeatmap that brings interactivity to ComplexHeatmap. InteractiveComplexHeatmap is designed with an easy-to-use interface where static complex heatmaps can be directly exported to an interactive Shiny web application only with one extra line of code. The interactive application contains comprehensive tools for manipulating heatmaps. Besides common tools as supported in other interactive heatmap packages, InteractiveComplexHeatmap additionally supports, e.g., selecting over multiple heatmaps and searching heatmaps via row or column labels. Also, InteractiveComplexHeatmap provides methods for exporting static heatmaps from other popular heatmap functions, e.g., heatmap.2() or pheatmap(), to interactive heatmap applications. Finally, InteractiveComplexHeatmap provides flexible functionalities for integrating interactive heatmap widgets into other Shiny applications. InteractiveComplexHeatmap provides a user interface for self-defining response to the selection events on heatmaps, which helps to implement more complex Shiny web applications.

Several studies provide the questions developers ask during software evolution tasks, providing foundations for subsequent work. Nevertheless, none of them focus on Live Programming environments that gain in popularity as they are perceived to have a positive effect on programming tasks. Studying the impact of a Live Programming environment on software development activities is thus the goal of this study. In a partial replication of the study by Sillito et al., we conducted 17 software evolution sessions in a Live Programming environment and report 1,161 developer questions asked during these sessions. We contrast our results with the results by Sillito et al., focusing on the question occurrences, question complexity and what information participants used to gain a required knowledge. We report eight new questions and observe that the Live Programming facilities do have an impact on the way developers ask questions about source code and use tools to gain corresponding knowledge.

Learning how to program can be quite difficult. Beginners face two obstacles to learning to program: developing a mental model of the steps of computation and learning the syntax of a programming language. Because programmers are prone to make mistakes that introduce errors into their code, it is important that they understand what each line of code is doing in their program. I propose that a system be built in which writing code and running code happen simultaneously. This system shows the results of code to the user immediately after it is typed; this type of system is called a live programming environment. The environment's features allow the programmer to highlight individual lines of code to see their result. The programmer can walk through loops and explore the details of a function call. The programmer can unit test a function or class. The environment displays variables declared in the code and their values and allows the programmer to create a visualization for class objects. The environment appears to be beneficial for beginners based on the results of two surveys with a total of 27 participants. The results of this thesis show that live programming environments should be developed to help the beginner learn to program.

Significant effort is currently invested in application integration, enabling business processes of different companies to interact and form complex multiparty processes. Web service standards, based on WSDL (Web Service Definition Language), have been adopted as process-to-process communication paradigms. However, the conceptual modeling of applications using Web services has not yet been addressed. Interaction with Web services is often specified at the level of the source code; thus, Web service interfaces are buried within a programmatic specification.In this article, we argue that Web services should be considered first-class citizens in the specification of Web applications. Thus, service-enabled Web applications should benefit from the high-level modeling and automatic code generation techniques that have long been advocated for Web application design and implementation. To this end, we extend a declarative model for specifying data-intensive Web applications in two directions: (i) high-level modeling of Web services and their interactions with the Web applications which use them, and (ii) modeling and specification of Web applications implementing new, complex Web services.Our approach is fully implemented within a CASE tool allowing the high-level modeling and automatic deployment of service-enabled Web applications.

The automated run-time detection of feature interactions in Web 2.0 communications applications is an important problem that has not been addressed to date. Such web-enabled communication services are constructed as reusable web widgets that can be composed by users in a web interface. Widgetizing communication features as web services can better serve users with highly customizable features, friendly user interfaces, and easier integration with other web services. However, it also introduces new feature interaction problems. As we show, these composite communication services combine web services and VoIP features in highly dynamic interfaces with application and service state that is typically distributed across multiple domains. In this paper, we present these new feature interactions and propose our solution. We present ten different feature interactions and organize them into a taxonomy. A general method for detecting FIs is given in FOL notation. We also present a coordinator plug-in mechanism for independent widgets to share feature information and state that can be implemented in today's browsers. We finally describe a run-time algorithm for FI detection that is suitable for this architecture and uses the FI notation presented in the paper.

We developed an identifier mapping application for bio-informatics research in Java programming language. It is easy to use and provides many usability functionalities that are expected as essentials for a professional appli-cation. It supports three widely used mapping services and can convert many ids from one source database in-to many target databases at once. Id mapping across service providers is possible by remapping the resultant ids. Because it adheres to the NetBeans platform archi-tecture, it can be incorporated into other NetBeans plat-form applications as an id mapping provider without adaption or modification.Availability: You can access the application at http://ne-on. gachon.ac.kr/idmapper.html.Keywords: ID mapping, java, netbeans, rich client, web services Introduction “-omics” style experiments, such as sequencing, micro-array, and proteomics, generate enormous amounts of data (Kim et al., 2006, Kim et al., 2008). To integrate and analyze the data in various respects, multiple tools are used. Each tool supports its own set of identifiers for genes or gene products. Even though there are widely used identifiers, such as Ensembl (Flicek et al., 2008), NCBI RefSeq (Pruitt et al., 2007), UniProt (The Uniprot Consortium, 2008) and HGNC (Povey et al., 2001), there is no universal identifier. When multiple tools and services are used, identifier conversion prob-lems across multiple databases arise frequently. A small research group can not afford its own mapping service and relies on external services. There exist efforts to reconcile identifiers across multiple source databases, such as the David gene ID conversion tool (Huang et al., 2008), MatchMiner (Bussey et al., 2003), IDconverter (Alibes et al., 2007), Onto- translate (Khatri et al., 2006), PICR (Cote et al., 2007), Synergizer (Brriz et al., 2008), and Biomart (Smedley et al., 2009). Services that are provided in the form of a web page can not be incorporated into other applications easily. Only a few services provide API access for batch map-ping or incorporation into other applications. The Protein Identifier Cross-Reference (PICR) service is a web application that provides interactive and pro-grammatic (SOAP and REST) access to a mapping algo-rithm that uses the UniProt Archive (UniParc) as a data warehouse to offer protein cross-references. The Syner-gizer is a service for translating between sets of bio-logical identifiers. It can, for example, translate Ensembl Gene IDs to Entrez Gene IDs, or IPI IDs to HGNC gene symbols, and much more. The Synergizer works via a web interface (for users who are not programmers) or through a web service (for programmatic access). BioMart is a query-oriented data management system, developed jointly by the Ontario Institute for Cancer Research (OICR) and the European Bioinformatics Insti-tute (EBI). It can be accessed via web services and can be adapted for identifier mapping. BridgeDb, though not released publically yet, is an-other attempt at an id mapping framework for bio-informatics applications. BridgeDb lets one add the fol-lowing capabilities quickly and easily: translate identi-fiers from one system to another, search references by id or symbol, and link out to online information for an identifier. Applications, such as the PathVisio pathway analysis tool, WikiPathways, CyThesaurus Cytoscape plug-in, and the NetworkMerge Cytoscape plug-in, are utilizing functionalities provided by BridgeDB.

With the proliferation of very large data repositories hidden behind web interfaces, e.g., keyword search, form-like search and hierarchical/graph-based browsing interfaces for Amazon.com, eBay.com, etc., efficient ways of searching, exploring and/or mining such web data are of increasing importance.

In times of emerging diseases, data sharing and data integration are of particular relevance for One Health Surveillance (OHS) and decision support. Furthermore, there is an increasing demand to provide governmental data in compliance to the FAIR (Findable, Accessible, Interoperable, Reusable) data principles. Semantic web technologies are key facilitators for providing data interoperability, as they allow explicit annotation of data with their meaning, enabling reuse without loss of the data collection context. Among these, we highlight ontologies as a tool for modeling knowledge in a field, which simplify the interpretation and mapping of datasets in a computer readable medium; and the Resource Description Format (RDF), which allows data to be shared among human and computer agents following this knowledge model. Despite their potential for enabling cross-sectoral interoperability and data linkage, the use and application of these technologies is often hindered by their complexity and the lack of easy-to-use software applications. To overcome these challenges the OHEJP Project ORION developed the Health Surveillance Ontology (HSO). This knowledge model forms a foundation for semantic interoperability in the domain of One Health Surveillance. It provides a solution to add data from the target sectors (public health, animal health and food safety) in compliance with the FAIR principles of findability, accessibility, interoperability, and reusability, supporting interdisciplinary data exchange and usage. To provide use cases and facilitate the accessibility to HSO, we developed the One Health Linked Data Toolbox (OHLDT), which consists of three new and custom-developed web applications with specific functionalities. The first web application allows users to convert surveillance data available in Excel files online into HSO-RDF and vice versa. The web application demonstrates that data provided in well-established data formats can be automatically translated in the linked data format HSO-RDF. The second application is a demonstrator of the usage of HSO-RDF in a HSO triplestore database. In the user interface of this application, the user can select HSO concepts based on which to search and filter among surveillance datasets stored in a HSO triplestore database. The service then provides automatically generated dashboards based on the context of the data. The third web application demonstrates the use of data interoperability in the OHS context by using HSO-RDF to annotate meta-data, and in this way link datasets across sectors. The web application provides a dashboard to compare public data on zoonosis surveillance provided by EFSA and ECDC. The first solution enables linked data production, while the second and third provide examples of linked data consumption, and their value in enabling data interoperability across sectors. All described solutions are based on the open-source software KNIME and are deployed as web service via a KNIME Server hosted at the German Federal Institute for Risk Assessment. The semantic web extension of KNIME, which is based on the Apache Jena Framework, allowed a rapid an easy development within the project. The underlying open source KNIME workflows are freely available and can be easily customized by interested end users. With our applications, we demonstrate that the use of linked data has a great potential strengthening the use of FAIR data in OHS and interdisciplinary data exchange.

Web services technologies are emerging as a new approach for supporting e-science and e-engineering by providing access to heterogeneous computation resources and integration of distributed scientific applications. In this paper, we propose a Web portal architecture that enables end users to access the distributed application through the Web interface and to compose new tasks by integrating a set of high level Web services provided by portal developers. The portal design demonstrates that flexibility, reusability and interoperability can be provided for both end users and portal developers by using semantic Web services technologies.

A Web-Based Perioperative Dashboard as a Platform for Anesthesia Informatics Innovation.

Though tactile maps have been shown to be useful tools for visually impaired individuals, their availability has been limited by manufacturing and design costs. In this paper, we present a system that uses 3D printing to (1) make tactile maps more affordable to produce, (2) allow visually impaired individuals to independently design and customize maps, and (3) provide interactivity using widely available mobile devices. Our system consists of three parts: a web interface, a modeling algorithm, and an interactive touchscreen application. Our web interface, hosted at www.tactilemaps.net, allows visually impaired individuals to create maps of any location on the globe while specifying (1) what features to map, (2) how the features should be represented by textures, and (3) where to place markers and labels. Our modeling algorithm accommodates user specifications to create map models with (1) multiple layers of continuously varying textures and (2) markers of various geometric shapes or braille characters. Our interactive application uses a novel approach to 3D printing tactile maps using conductive filament to provide touchscreen overlays that allow users to dynamically interact with the maps on a wide range of mobile devices. This paper details the implementation of our system. We also present findings from a user study validating the usability of our mapping interface and the utility of the maps produced. Finally, we discuss the limitations of our current implementation and the plans we have to improve our system based on feedback from our user study and additional interviews.