TOWARDS UNDERSTANDING THE ROLE IMPORTANCE, AND IMPACT OF NATURAL LANGUAG INTERFACES TO DATABASES

This paper integrates diverse literature on natural language interfaces to databases, most of which emphasize technical issues. It formalizes one of the only categorizations of interfaces proposed in the literature. It also suggest how these systems may impact organizational activities, information systems usage, and decision makers\u27 performance. A survey of information systems professionals regarding the use, role, importance, and perceptions about natural language interfaces is reported. The findings may be specially useful for developing implementation strategies for natural language based systems and further research in this area

Towards an Ideal Database Server for Office Automation Environments

Office automation systems are growing but continue both in use and complexity. The evelopment of a database management system for the office automation environment ecomes a high priority, inorder to provide an efficient and reliable way to engage the information needs of the office. Therefore, the specification of an 'ideal' database server for the office automation environment becomes a key area of concern. inaddition to providing traditional support, the ideal database server must also provide new database support, in order to meet the unique and nyneedsofofficeautomationenvironments. In this paper, we focus on the characterization and specification of an ideal database server, for the office automation environment. We also consider how such an ideal database server can effectively Integrated into the office automation environment. Further, we ne an experimental database system, known as the multi-backend database system (NSDS), as a candidate for the ideal database server in the office automation environment.Chief of Naval Researc

SheetCopilot: Bringing Software Productivity to the Next Level through Large Language Models

Computer end users have spent billions of hours completing daily tasks like tabular data processing and project timeline scheduling. Most of these tasks are repetitive and error-prone, yet most end users lack the skill to automate these burdensome works. With the advent of large language models (LLMs), directing software with natural language user requests become a reachable goal. In this work, we propose a SheetCopilot agent that takes natural language task and control spreadsheet to fulfill the requirements. We propose a set of atomic actions as an abstraction of spreadsheet software functionalities. We further design a state machine-based task planning framework for LLMs to robustly interact with spreadsheets. We curate a representative dataset containing 221 spreadsheet control tasks and establish a fully automated evaluation pipeline for rigorously benchmarking the ability of LLMs in software control tasks. Our SheetCopilot correctly completes 44.3\% of tasks for a single generation, outperforming the strong code generation baseline by a wide margin. Our project page:https://sheetcopilot.github.io/.Comment: Accepted to NeurIPS 202

Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules (Technical Report)

Verified compilation of open modules (i.e., modules whose functionality depends on other modules) provides a foundation for end-to-end verification of modular programs ubiquitous in contemporary software. However, despite intensive investigation in this topic for decades, the proposed approaches are still difficult to use in practice as they rely on assumptions about the internal working of compilers which make it difficult for external users to apply the verification results. We propose an approach to verified compositional compilation without such assumptions in the setting of verifying compilation of heterogeneous modules written in first-order languages supporting global memory and pointers. Our approach is based on the memory model of CompCert and a new discovery that a Kripke relation with a notion of memory protection can serve as a uniform and composable semantic interface for the compiler passes. By absorbing the rely-guarantee conditions on memory evolution for all compiler passes into this Kripke Memory Relation and by piggybacking requirements on compiler optimizations onto it, we get compositional correctness theorems for realistic optimizing compilers as refinements that directly relate native semantics of open modules and that are ignorant of intermediate compilation processes. Such direct refinements support all the compositionality and adequacy properties essential for verified compilation of open modules. We have applied this approach to the full compilation chain of CompCert with its Clight source language and demonstrated that our compiler correctness theorem is open to composition and intuitive to use with reduced verification complexity through end-to-end verification of non-trivial heterogeneous modules that may freely invoke each other (e.g., mutually recursively)

The difference a method makes : methods as epistemic objects in computational science

Computational science is intrinsically interdisciplinary; the methods of one scientist may be the objects of study for another. This essay is an attempt to develop an interdisciplinary framework that can analyse research into methods as a distinctive kind of epistemic orientation in science, drawing on two examples from fieldwork with a group of specialists in computer modelling. Where methods for simulation are objects of research in their own right, they are distinct in kind to the objects of simulation, and raise a different set of sociological and philosophical questions. Drawing on the historian Hans-Jorg Rheinberger’s theory of epistemic objects, I ask: what kind of epistemic object does a method make, and how is research organized around it? I argue that methods become objects of research as purposeful things, in terms of their enrolment in the intentional structure of the experimental system. And, as methods research tends to be interventionary, in the sense that its mode of study creates and modifies its objects, we therefore observe a practical recursion, a dynamic of scientific reinvention, a ‘tuning’ of experimental systems that sheds light on the form of these systems’ historicity, their differential self-reproduction

Type Systems for Coordination Languages

S-Net is a declarative coordination language rooted in stream processing with a runtime that automatically distributes the computational units among available resources. It is conceived in response to the change of processor development trend, from making the speed faster to embedding more cores. For performance reasons, the S-Net compiler is responsible for generating some additional information, through type inference, which is used by the runtime to make data delivery decisions. This requires the compiler to be supported by a sound type system which can ensure that the program behaviour meets the expectations of the language designers and the programmers. However, due to S-Net's design principle of ease of use, the S-Net type system was believed to be simple and was only informally documented. As we empirically tested the type inference implementation, we gradually revealed the hidden complexity of the calculus behind the apparently easy-to-use language, which was clearly beyond the capability of the informal type system. We then attempted several formulations of the type system, each addressing more issues we have found, but a complete solution was still missing. S-Net now urgently needs a formal type system with proofs of soundness. We have identified a major issue which has been making it difficult to design a correct type system, that is the type-semantics interdependency. In this thesis, we present a new design of the S-Net semantics and type system with no type-semantics interdependency, in terms of a new language BL-Net, a reduced S-Net which preserves only the type-related behaviour, which has an operational semantics reflecting that of S-Net, and a type system with the soundness and completeness proof. Our contributions also include a bridging solution to fit the new type system into the existing compiler structure

On Language Interfaces

International audienceComplex systems are developed by teams of experts from multiple domains , who can be liberated from becoming programming experts through domain-specific languages (DSLs). The implementation of the different concerns of DSLs (including syntaxes and semantics) is now well-established and supported by various languages workbenches. However, the various services associated to a DSL (e.g., editors, model checker, debugger or composition operators) are still directly based on its implementation. Moreover, while most of the services crosscut the different DSL concerns, they only require specific information on each. Consequently, this prevents the reuse of services among related DSLs, and increases the complexity of service implementation. Leveraging the time-honored concept of interface in software engineering, we discuss the benefits of language interfaces in the context of software language engineering. In particular, we elaborate on particular usages that address current challenges in language development

Composition et interopérabilité pour l'ingénierie des langages dédiés externes

Following the principles of Model-Driven Engineering and Language-Oriented Programming, Domain-Specific Languages (DSLs) are now developed in numerous domains to address specific concerns in the development of complex systems. However, despite many advances in Software Language Engineering, DSLs and their tooling still suffer from substantial development costs which hamper their successful adoption in the industry.We identify two main challenges to be addressed. First, the proliferation of independently developed and constantly evolving DSLs raises the problem of interoperability between similar languages and environments. Language users must be given the flexibility to open and manipulate their models using different variants and versions of various environments and services to foster collaboration in the development of complex systems. Second, since DSLs and their environments suffer from high development costs, tools and methods must be provided to assist language designers and mitigate development costs.In this thesis, we address these challenges through three interconnected contributions. First, we propose the notion of language interface. Using language interfaces, one can vary or evolve the implementation of a DSL while retaining the compatibility with the services and environments defined on its interface. Then, we present a mechanism, named model polymorphism, for manipulating models through different language interfaces. Model polymorphism opens up the possibility to safely manipulate models using different modeling environments and services. Finally, we propose a meta-language that enables language designers to reuse legacy DSLs, compose them, extend them, and customize them to meet new requirements. This approach relies on language interfaces to provide a reasoning layer for ensuring the structural correctness of composed DSLs and their safe manipulation.We implement all our contributions in a new language workbench named Melange. Melange supports the modular definition of DSLs, and the interoperability of their environments. Melange is seamlessly integrated with the de facto standard Eclipse Modeling Framework (EMF) and provides model polymorphism to any EMF-based tool of the Eclipse modeling ecosystem. Using Melange, we show how to reuse tools and services over various language families (four versions of the Unified Modeling Language, and a family of statechart languages), and how to flexibly manipulate their models. We also show how Melange eases the development of new DSLs by designing a new modeling language for Internet of Things systems as an assembly of various independently developed languages.Different perspectives directly stem from the contributions presented in this thesis. In particular, we discuss how our contributions constitutes a first step towards component-based language engineering and viewpoints engineering.Le développement de langages dédiés (DSLs) est une activité récurrente lors de l'ingénierie de systèmes complexes à forte composante logicielle. Cependant, malgré de nombreuses avancées dans l'ingénerie des langages, les coûts de développement élevés des DSLs et de leur outillage entravent toujours leur adoption par l'industrie.Nous identifions deux enjeux principaux. Tout d'abord, la prolifération de DSLs développés de manière indépendante et en constante évolution pose le problème de l'interopérabilité entre langages et environnements similaires. En outre, afin de diminuer leurs coûts de développement, des outils et méthodes appropriés doivent être proposés pour assister les développeurs de langage. Dans ce but, nous proposons tout d'abord la notion d'interface de langage. En utilisant des interfaces de langage, il est possible de faire varier ou évoluer l'implémentation d'un DSL tout en conservant la comptabilité avec les services et environnements définis sur son interface. Nous présentons ensuite un mécanisme, le polymorphisme de modèle, permettant de manipuler des modèles à travers différentes interfaces de langage. Enfin, nous proposons un méta-langage permettant aux développeurs de langages de réutiliser des DSLs existants, de les composer, de les étendre et de les personnaliser pour s'adapter à de nouvelles exigences.Nous implémentons chacune de nos contributions dans un nouvel environnement de développement de langage nommé Melange, qui supporte la définition modulaire de DSLs et l'interopérabilité de leur outillage. Nous évaluons la capacité de Melange à résoudre des scénarios avancés d'ingénierie des langages