Scala

Keynote

Traditionally, programming languages have been islands, each disconnected from the rest. Running multiple languages on a single VM (e.g. the JVM) allows languages to communicate a little more easily, but at the price of performance: no matter how clever the VM, some languages run slowly. Even when all languages on a VM run acceptably fast, the mechanisms for communication are usually crude, normally due to performance concerns.

In this talk I will show how languages can be composed in a way that reflects the needs of programmers, and that human-orientated design decisions can be made to run sufficiently fast. Using the Eco editor, users can write source files that contain fragments of multiple languages. Multi-language programs are then run on composed meta-tracing interpreters that JIT compile across language implementations – despite not having a common VM. I will show that the performance of the resulting systems is more than good enough to be usable, and that it opens up new possibilities for language design and use.

Joint work with Edd Barrett, Carl Friedrich Bolz, Lukas Diekmann, Sarah Mount, and Jasper Schulz. More at http://soft-dev.org/

Laurence Tratt

King's College London

United Kingdom

I am a programmer and Reader in Software Development in the Department of Informatics at King’s College London where I lead the Software Development Team. I am an EPSRC Fellow. I co-founded Elbatrop.

dotty is a new, experimental Scala compiler based on DOT, the calculus of Dependent Object Types. Higher-kinded types are a natural extension of first-order lambda calculus, and have been a core construct of Haskell and Scala. As long as such types are just partial applications of generic classes, they can be given a meaning in DOT relatively straightforwardly. But general lambdas on the type level require extensions of the DOT calculus to be expressible. This paper is an experience report where we describe and discuss four implementation strategies that we have tried out in the last three years. Each strategy was fully implemented in the dotty compiler. We discuss the usability and expressive power of each scheme, and give some indications about the amount of implementation difficulties encountered.

Martin Odersky

EPFL, Switzerland

Switzerland

Guillaume Martres

EPFL, Switzerland

Switzerland

Dmitry Petrashko

EPFL, Switzerland

Hundreds of programming languages compile to JavaScript. Yet, most of them fail, at one level or another, to provide satisfactory interoperability with JavaScript APIs. This is limiting, as interoperability is at least required to manipulate web pages through the DOM API, but also to use the eco-system of existing JavaScript libraries. This paper presents the interoperability features of Scala.js, which solves the shortcomings of previous approaches. Scala.js offers a separate hierarchy of JavaScript types, whose operations have semantics borrowed from ECMAScript 2015. The interoperability features are complete with respect to ECMAScript 2015, save for two exceptions which are still being worked on. This allows Scala.js programs to perform any operation that an ECMAScript program could do, thereby guaranteeing that they can talk to any JavaScript library.

Sébastien Doeraene

EPFL, Switzerland

Switzerland

Tobias Schlatter

EPFL, Switzerland

Nicolas Stucki

EPFL, Switzerland

Switzerland

Algebraic data types and pattern matching are key features of functional programming languages. Exhaustivity checking of pattern matching is a safety belt that defends against unmatched exceptions at runtime and boosts type safety. However, the presence of language features like inheritance, typecase, traits, GADTs, path-dependent types and union types makes the checking difficult and the algorithm complex.

In this paper we propose a generic algorithm that decouples the checking algorithm from specific type theories. The decoupling makes the algorithm simple and enables easy customization for specific type systems.

Fengyun Liu

EPFL, Switzerland

Switzerland

I’m a PhD student at EPFL. My interested areas are type systems, effect systems, programming languages, and various logics.

Type-directed API search, using queries composed of both keywords and type signatures to retrieve definitions from APIs, are popular in the functional programming community. This search technique allows programmers to easily navigate complex and large APIs in order to find the definitions they are interested in. While there exist some effective approaches to address type-directed API search for functional languages, we observed that none of these have been successfully adapted for use with statically-typed, object-oriented languages. The challenge here is incorporating large and unified inheritance hierarchies and the resulting prevalence of subtyping into an API retrieval model. We describe a new approach to API retrieval and provide an implementation thereof for the Scala language. Our evaluation with queries mined from Q&A websites shows that the model retrieves definitions from the Scala standard library with 94% of the relevant results in the top 10.

Lukas Wegmann

1plusX, Switzerland

Switzerland

Farhad Mehta

University of Applied Sciences Rapperswil, Switzerland

Peter Sommerlad

University of Applied Sciences Rapperswil, Switzerland

Mirko Stocker

University of Applied Sciences Rapperswil, Switzerland

Switzerland

This paper describes RandIR, a tool for differential testing of compilers using random instances of a given intermediate representation (IR). RandIR assumes no fixed target language but instead supports extensible IR-definitions through an internal IR-independent representation of operations. This makes it particularly well suited to test embedded compilers for multi-stage programming, which is our main use case. The ideas underlying our work, however, are more generally applicable.

RandIR is able to automatically simplify failing instances of a test, a technique commonly referred to as shrinking. This enables testing with large random IR samples, thus increasing the odds of detecting a buggy behavior, while still being able to simplify failing instances to human-readable code.

Georg Ofenbeck

ETH Zurich, Switzerland

Tiark Rompf

Purdue University, USA

United States

Markus Püschel

ETH Zurich

Switzerland

Metaprogramming techniques to generate code at runtime in a general-purpose meta-language have seen a surge of interest in recent years, driven by the widening performance gap between high-level languages and emerging hardware platforms. In the context of Scala, the LMS (Lightweight Modular Staging) framework has contributed to "abstraction without regret''–high-level programming without performance penalty–in a number of challenging domains, through runtime code generation and embedded compiler pipelines based on stacks of DSLs.

Based on this experience, this paper crystallizes some of the design decisions of LMS and discusses potential alternatives, which maintain the underlying spirit but differ in implementation choices: specifically, strategies for realizing more flexible front-end embeddings using type classes instead of higher-kinded types, and strategies for type-safe metaprogramming with untyped intermediate representations.

Tiark Rompf

Purdue University, USA

United States

Tiark Rompf is an assistant professor at Purdue University. His work focuses on runtime code generation, advanced compiler technology, and associated language support. From 2008 to 2014 he was a member of Martin Odersky’s Scala team at EPFL where he developed the LMS compiler framework and made various contributions to the Scala language and toolchain (delimited continuations, efficient immutable data structures, compiler speedups, type system work).

Cloud computing offers an attractive and cost-efficient computing platform and hence it has been widely adopted by the industry and the government. At the same time, cloud computing poses a serious security challenge because sensitive data must often be outsourced to third party entities that can access the data and perform computations on them.
Partial homomorphic encryption is promising for secure computation, since it allows programs to be executed over encrypted data. Despite advances in cryptographic techniques have improved the expressivity of such programs, integration with mainstream languages has seen little progress.
To this end, we present SecureScala, a domain-specific language in Scala that allows expressing secure programs without requiring any cryptographic knowledge. SecureScala is based on a novel combination of free monads and free applicative functors and supports parallel execution and static analyzability. We evaluate our approach through several case studies, demonstrate its expressivity, and show that it incurs in limited performance overhead.

Markus Hauck

codecentric AG

Savvas Savvides

Purdue University

Patrick Eugster

Purdue University

United States

Mira Mezini

TU Darmstadt

Germany

Guido Salvaneschi

TU Darmstadt, Germany

In an information system development process, a lot of time is spent on initial setup and development of prototypes. During that time, a lot of resources are spent, and often thrown away as the process progresses in future iterations. The main focus of this talk is to define and implement a domain specific language that would allow fast development of information system prototypes. Generated prototype source code contains MVC skeleton with predefined methods for creating, reading, updating and deleting objects from the database. These objects are related to the corresponding relational tables using Slick database query and access library. Operations on objects are available through REST services hosted at a JBoss Netty web server with Play framework. A skeleton system represents a basis for the development of an information system in a manner that makes adding new functionalities easy. Once the system is generated, further implementation is done using Scala. Scala is an excellent candidate both for host and target programming language. In this version we use external DSL but in future versions we plan to switch to embedded DSL that is more convenient to use with Scala.

Zeljko Bajic

Serbia and Montenegro

Milan Jovic

Department of Mathematics and Informatics, Faculty of Sciences, University of Novi Sad

The cake pattern was designed to support modular development combining mixins with ML modules, but it is criticized because mixins are not sufficiently isolated from each other’s implementation. Indeed, as discussed by Gabriel, historically mixins were not designed to enforce isolation, but to support separating intrinsically orthogonal concepts in cooperative development scenarios.

We start investigating the issue and clarify which scenarios the cake pattern does succesfully apply to. We compare the cake pattern with an encoding of (recursive) hierarchical modules based on object composition instead of inheritance, that support fully separate modular development at the cost of more boilerplate.

We also suggest one could support separate modular development without additional boilerplate by combining the cake pattern with private implementation inheritance.

Paolo G. Giarrusso

University of Tübingen, Germany

Italy

Jonathan Immanuel Brachthäuser

University of Tübingen, Germany

In this paper, we report on our experience in teaching a course on concepts of programming languages at TU Delft based on Krishnamurthi’s PAPL book with the definitional interpreter approach using Scala as meta-language and using the WebLab learning management system. In particular, we discuss our experience with encoding of definitional interpreters in Scala using case classes, pattern matching, and recursive functions; offering this material in the web-based learning management system WebLab; automated grading and feedback of interpreter submissions using unit tests; testing tests to force students to formulate tests, instead of just implementing interpreters; generation of tests based on a reference implementation to reduce the effort of producing unit tests; and the construction of a product line of interpreters in order to maximize reuse and consistency between reference implementations.

Tim van der Lippe

Delft University of Technology, Netherlands

Netherlands

Thomas Smith

Delft University of Technology, Netherlands

Daniel A. A. Pelsmaeker

Delft University of Technology, Netherlands

Netherlands

Eelco Visser

Delft University of Technology, Netherlands

Netherlands

Keynote

“Do well-typed programs go wrong?” "Of course they do, dear, even the finest Scala programs written using the best of type systems.” “But then, why bother?” “Because it is the way of the world child.” The vast majority of programs written today are written in languages with a single, unconstrained, type; in other words they ignore four decade of research in programming languages. But all is not lost. An idea –referred to, for the lack of better name, as gradual typing– has gained hold in both academe and industry. At heart, gradual typing is about incrementally decorating untyped programs with type annotations and obtaining (partial) correctness. Not surprisingly soundness has a very different meaning in academic efforts and industrial ones. This talk will attempt to explain what it means for a variable to have a type and argue that soundness must be revisited in this new age. Examples from our experience implementing and evaluating gradual type systems for languages such as JavaScript, Thorn and Racket will illustrate the talk. Some hopeful conclusions will be drawn.

Jan Vitek

Northeastern University

Switzerland

Jan Vitek is a Professor of Computer Science at Northeastern University. Dr. Vitek was born in Czechoslovakia and educated in Switzerland. Over the years, he worked on topics related to programming languages, their design, use, and implementation. With Noble and Potter, he proposed the notion of flexible alias control which became know as Ownership Types. He led the Ovm project which produced the first real-time Java virtual machine to be flight tested on a ScanEagle drone (he claims no one was harmed). Outcomes of this project include the Schism real-time garbage collector and the FijiVM – a production VM for embedded systems. More recently, he worked on dynamic languages, trying to make sense of JavaScript and to design a new language called, Thorn. Nowadays, he spends his time with statisticians and data scientists. Jan believes that his 2012 election as Chair of SIGPLAN was an accident; since has been busy trying to rock the boat to ensure this does not happen again. In his spare time, Jan enjoys organizing conferences and sitting on PCs (over 25 in the last decade). He founded the MOS (mobile objects), IWACO (alias control), STOP (gradual typing), and TRANSACT (transactional memory) workshop series. He was the first program chair of VEE and chaired ESOP, ECOOP, Coordination and TOOLS. He was the general chair of PLDI (in Beijing!), ISMM and LCTES. He may still be sitting on the steering committees of ECOOP, JTRES, ICFP, OOPLSA, POPL, PLDI, LCTES, ESOP.

Aggregate programming is a novel paradigm that addresses, at the core, many issues commonly found in the development of large-scale, situated, self-adaptive systems. It is a particular macro-programming approach where a developer expresses the behaviour of the system at the aggregate-level, by targeting the distributed computational machine which is given by the entire set of (possibly mobile and heterogeneous) networked devices pervading the environment. It is the model that takes care of turning a system-level behaviour specification into the concrete, device-centric programs executed locally by each component.

Aggregate computing is formally grounded in the field calculus, a minimal functional language that works with computational fields, i.e., distributed data structures mapping devices (digital representatives of space-time portions) to computational objects. Fields are a useful unifying abstraction for drawing a connection between the physical and the computational world, and between the local and global programming viewpoints. This approach is compositional, allowing to define layers of building blocks of increasing abstraction, and is also amenable to formal analyses.

In this talk, I will present scafi (SCAla with computational FIels), an aggregate computing framework for the Scala programming language which provides (i) an internal DSL for expressing aggregate computations as well as (ii) a library support for the configuration and execution of aggregate systems. There is no need to learn ad-hoc external DSLs anymore: with scafi, Scala programmers can instantaneously start playing with this new, intriguing development approach!

Roberto Casadei

University of Bologna, Italy

Italy

DynaML is an open source library written in the Scala programming language, targeted towards machine learning researchers and practitioners.

The aim is to build a robust set of abstract classes and interfaces, which can be extended easily to implement advanced models for small and large scale applications.

DynaML has a highly modular package structure and leverages many features of the Scala programming language such as generic types, tail recursion, etc.

Currently implementations of models such as least squares support vector machines, feed forward neural networks, gaussian processes are available along with optimization solvers such as conjugate gradient, quasi-newton (BFGS), back-propagation etc.

Furthermore, DynaML has a lightweight data pipes library which enables the creation and composition of reproducible data processing workflows.

Mandar Chandorkar

Centrum Wiskunde & Informatica

Netherlands

Scala-gopher is a library-level Scala implementation of communication sequence process constructs: channels, selectors (similar to analogical constructs in Limbo or Go) transputers (similar to Occam proc) and a set of high-level operations on top of akka and SIP-22 async. The framework integrates CSP-style programming into standard Scala concurrency environment via idiomatic API. This allows usage of communication patterns, well known in Go world, but not easy expressable in mainstream scala concurrency frameworks, along with algebraic approach for composing computation builders. Besides, we want to discuss current implementation issues and future directions in the context of evolving of compiler and libraries ecosystem.

Ruslan Shevchenko

vertamedia

Concurrent programming is infamous for its difficulty. An important source of difficulty is non-determinism, stemming from unpredictable interleavings of concurrent activities. Futures and promises are widely-used abstractions that help designing deterministic concurrent programs, although this property cannot be guaranteed statically in mainstream programming languages. Deterministic-by-construction concurrent programming models avoid this issue, but they typically restrict expressiveness in important ways.

This paper introduces a concurrent programming model, Reactive Async, which decouples concurrent computations using so-called cells, shared locations which generalize futures as well as recent deterministic abstractions such as LVars. Compared to previously
proposed programming models Reactive Async provides (a) a fallback mechanism for the case where no computation ever computes the value of a given cell, and (b) explicit and optimized handling of cyclic dependencies. We present a complete implementation of the Reactive Async programming model as a library in Scala. Finally, the paper reports on a case study applying Reactive Async to static analyses of JVM bytecode based on the Opal framework.

Philipp Haller

KTH Royal Institute of Technology

Sweden

Simon Geries

KTH Royal Institute of Technology, Sweden

Michael Eichberg

TU Darmstadt, Germany

Guido Salvaneschi

TU Darmstadt, Germany

We present qualified types for Scala, a form of refinement types adapted to the Scala language. Qualified types allow users to refine base types and classes using predicate expressions. We implemented a type checker for qualified types that is embedded in Scala’s next-generation compiler Dotty and delegates constraint checking to an SMT solver. Our system supports many of Scala’s functional as well as its object-oriented constructs. To propagate user-provided qualifier ascriptions we utilize both Scala’s own type system and an incomplete, but effective qualifier inference algorithm. Our evaluation shows that for a series of examples exerting various of Scala’s language features, the additional compile-time overhead is manageable. By combining these features we show that one can verify essential safety properties such as static bounds-checks while retaining several of Scala’s advanced features.

Georg Stefan Schmid

EPFL, Switzerland

Viktor Kunčak

EPFL, Switzerland

We present a lightweight library for testing concurrent Scala programs by systematically exploring multiple interleavings between user-specified operations on shared objects. Our library is targeted at beginners of concurrent programming in Scala, runs on a standard JVM, and supports conventional synchronization primitives such as wait, notify, and synchronized. The key component of the library is the trait SchedulableMonitor that accepts a thread schedule, and interleaves as per the schedule all user-specified operations invoked through multiple threads on objects implementing the trait. Using our library, we developed a unit test engine that tests concurrent operations on shared objects on thousands of schedules obtained by bounding the number of context-switches. If a unit test fails on a schedule, the test engine offers as feedback the interleaved traces of execution that resulted in the failure. We used our test engine to automatically test and evaluate two assignments: (a) lock-based producer/consumer problem, and (b) lock-free sorted list implementation, offered to a class of 150 under-graduate students of EPFL. Our evaluations show that the system is effective in detecting bugs in students’ solutions.

Mikaël Mayer

EPFL, Switzerland

Ravichandhran Madhavan

EPFL

Switzerland

We present Scala-AM, a framework for implementing static analyses as systematically abstracted abstract machines. Analyses implemented on top of Scala-AM separate operational semantics from machine abstraction concerns. This modularity facilitates varying the analyzed language and the applied abstraction method in an analysis. We describe the design of our framework and demonstrate its use in a static analysis for the DOT calculus. We conclude with a tour of the features of Scala through which Scala-AM achieves its modularity.

Quentin Stiévenart

Vrije Universiteit Brussel, Belgium

Jens Nicolay

Vrije Universiteit Brussel, Belgium

Belgium

Wolfgang De Meuter

Vrije Universiteit Brussel, Belgium

Belgium

Coen De Roover

Vrije Universiteit Brussel, Belgium

Belgium

Bonsai is a tool that symbolically checks for soundness errors in type systems. It constructs a symbolic space of syntactically-correct programs and evaluates them on the actual typechecker and interpreter, looking for a program that passes the former but fails in the latter. Being a bounded model checker, Bonsai does not prove correctness of a type system, but it finds counterexamples twice as large as those found by experts. We demonstrate how to use Bonsai to find the recently-discovered Scala soundness issue SI-9633 (Amin & Tate), which is related to the interaction between null and path-dependent types.

Kartik Chandra

Henry M. Gunn High School

Rastislav Bodik

University of Washington, USA

Slovakia

It is difficult to verify that the popular implementations of CSS layout match the specification, due to the very different languages being used. We hope to bridge this gap by formalising the specification using attribute grammars, which are formulae for specifying tree computations. Kiama is a language processing library that uses Scala’s pattern matching syntax as a baseline for defining attribute formulae. This format is useful for defining a formula for many production rules in one place. Further, Kiama 2.0 introduced the ability to interrogate the structure of a tree using extractor patterns, which allows us to write tree matching patterns that match not only downwards on the tree, but also upwards or sideways. We have also been using extractor patterns to grant easy access to commonly used attributes, and to express the attributes in a language that closely resembles the CSS specification.

Scott Buckley

Macquarie University, Australia

Australia

Tools for creating parsers are a key part of a mature language eco-system. Scala has traditionally relied on combinator libraries for defining parsers but being libraries they come with fundamental implementation limitations. An alternative is to use a Java-based parser generator such as ANTLR or Rats! but these tools are quite verbose and not ideal to use with Scala code. We describe our experiences with Scala-focused parser generation that is embodied in our sbt-rats plugin for the Scala Build Tool. At its simplest, sbt-rats provides a bridge to the Rats! parser generator for Java. On top of this bridge, we have a simple grammar definition notation that incorporates annotations for tree construction and pretty-printing. As well as generating a Rats! grammar, sbt-rats can optionally generate case class definitions for the tree structure and a pretty-printer defined using our Kiama language processing library. We explain the sbt-rats grammar notation and describe our positive experiences using it to define grammars for LLVM assembly notation and the SMTLIB input/output language for SMT solvers.

Anthony Sloane

Macquarie University, Australia

Australia

Franck Cassez

Macquarie University, Australia

Scott Buckley

Macquarie University, Australia

Australia