

Slides for many talks available now! Scroll down!

ECOOP Summer School

The ECOOP summer schools talks are ninety minute tutorial talks scheduled during the ECOOP conference available to all conference registrants. The series is organized by James Noble and Jan Vitek. Previous instances: ESS'13, ESS'12, ESS'11, ESS10, ESS'09.

The 2014 Summer School is sponsored by Oracle.

ECOOP Summer School Schedule

Captain Teach and Pyret: In-Flow Peer-Review of Programming Assignments

Joe Gibbs Politz and Shriram Krishnamurthi



Code review is an integral part of building large-scale systems, and deciding which answer to use from StackOverflow exercises both program comprehension and judgement. Yet students rarely get much practice reading and reviewing code.

Captain Teach is a new learning environment for programming that supports peer review even as the assignment is in progress. Assignments are broken up into reviewable chunks, and after submitting each piece, students are asked to review the work of a few other students before continuing. In contrast to peer grading, which happens after the assignment is done, in-flow peer-review gives students a chance to apply what they learn both from others' solutions and from feedback they receive by others. This also naturally increases motivation to perform code review well.

Captain Teach is language-agnostic, and several universities are already investigating its use next year. Come learn about how you can make peer-review a part of your educational process, including assignment design and grading implications. We intend for this to be an open discussion rather than just a presentation.

If time permits we will briefly show Pyret, a new programming language that happens to have features that make it especially amenable for use in in-flow peer review.

Project URL: http://pyret.org Contact: Shriram Krishnamurthi

Build your own Functional Operating System

Anil Madhavapeddy and Richard Mortier



Mirage proposes a radically different way to build virtual machines for the cloud. Rather than the traditional OS model where functionality is provided in layers, building up from a feature-rich kernel through userspace and language runtimes, Mirage progressively specialises application code, written in OCaml, replacing traditional OS components such as the filesystem, network stack and scheduler, with type-safe libraries. This allows you to code using your usual tools, only making the final push to the cloud once you are happy your code works. Your application becomes a “unikernel”: a sealed, fixed-purpose bootable image that runs directly on the Xen hypervisor without need for a guest OS. As unikernels only link in the libraries explicitly required by the application code, they are very compact: a self-hosting Mirage web server is less than a megabyte in size! We describe the architecture of Mirage, run through some samples, and get you started porting your own homepages onto Mirage. Audience participation is encouraged!

Contact: Anil Madhavapeddy

Towards Language Composition

Laurence Tratt



Slides (PDF)

We want better programming languages, but “better” invariably ends up becoming “bigger”. Since we can't keep making our languages bigger, what alternatives do we have? I propose language composition as a possible solution to this long standing problem. Language composition means merging two languages and allowing them to be used together. At its most fine-grained, this could allow multiple programming languages to be used together within a single source file. However, language composition is not a new idea. It has failed in the past because editing composed programs was intolerably difficult and the resulting programs ran too slow to be usable. Without good solutions to these problems, language composition will remain an unrealised ideal. I will show how the work we are doing is beginning to address both aspects. We have built a prototype editor utilising a novel concept 'language boxes', which allows one to edit composed programs in a natural way. We are tackling the performance problem by composing together interpreters using meta-tracing, allowing us to build composed VMs with custom JITs that naturally optimise across different language's run-times. While we are much nearer the beginning of the journey than the end, our initial research has allowed us to build a simple composition of two very different languages: Python and Prolog.

Project URL: http://soft-dev.org/ Contact: Laurence Tratt

Benchmarking Computer Systems

Tomas Kalibera



Slides (PDF)

Comparing computer systems is an important part of computer science, and particularly in programming language and systems research, where performance is so important. Most scientific papers in this field measure performance, and for many the amount of measured performance improvement determines their acceptance and impact. Also, most papers published even at top conferences have significant flaws in their performance comparison methodology. Today's computer systems are so complicated that their behavior is similar to that of objects of the real word (there are also effects that can be modelled as random, there is also a lot of many different effects impacting performance, we are not aware of what many of them are, etc). Experimenting in the real world is covered by experiment design and statistical inference, now mature fields of statistics. In computer systems performance evaluation we are now at the very beginning. We have specific problems, but for now we can improve our performance comparisons even using elementary knowledge of applied statistics. The talk will offer several thoughts and examples on how to do things better with a bit of good will, exploratory data analysis, and statistical bootstrap.

Contact: Tomas Kalibera

Programming for Social Scientists

Ben Livshits



Slides (PDF)

Experimental psychology is often jokingly referred to as the study of the college sophomore. In this talk, we show how crowd-sourced polls or surveys can be used to quickly and cost-efficiently collect data on a mass scale for a range of social science queries. We will present InterPoll, a LINQ-based programming abstraction and runtime system which allows novice pollsters and survey writers to easily express and correctly execute crowd-sourced polls and surveys. Through a series of examples, we show how developers can easily express common queries in social science, politics, and other areas of human knowledge via LINQ. Then, we demonstrate how InterPoll's runtime correctly executes said queries, automatically re-weighting responses to queries so as to handle potentially biased crowds.

Contact: Ben Livshits

Exercises in Programming Style

Cristina Videira Lopes

Slides (PDF)

Back in the 1940s, a French writer called Raymond Queneau wrote an interesting book with the title Exercises in Style featuring 99 renditions of the exact same short story, each written in a different style. In my book “Exercises in Programming Style” (available in June 2014) I shamelessly do the same for a simple program. From monolithic to object-oriented to continuations to relational to publish/subscribe to monadic to aspect-oriented to map-reduce, and much more, you will get a tour through the richness of human computational thought by means of implementing one simple program in many different ways. This is more than an academic exercise; large-scale systems design feeds on these ways of thinking. I will talk about the dangers of getting trapped in just one or two prescribed styles during your career, and the need to truly understand this wide variety of concepts when architecting software.

Contact: Cristina Videira Lopes

Programming the Network with Frenetic

Nate Foster and Arjun Guha

Slides (PDF)

Modern networks provide a variety of services including routing, load-balancing, traffic monitoring, authentication, and access control. These services are logically distinct, but they must be implemented on top of low-level networking hardware, which offers no support for modular programming. Network programs are thus written in a monolithic style, which complicates programs, makes reasoning difficult, and frequently leads to failures. In recent years, several research groups have applied ideas from programming languages and formal methods to help make network programs safer and easier to write. The catalyst has been the emergence of software defined networking (SDN) and OpenFlow as a simple and open platform for developing network applications. This tutorial will provide an introduction to languages, abstractions, and reasoning tools for networks, focusing both on the low-level OpenFlow protocol and the high-level Frenetic language. Participants will spend most of the tutorial engaged in programming exercises.

Contact: Nate Foster

Linearizing the Heap: Thoughts on Communication, Sharing, and the Pervasive Use of Accelerators

Nick Mitchell



Slides (PDF)

Many high-level languages have, as their main use case, the encoding of software switches. These programs collate data, and the core essence of their program flow has changed little from the days of green screens and COBOL. Requests arrive, are parsed and dispatched to handlers that, in turn, fetch data from other services and then assemble a report by slotting that data into a static template. Wire protocols must be honored, both in the upstream direction from which the requests emanate, and in the downstream direction in which the data resides. Some conversions are thus an inherent part of these software collators, to cope with protocol and data format mismatches. At least from the perspective of the computational resources, we are left with code that streams through data, performing selections and sorting, gathering and scattering, and other flavors of bit manipulations on this data — in short: streaming bit manipulation.

It is a minor bit of computer science tragedy, then, that the kinds of hardware architectures perfectly suited to host this style of computation, such as specialized circuitry in the form of FPGAs, can only dream of executing the important parts of a typical Ruby, Node.js, or Java application. In large part, this incompatibility stems from the large separation between operational and serialized forms. Programs written in these high-level languages store and operate on data as a graph (where each memory allocation can be separately introspected upon), while wire protocols represent data as a linear stream. Even if one desired to accelerate a portion of a preexisting Ruby or Java computation (let alone the entirety), this mismatch of data storage would result in death by Amdahl's law: the sequential shuttling of data from the operational to a streamable form would dominate the gains of partial acceleration. In this lecture, we will motivate research towards this goal of a more pervasive use of accelerators. We will cover potential changes to languages, memory management, and evaluation semantics.

Contact: Nick Mitchell

How to Grow a Language for “Big” Applications

Philipp Haller



In a few years, the requirements of data-intensive distributed applications, such as large-scale web applications, have changed dramatically, requiring response times orders of magnitude shorter for data in the petabytes. At the same time, the software industry is undergoing a fundamental shift toward Software-as-a-Service, where such “reactive applications” are deployed on cloud-based computing platforms with thousands of multicore processors. Reactive programming aims to explore programming languages, tools, and systems that enable the productive construction of reactive applications that are efficient and reliable. In this tutorial I'll present recent efforts in the design and implementation of reactive programming abstractions for Scala. More specifically, I'll show how to leverage implicits and macros in Scala for implementing constructs that are efficient, flexible, and reliable.

Contact: Philipp Haller

Principles of Reactive Programming

Erik Meijer



Slides (PDF)

As computers are moving further apart in space, we can no longer ignore the fundamental effects of programming: exceptions, asynchrony, and dimensionality. In these lectures we will explore the consequences of making these effects explicit in our code and present new programming language constructs and APIs to help developers handle them in their code. In particular we will focus on the language-independent Reactive Extensions (Rx) library that re-implements familiar operators over synchronous collections such as map, filter, fold, ... over asynchronous data streams.

Contact: Erik Meijer

Hack: type-checking at scale.

Julien Verlaguet



Facebook released a new programming language called Hack. Hack is a gradually typed language that interoperates seamlessly with PHP. More importantly, Hack has been designed to scale on a very large codebases. In this talk, I will highlight the particularities of the type-checker's architecture. The Hack checker was designed as a daemon watching the filesystem for changes. Making such an architecture scale to millions of lines of code while preserving instantaneous checks comes with many challenges. We believe that it could bring an interesting perspective for other programming languages to review those challenges and see how we overcame them.

Project URL: http://hacklang.org/ Contact: Julien Verlaguet

Implementing Ruby Using Truffle and Graal

Chris Seaton



Slides (PDF)

Oracle's Truffle framework allows languages to be implemented as specialising AST interpreters written in Java. When run on a JVM with the Graal JIT compiler, these interpreters are compiled with partial evaluation, producing optimized machine code. Truffle and Graal also provide high-level access to JVM mechanisms such as dynamic deoptimization that allow us to implement highly speculative optimisations while still supporting the full range of functionality of dynamic languages. The JRuby project uses Truffle and Graal to implement Ruby. This talk will focus on how to use Truffle to implement a real language as part of a runtime already used in production and demonstrate the techniques that we have found work well. We will address Ruby's awkward parts and show how to implement them with both simplicity and high performance.

Project URL: http://openjdk.java.net/projects/graal/ Contact: Chris Seaton

Dr. Streamlove or: How I Learned to Stop Worrying and Love the Flow

Viktor Klang

Slides (pdf)

Stream-based programming holds the promise of unifying IO with traditional Functional Programming manipulation of collections. In this session we will introduce you to Akka Streams—an asynchronous Stream-based programming library with non-blocking back pressure implemented on top of Akka—an implementation of the Actor Model. We'll demonstrate the Flow API—a lifted representation—as well as a pluggable way of transforming the lifted representation into the execution representation—Flow Materialization. We will also discuss the implications of non-blocking back pressure for fan-in (many producers to single consumer) as well as fan-out (single producer to many consumers) as well as discuss dynamic runtime optimization as well as compile time optimization.

Project URL: typesafe.com Contact: @viktorklang