Program

Day I, November 12th, 2013 (at ICAB, Madera room)
09:30–09:45 Welcome and Introduction
09:45–10:45 Foundations for tier-less web programming in WebDSL
Eelco Visser
10:45–11:45 Safe tier splitting using practical effect inference in Koka.
Daan Leijen
11:45–13:00 Lunch Break
13:00–14:00 Orchestrating Asynchronous Events on the Web
Manuel Serrano
14:00–15:00 Opa and AngularJS
Adam Koprowski
15:00–15:30 Coffee Break
15:30–16:30 Scala.js: write in Scala for the browser
Sebastien Doeraene
16:30–17:30 Contracts for eventuation properties
Mario Südholt
 
Day II, November 13th, 2013 (VUB Campus, Room D2.01)
09:30–09:45 Welcome
09:45–10:45 A practical theory of language-integrated query
Philip Wadler
10:45–11:45 A formal introduction to TypeScript
Gavin Bierman
11:45–13:00 Lunch Break
13:00–14:00 Programming Language Semantics as Natural Science
Shriram Krishnamurthi
14:00–15:00 Ur/Web: Taking Syntax Seriously
Adam Chlipala
15:00–15:30 Coffee Break
15:30–16:30 From AmbientTalk to CloudTalk
Wolfgang De Meuter and Tom Van Cutsem
16:30–17:30 Panel: The Future of Web/Internet Programming Languages


Foundations for tier-less web programming in WebDSL
Eelco Visser (TU Delft)

WebDSL is a domain-specific language for tier-less web programming, which linguistically integrates support for concerns such as data modeling, user interface templates, access control, data validation, and search. The compiler and Eclipse IDE for WebDSL statically check consistency between these concerns and guarantee a number of safety properties. In this talk I will explore the design of the language, in particular its request life cycle model.


Safe tier splitting using practical effect inference in Koka.
Daan Leijen (Microsoft Research, Redmond)

Koka is a strongly typed function oriented language where the potential side-effects of a function are apparent in its type signature. Such effect types give strong guarantees about your program: for example, a function that is typed without an “exn” effect will never throw an unhandled exception.

Koka compiles to JavaScript and resulting programs can run both in the browser or as NodeJS programs. In this talk, I will introduce Koka and show how using the effect types of Koka we can guarantee “safe tier-splitting”, i.e. where one program contains both the client and server parts but where it is guaranteed that these parts can only interact through specific api’s, and not for example by sharing a global variable.

You can try out Koka live at www.rise4fun.com/koka/tutorial.


Orchestrating Asynchronous Events on the Web
Manuel Serrano (INRIA Sophia-Antipolis)

The forthcoming Web-of-Things applications will merge classical computing, client-server concurrency, web-based interfaces, and the complex time- or event-base reactive programming found in embedded systems. To handle them, we extend the Hop multitier Scheme-based web programming platform by HipHop, a new domain-specific language embedded within Hop and dedicated to event-based process orchestration. Borrowing the synchronous reactive model of Esterel, HipHop is based on synchronous concurrency and preemption primitives, which are known to be the key components for the modular design of complex reactive behaviors. Contrarily to classical embedded systems, web applications will be very dynamic and adapt to their environment; thus, we introduce new primitives to handle program code dynamicity. Using a music player example, we show how to modularly build non-trivial orchestration code with HipHop and Hop.


Opa and AngularJS
Adam Koprowski (Google)

JavaScript is a de-facto standard for web development.  It is the glue of client-side web programming and, with the rise of Node.js, is becoming more and more popular on the server-side.  In this talk I will present two solutions that try to address some of the shortcomings of JavaScript.

The first one, Opa, is a full-fledged programming language developed by MLstate.  It combines client-side, server-side and database programming all in one coherent language that compiles, respectively, to JavaScript, Node.js and MongoDB queries.  Probably the most notable feature of Opa is the fact that it is a strongly typed, functional language with type inference.

In the second part of my talk I will focus on AngularJS, a JavaScript framework developed by Google.  It provides clear structure for web applications, following the model-view-controller (MVC) pattern.  It allows developers to easily write custom, reusable tags specific for their applications and enables declarative UI programming thanks to its two-way data bindings synchronizing models with views.


Scala.js: write in Scala for the browser
Sebastien Doeraene (École Polytechnique Fédérale de Lausanne)

As browser applications become larger and larger, developers start feeling some limitations of JavaScript. This explains the explosion of new languages targeting JavaScript, and ports of existing languages to JavaScript. In this talk, we present yet another such port: Scala.js, a Scala to JavaScript compiler.

Scala is a statically-typed, functional and object-oriented language. Arguably, its concepts and syntax make it particularly well suited to event-based programming models. Most notably, it was a big factor in popularizing the actor model. More recently, it also provides nice abstractions for reactive programming.

First, we will present Scala.js in general, and show what it is capable of. Then, we will discuss work in progress at designing and implementing an actor system for Scala.js: how it fits into the single-threaded, event-based model of JavaScript; and how it can communicate with an Akka-based backend.


Contracts for eventuation properties
Mario Südholt (École des Mines de Nantes)

Properties that do not hold for some time during system execution but must be satisfied at some later points in time are of increasing importance for many types of applications, especially concurrent and distributed ones. Typical examples of such “eventuation” properties include eventual consistency of replicated data in distributed systems with communication failures and security properties that cannot be verified for parts of a computation but have to be enforced later on. Programming-level support for several kinds of such properties, such as Cloud types, has gained quite some interest recently.

In this talk we first review different types of such properties and proposals for corresponding language-level mechanisms. We then present novel means to support their analysis and enforcement using contracts, especially contracts based on typed interaction protocols.


A practical theory of language-integrated query
Philip Wadler (U Edinburgh)

Language-integrated query is receiving renewed attention, in part because of its support through Microsoft’s LINQ framework. We present a theory of language-integrated query based on quotation and normalisation of quoted terms. Our technique supports abstraction over values and predicates, composition of queries, dynamic generation of queries, and queries with nested intermediate data. Higher-order features prove useful even for constructing first-order queries. We prove that normalisation always succeeds in translating any query of flat relation type to SQL. We present experimental results confirming our technique works, even in situations where Microsoft’s LINQ framework either fails to produce an SQL query or, in one case, produces an avalanche of SQL queries. The talk will include an overview of our previous Links project and its successor, ABCD.


A formal introduction to TypeScript
Gavin Bierman (Microsoft Research, Cambridge)

TypeScript is an extension of JavaScript intended to enable easier development of large-scale JavaScript applications. While every JavaScript program is a legal TypeScript program, TypeScript offers a module system and a rich gradual type system. This type system aims to be useful but, somewhat controversially, not statically sound. In this talk I will give a rigorous description of TypeScript by defining its type system on a core set of constructs of the language. This enables us to both distinguish precisely the sound and unsound aspects of the type system and compare with existing systems.


Programming Language Semantics as Natural Science:
The Peculiar, Evolving, and Barely Consummated Relationship Between Semantics and Scripting Languages

Shriram Krishnamurthi (Brown U)

Most programming languages should be thought of natural objects, and
the art of semantics should revolve around what it takes to describe
them under that assumption. Furthermore, we should extend the same
treatment beyond languages to libraries, frameworks, and the other
linguistic elements that constitute modern programs. I will discuss
some of my group’s prior successes in this direction, and also outline
future challenges.


Ur/Web: Taking Syntax Seriously
Adam Chlipala (MIT)

Ur/Web is a new-ish statically typed, purely functional programming language for modern Web applications.  It has a few commercial and otherwise respectably real-world users.  The foundation of the language is in dependent type theory, which has rarely poked its head outside academia.

A variety of principled Web application languages by now have implementations that, to various extents, understand the key pieces of Web applications, rather than just treating them as normal strings.  Ur/Web is unique in teaching the compiler about these application pieces by encoding the syntax of languages like HTML and SQL using typed combinators.  That is, rather than hardcoding a language implementation that understands such embedded languages, we instead implement a language with a very expressive type system, such that the static checking we want follows from definition of key embedded languages as libraries.

There are some nice consequences for developers that follow from first-class encoding of embedded languages using a simple but expressive type system.  First, we can use the type system to understand metaprograms that generate custom functionality, as in the scaffolding made popular by Ruby on Rails.  Second, we can bring classic programming language encapsulation techniques to the Web, to build strongly isolated components that contain Web-specific private state, where other frameworks only allow such state to be public.


From AmbientTalk to CloudTalk
Wolfgang De Meuter and Tom Van Cutsem (Software Languages Lab, VUB, Brussels)

AmbientTalk is a distributed programming language whose development started back in 2004. Its design goal was to ease the development of peer-to-peer collaborative applications on mobile phones. Back then, “apps” were non-existent and no one really knew how to design such applications. Today, the majority of apps do not collaborate peer-to-peer but rather via the cloud. We recount some of the history of AmbientTalk, and then describe how our experience with the language is influencing our current research projects, which are oriented towards collaborative cloud applications. We focus on two research themes: one is on how to gracefully support disconnected operation, which requires client-side replicas of shared server state. The second theme is how to scale from collaborative peer-to-peer apps serving perhaps 10 clients to collaborative cloud apps that may serve 10^6 clients.