|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
|10:45–11:45||Safe tier splitting using practical effect inference in Koka.
|13:00–14:00||Orchestrating Asynchronous Events on the Web
|14:00–15:00||Opa and AngularJS
|15:30–16:30||Scala.js: write in Scala for the browser
|16:30–17:30||Contracts for eventuation properties
|Day II, November 13th, 2013 (VUB Campus, Room D2.01)|
|09:45–10:45||A practical theory of language-integrated query
|10:45–11:45||A formal introduction to TypeScript
|13:00–14:00||Programming Language Semantics as Natural Science
|14:00–15:00||Ur/Web: Taking Syntax Seriously
|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.
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)
Scala.js: write in Scala for the browser
Sebastien Doeraene (École Polytechnique Fédérale de Lausanne)
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.
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)
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
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.