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.
|28 Jul||29 Jul||30 Jul||31 Jul||1 Aug|
|UPMARC Summer School||ECOOP Summer School|
|10:00 – 12:00|
|13:30 – 15:00|
|15:30 – 17:00|
|17:15 – 18:45|
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.
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
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.
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
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
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
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
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
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
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
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
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.
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.
|There are three Erik Meijers on wikipedia; a handsome ex-soccer player, a socialist politician, and a hacker. The latter is me.|
|Julien Verlaguet is a uber-hacker at Facebook.|
|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 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 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 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 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.|
|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 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 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 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 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 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 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 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|