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.
| Mon | Tue | Wed | Thu | Fri |
|---|---|---|---|---|
| 28 Jul | 29 Jul | 30 Jul | 31 Jul | 1 Aug |
| FTfJP | COP | ECOOP | ||
| JSTools | IWACO | |||
| ICOOOLPS | COOMPL | |||
| PLE | PLAS | |||
| Scala | ||||
| PhD Symp | ||||
| UPMARC Summer School | ECOOP Summer School | |||
ECOOP Summer School Schedule
| Wed | Thur | Fri | |
|---|---|---|---|
| 10:00 – 12:00 | Captain Teach and Pyret: In-Flow Peer-Review of Programming Assignments |
||
| 13:30 – 15:00 | |||
| 15:30 – 17:00 | |||
| 17:15 – 18:45 | Linearizing the Heap: Thoughts on Communication, Sharing, and the Pervasive Use of Accelerators |
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
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
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
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
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
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
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
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
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
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
Speakers and Bios
Erik Meijer
There are three Erik Meijers on
wikipedia; a handsome ex-soccer player, a socialist politician, and a
hacker. The latter is me. |
Julien Verlaguet
 Julien Verlaguet is a uber-hacker
at Facebook. |
Philipp Haller
Philipp Haller
is a software engineer and consultant at Typesafe,
Switzerland. He created Scala's original actors
library, and is one of the lead designers of futures
in Scala as well as Scala Async. Previously, he
worked on parallel domain-specific languages at
Stanford's Pervasive Parallelism Lab and co-authored
the book “Actors in Scala”.
|
Ben Livshits
 Ben Livshits is a research scientist at Microsoft Research
and an affiliate professor at the University of Washington. From
St. Petersburg, Russia, he holds degrees in Mathematics and CS
from Cornell and Stanford. Dr. Livshits' research interests
include application of analysis techniques to finding errors in
programs, and, more generally, privacy, security, and performance
of large programs. |
Anil Madhavapeddy
 Anil Madhavapeddy is
a Senior Research Fellow at the Cambridge Computer Lab. He was on
the team that developed the Xen hypervisor, and served as the
senior architect and product director for XenSource. He is an
active member of the open source community with OpenBSD and a
member of the steering committee for Commercial Uses of Functional
Programming. He founded and directs the $4.5m OCaml Labs group
which is an industrial-academic collaboration to promote
functional programming as a real solution for constructing
mission-critical systems. |
Richard Mortier
 Richard Mortier is Horizon Transitional Fellow in Computer
Science at the University of Nottingham. His research focuses on
user-centred systems with projects in topics ranging from home
networking, to designable visual codes, to human-data
interaction. He founded Vipadia Limited designing and building the
Clackpoint and Karaka real-time communications services. |
Nate Foster
Nate Foster
is an Assistant Professor of Computer Science at Cornell
University. His research focuses on developing language
abstractions and tools for building reliable systems. He is
the recipient of a Sloan Research Fellowship, an NSF CAREER
Award, a Tien '72 Teaching Award, a Yahoo! Academic Career
Enhancement Award, and the Morris and Dorothy Rubinoff
Award. |
Arjun Guha
Arjun Guha
is an Assistant Professor of Computer Science at UMass
Amherst. He enjoys tackling practical problems, while
adhering to the mathematical foundations of programming
languages. His dissertation on JavaScript is used by other
researchers as a foundation for their own work. He developed
a model of SDN in the Coq Proof Assistant, which is the
foundation for a verified SDN controller. |
Nick Mitchell
 Nick Mitchell is a Research Staff Member at IBM's
T.J. Watson Research Center. He primary focus in recent years has
been the study and cataloging of bloat in object-oriented
programs. As part of this work, he has surveyed thousands of
applications, in a variety of languages, and has developed
tooling, analysis techniques, and user interfaces to support this
area of study. |
Joe Gibbs Politz
 Joe Gibbs Politz is a
PhD student in computer science at Brown University. After doing
research on semantics and security, he has come to his senses and
is now working on languages and platforms for better programming
education. Originally from the city of Worcester, he has thusfar
successfully straddled the deep cultural divide between
Massachusetts and Rhode Island. |
Shriram Krishnamurthi
Shriram Krishnamurthi
is a professor of computer science at Brown University. He has
worked on problems in programming languages, software engineering,
verification, security, and networking. Education is by far the
hardest research problem he has tackled. Originally from India,
he has lived in several countries, including the United States and
Texas. |
Cristina Videira Lopes
 Cristina Videira Lopes is
a Professor of Informatics at the University of California,
Irvine. Her research focuses on software engineering for
large-scale data and systems. She was a founding member of the
Xerox PARC team that developed Aspect-Oriented Programming. She is
also a prolific software developer in particular for
OpenSimulator, a virtual world server. She is also a founder of
Encitra, a company specializing in online virtual reality for
early-stage sustainable urban redevelopment projects. She claims
to be the only person in the world who is both an ACM
Distinguished Scientist and Ohloh Kudos Rank 9. |
Laurence Tratt
 Laurence Tratt is a
Lecturer at King's College London where he leads the Software
Development Team. He designed and implemented the Converge
programming language. He has long wondered how we might be able to
improve programming languages, from language design to language
language implementation. |
Tomas Kalibera
Tomas Kalibera is a researcher working for Purdue University
on the R language implementation. His research interests include
virtual machines, garbage collection, and benchmarking based on
statistical methods. |
Chris Seaton
 Chris Seaton is a
PhD student at the University of Manchester, UK, and a member of
the Oracle Labs VM Research Group. He works on constructs to
support irregular parallelism, and dynamic language
implementations.
|
Viktor Klang
 Viktor Klang hails from southern Sweden and has been a passionate Scala hacker since 2007, a Java enterprise systems architect since 2003 and a programmer since 1998. He's a big fan of agile development, scalable software and elegant code. He joined the Akka team in the middle of 2009 as one of the earliest committers. Viktor currently serves as Chief Architect at Typesafe
|