SPLASH'16 conference in Amsterdam

Last week I attended the SPLASH’16 conference in Amsterdam. SPLASH is a general conference on programming languages and anything only slightly related to that, such as language workbenches, meta-programming, aspect-oriented programming, type systems and compilers. The name SPLASH is a rather forced acronym for Systems, Programming, Languages and Applications: Software for Humanity, which they chose since their previous acronym OOPSLA (Object-Oriented Programming, Systems, Languages, and Applications) didn’t cover the variety of subjects any more. Personally, I would have called it the Backus conference, after John Backus who invented a now widely used notation for formal language syntax and designed the Fortran programming language.

It was my first conference, and I attended it partly because of an accepted paper we wrote about teaching programming language concepts using Scala, and partly because of the Programming Languages Mentoring Workshop (PLMW) that was given there.

The conference started on the last Sunday of October, and the first two days were all about co-hosted workshops, conferences and symposiums, such as the Scala and Software Language Engineering (SLE). We could freely attend any talk that piqued our interests, and so I did. Here are some of the more interesting talks that day:

Timothée Haudebourg presented a solution for deep priority conflicts in SDF3, a syntax definition formalism. In SDF3 you can express that, for example, a unary not cannot occur on the left-hand side of a binary or. This means that not a or b must parse to not (a or b), as (not a) or b is disallowed. The problem is that such a unary not can occur arbitrarily deep in the parse tree, and this is not caught by the parser and causes ambiguities. This means that a or not b or c, which should parse to a or (not (b or c)) also parses to (a or (not b)) or c, so the expression is ambiguous. Their solution is to maintain a context in which a production can occur. Find more details, and the presentation here.

Right after that Elizabeth Scott presented a technique for fixing lexical ambiguities without having to deal with them in a generalized parser, like SDF3 does. For example the string a+++++b in C-like languages is lexically ambiguous, as it can mean both a++ + ++b and (a++)++ + b. The middle token can either be the binary operator + or the unary operator ++. To fix this, they propose to amend each token with the offset and length of where the token was found, let the lexer return all possible tokenizations of the string at the current position, and let the parser recombine these explored parsings when the token offsets line up. Details and slides here.

Dotty, the new experimental Scala compiler based on the minimal calculus DOT, will support higher-kinded types. Martin Odersky explained how he and his team got through four iterations before they found an approach that provided the features they wanted: full higher-kinded types, type lambdas and full type inference. Find the presentation and the paper pre-print here.

The day ended with the presentation of our own paper. Thomas Smith showed how we teach concepts of programming languages at the TU Delft, and how we use Scala to do this in a scalable fashion. We generate test suites that automatically assess the student’s implementations, and even their test suites. The details and presentation are here, and the paper is here.

One of the highlights on Monday was a keynote from Simon Peyton Jones about how to learn our children computing. He showed that you don’t need computers, or even technology, to teach computing to children. For example, in this video children with numbers follow edges in a graph and simple rules to come out sorted at the other end. Even if they mix up randomly - to foil the teacher’s plan of course - they still end up sorted. Such non-technical ways of applying computing teach a lot, and have been used in shaping the National Curriculum in England. Read more and look at the slides here.

Tuesday for me was completely taken by the Programming Languages Mentoring Workshop (PLMW), which was a workshop where both veterans and young professionals talked about their careers, how they ended up where they are now, and what we can do to shape our careers, whether we want to do a PhD, go for a career in academia or industry. It was really interesting, and I can recommend anyone to follow such a mentoring workshop if it is available in your area of studies.

At the Onward! Essays talks on Wednesday, one of the more interesting essays was The Left Hand of Equals primarily written by James Noble and narrated by Andrew Black. I’ll just quote the abstract, and you can find the essay here:

This essay takes a reflexive journey through fifty years of identity and equality in object-oriented languages, and ends somewhere we did not expect: a ‘left-handed’ equality relying on trust and grace.

There was also an interesting talk by Santiago Perez De Rosso about some of the design choices that were made in Git, and the problems they cause. They aim to solve these issues with Gitless, a version control system built on top of Git. You can find the details and a paper pre-print here.

Back on the topic of Scala, Thursday started with a keynote from Martin Odersky about the DOT calculus itself as a foundation for the next version of Scala, and the Dotty compiler built on top of it. More details here. Nada Amin followed up with an interesting talk about proving type soundness for the full DOT calculus (details), which Ross Tate countered on Friday with a talk about why Scala’s and Java’s type systems are still unsound, of which the publication and pre-print can be found here.

Another interesting Onward! essay was in the control room of the banquet from Dick Gabriel, where he uses AI to generate haiku. Or as Gabriel himself describes it, about “creativity, AI, programming, the Turing Test, and mystery.” You can find the essay here.

the maiden condominium

opens its award-winning gametocyte

in the control room of the banquet

— Richard P. Gabriel’s AI

Finally, the conference ended on Friday with a keynote from Guy Steele, who has been quoted numerous times for once saying:

“If it’s worth telling yourself (or another programmer), it’s worth telling the compiler.”

— Guy Steele

In his talk he explored how to tell a compiler what we think we know, and his attempts at encoding this information in his now discontinued experimental programming language Fortress. More details here.

All in all, the conference was a great way to get to know some of the veterans in the field, their work, and what’s keeping everyone else busy. If I have the chance, I would definitely attend more conferences in the future.