17 research outputs found
The RPC Calculus
Several recent language designs have offered a unified language
for programming a distributed system, with explicit notation of locations;
we call these “location-aware” languages. These languages
provide constructs allowing the programmer to control the location
(the choice of host, for example) where a piece of code should run,
which can be useful for security or performance reasons. On the
other hand, a central mantra of WWW system engineering prescribes
that web servers should be “stateless”: that no “session
state” should be maintained on behalf of individual clients—that
is, no state that pertains to the particular point of the interaction at
which a client program resides. Many implementations of locationaware
languages are not at home on the web: they hold some kind
of client-specific state on the server. We show how to implement a
symmetrical location-aware language on top of a stateless server
A Polymorphic RPC Calculus
The RPC calculus is a simple semantic foundation for multi-tier programming
languages such as Links in which located functions can be written for the
client-server model. Subsequently, the typed RPC calculus is designed to
capture the location information of functions by types and to drive location
type-directed slicing compilations. However, the use of locations is currently
limited to monomorphic ones, which is one of the gaps to overcome to put into
practice the theory of RPC calculi for client-server model. This paper proposes
a polymorphic RPC calculus to allow programmers to write succinct multi-tier
programs using polymorphic location constructs. Then the polymorphic multi-tier
programs can be automatically translated into programs only containing location
constants amenable to the existing slicing compilation methods. We formulate a
type system for the polymorphic RPC calculus, and prove its type soundness.
Also, we design a monomorphization translation together with proofs on its type
and semantic correctness for the translation.Comment: SBMF-Brazilian Symposium on Formal Methods 201
Using Links to prototype a Database Wiki
Both relational databases and wikis have strengths that make them attractive for use in collaborative applications. In the last decade, database-backed Web applications have been used extensively to develop valuable shared biological references called curated databases. Databases offer many advantages such as scalability, query optimization and concurrency control, but are not easy to use and lack other features needed for collaboration. Wikis have become very popular for early-stage biocuration projects because they are easy to use, encourage sharing and collaboration, and provide built-in support for archiving, history-tracking and annotation. However, curation projects often outgrow the limited capabilities of wikis for structuring and efficiently querying data at scale, necessitating a painful phase transition to a database-backed Web application. We perceive a need for a new class of general-purpose system, which we call a Database Wiki, that combines flexible wiki-like support for collaboration with robust database-like capabilities for structuring and querying data. This paper presents DBWiki, a design prototype for such a system written in the Web programming language Links. We present the architecture, typical use, and wiki markup language design for DBWiki and discuss features of Links that provided unique advantages for rapid Web/database application prototyping
Towards native higher-order remote procedure calls
We present a new abstract machine, called DCESH, which mod-els the execution of higher-order programs running in distributed architectures. DCESH implements a native general remote higher-order function call across node boundaries. It is a modernised ver-sion of SECD enriched with specialised communication features required for implementing the remote procedure call mechanism. The key correctness result is that the termination behaviour of the remote procedure call is indistinguishable (bisimilar) to that of a local call. The correctness proofs and the requisite definitions for DCESH and other related abstract machines are formalised using Agda. We also formalise a generic transactional mechanism for transparently handling failure in DCESHs. We use the DCESH as a target architecture for compiling a conventional call-by-value functional language ("Floskel") whic
A Typed Slicing Compilation of the Polymorphic RPC Calculus
The polymorphic RPC calculus allows programmers to write succinct multitier
programs using polymorphic location constructs. However, until now it lacked an
implementation. We develop an experimental programming language based on the
polymorphic RPC calculus. We introduce a polymorphic Client-Server (CS)
calculus with the client and server parts separated. In contrast to existing
untyped CS calculi, our calculus is not only able to resolve polymorphic
locations statically, but it is also able to do so dynamically. We design a
type-based slicing compilation of the polymorphic RPC calculus into this CS
calculus, proving type and semantic correctness. We propose a method to erase
types unnecessary for execution but retaining locations at runtime by
translating the polymorphic CS calculus into an untyped CS calculus, proving
semantic correctness.Comment: A long version of PPDP 2021 (23rd International Symposium on
Principles and Practice of Declarative Programming
Multiparty Languages: The Choreographic and Multitier Cases (Pearl)
Choreographic languages aim to express multiparty communication protocols, by providing primitives that make interaction manifest. Multitier languages enable programming computation that spans across several tiers of a distributed system, by supporting primitives that allow computation to change the location of execution. Rooted into different theoretical underpinnings - respectively process calculi and lambda calculus - the two paradigms have been investigated independently by different research communities with little or no contact. As a result, the link between the two paradigms has remained hidden for long.
In this paper, we show that choreographic languages and multitier languages are surprisingly similar. We substantiate our claim by isolating the core abstractions that differentiate the two approaches and by providing algorithms that translate one into the other in a straightforward way. We believe that this work paves the way for joint research and cross-fertilisation among the two communities
Ur/Web: A Simple Model for Programming the Web
The World Wide Web has evolved gradually from a document delivery platform to an architecture for distributed programming. This largely unplanned evolution is apparent in the set of interconnected languages and protocols that any Web application must manage. This paper presents Ur/Web, a domain-specific, statically typed functional programming language with a much simpler model for programming modern Web applications. Ur/Web's model is unified, where programs in a single programming language are compiled to other "Web standards" languages as needed; modular, supporting novel kinds of encapsulation of Web-specific state; and exposes simple concurrency, where programmers can reason about distributed, multithreaded applications via a mix of transactions and cooperative preemption. We give a tutorial introduction to the main features of Ur/Web, formalize the basic programming model with operational semantics, and discuss the language implementation and the production Web applications that use it.National Science Foundation (U.S.) (Grant CCF-1217501
Séparation des couleurs dans un lambda-calcul bichrome
National audienceDans cet article nous introduisons un λ-calcul bichrome pour expliciter une partie de l'évaluation d'un terme en précisant la localité du calcul1. L'intérêt est alors de pouvoir définir une transformation, par β-expansion, qui regroupe les expressions de même couleur. Les propriétés de correction, de terminaison et de confluence de cette transformation sont démontrées 'a l'aide de l'assistant de preuves Coq. Cette transformation est indépendante de la sémantique de communication et de synchronisation de l'application. On s'intéresse alors aux applications utilisant deux unités de calcul comme les couples client-serveur de la programmation Web. Nous abordons le passage à un λ-calcul à plus de deux couleurs et montrons les difficultés que cela engendre