Design and Implementation of Modern Programming Languages

Design and Implementation of Modern Programming Languages

Modern programming languages like Java offer the programmer many advanced concepts: automatic memory management, dynamic class loading and linking, powerful type systems, and efficient just-in-time compilation. Typically, such features are partly implemented by the language's compiler (checking whether a program is well-typed), partly by the runtime environment (collecting garbage, i.e., objects no longer reachable).

This course is complemented by a hands-on training: Implementation of Programming Languages. Attending the hands-on training is not mandatory, although there may exist synergies between topics offered here and in the hands-on training.

Course Information

TUCaN-ID

20-00-0182-se

Course Type

S2 / 3 CPs

Advisors

Guido Salvaneschi, Andreas Sewe, Jan Sinschek, Ralf Mitschke

Sign-up

Please sign up by mail:

Kick-off

Friday, 20 April 2012, 16:15 - 17:15 in S2|02-A313

Blockseminar

Friday, 20 July 2012, 16:15 - 17:15 in S2|02-A313

Language

Both English and German are accepted for talks and term papers.

Topics

The following is the preliminary list of topics.

Functional-reactive Programming for the Web

Functional reactive programming (FRP) is about representing time-changing values and event streams as first class entities. The first approaches, like the Yampa and the FRAN libraries were implemented in Haskell. Several recent proposals adopt FRP in more modern flavors in the setting of Web applications. Simple client-side computations and event-triggered actions (like server messages), typical of Web applications, seem to be an optimal setting for FRP. For example, Reactive is a Scala library used in the Lift Web

framework. Flapjax is a Javascript extension/library for reactive applications. Ur/Web is a framework for secure Web programming which also employs FRP.

The students are supposed to give an overview of the existing proposals. They are required to compare the approaches and evaluate the effectiveness of FRP in the Web applications setting.

Students: 1-2

Advisor: Guido Salvaneschi

Efficient Reactive Data Structures

Recent programming models support dynamic and incremental update of queries and views. These features are becoming widespread and are now supported in many mainstream frameworks. For example, .Net’s Reactive Extensions (Rx) is a library-based approach to modeling functional reactive behavior. It represents data streams by sequences of observables, correlated by LINQ operators. LiveLINQ is a LINQ extension which keeps data structures automatically updated. Glazed Lists is a Java library to support similar functionalities.

The students are supposed to give an overview of these proposals. They are also required to analyze and compare the expressive power and the capabilities of each approach.

Students: 1-2

Advisor: Guido Salvaneschi

Event Driven Programming

Software applications must be reactive to respond to various kind of events like user actions or network messages. Reactivity is traditionally implemented with the Observer pattern. However, some languages also provide specific abstractions for reactive programming. For example C# supports native events declarations. Research languages like Ptolemy, EventJava or EScala support more advanced event systems, including event composition, implicit events and polymorphic events.

The students are supposed to give an overview of the state of the art. They are also required to analyze and compare the expressive power and the specific features of each approach.

Students: 1-2

Advisor: Guido Salvaneschi

Dataflow Programming

Dataflow programming is a programming paradigm which directly supports the manipulation of streams of changing data. The applications of this paradigm include high performance computing, like the StreamIt language. Aurora and Borealis are similar frameworks to support query evaluations over streaming data. Yahoo! Pipes are a graphical domain specific language to filter and aggregate Web content. Systems such as OpenLazo and JavaFX also apply concepts from dataflow programming to the Web.

The students are supposed to give an overview of these proposals. They are also required to analyze and compare the expressive power and the capabilities of each approach.

Students: 1-2

Advisor: Guido Salvaneschi

Complex Event Processing

Complex event processing is about the elaboration of event streams, in particular the recognition of event patterns from time-changing event streams. Queries on event streams usually have high performance requirements. The applications of this paradigm include highly efficient software for trading and financial transactions, processing of data coming from sensors in a pervasive computing environment, and, more recently, elaborations of massive information from the web. Systems supporting this model include TelegraphCQ, SASE and Cayugaq.

The students are supposed to give an overview of these frameworks. They are also required to analyze and compare the capabilities and the efficiency of each approach.

Students: 1-2

Advisor: Guido Salvaneschi

Language abstractions for WSN

WSN are small devices with limited computational power carrying sensors and communication facilities. Due to their reduced size and energy consumption, they can be easily deployed in the environment. Programming these devices requires special care to preserve the limited battery availability. The current practice is centered around very low level frameworks right on top of the operating system. Current research is exploring higher level abstractions. For example TinyDB exposes the sensor network as a database which can be inspected by SQL-like queries. Regiment is a functional language in which list comprehensions support the reification of spatial locality.

The students are supposed to give an overview of these frameworks. They are also required to analyze and compare the expressive power, the capabilities and the efficiency of each approach.

Students: 1-2

Advisor: Guido Salvaneschi

Concurrent programming with Join

Concurrent programming became more interesting since most commercial processors have multiple cores. However, writing concurrent software remains hard. An important issue is to protect regions of the code known as critical sections. Operating systems offer low level constructions like semaphores. Modern languages incorporate synchronization features at the language level. In the theoretical setting of abstract calculi, the Join calculus offers an elegant way for thread to synchronize and communicate. Several languages implement the join operator. Among the others: Jocaml, Polyphonic C# (C omega), Funnel, Join Java and JErlang.

The students should highlight the differences between the existing implementations. They should analyze the limitations of each technique and investigate the advantages over traditional thread-based approaches.

Students: 1-2

Advisors: Jurgen van Ham,Guido Salvaneschi

Talk

With this seminar we want to introduce you to core techniques of scientific work; each participant is thus required to give a talk about the topic chosen. This talk will be given during a Blockseminar at the end of the term.

All talks have to be 15 minutes long if given by a single person, and 25 minutes or 35 minutes when given by a group of two or three, respectively. (Each member of the group should have an equal share in it.) Please practice your talk several times; in particular, make sure that you do not miss the time limit by much, i.e., by at most 10%; this mimics the strict time limits of real-world conferences and workshops. Consequently, if a talk is significantly shorter or longer, then this fact will have a (negative) impact on the presenters' grade.

Term Paper

In addition to giving scientific talks, we want to introduce you to the process of writing and publishing research papers. In other words: you will have to write a term paper. The following notes may guide you in this process:

The initial references provided with the topic chosen by you are only a first step; in your term paper, try not to summarize everything that's written therein or in the references' references. Instead, try to tell an engaging, coherent story about one aspect of the topic. (It helps to image oneself as a novice to the topic, who attends the talks or reads the term papers.) Also, search for further references on your own and point out connections between the various papers you researched; we expect at least 2-3 related references found per person. Please present technologies, e.g., programming languages, with your own words and your own examples. If you merely copy the work of others, this means but one thing: no contribution; you will fail the seminar. This rule does not prevent you from quoting other researchers, however. It does require you to faithfully attribute quotations or other kinds of references, though.

Overall, we expect about 6 pages of term paper if written by a single person. For groups of two or three persons we expected 8 or 10 pages, respectively. (This page limit take the space needed for the title, the list of references, and any figures already into account.) If many or large figures or tables are included, we expect a slightly longer term paper to compensate for this. Please consult your advisor about this. To make the term papers' length comparable, all participants are required to use the ACM SIGPLAN Proceedings Template, preferably in its LaTeX incarnation (default font size, 9pt).

Reviews

A review is an assessment of a scientific paper, which is submitted for publication at a journal or conference. Scientific peers rate the paper's quality and thus decide, whether the paper is accepted for publication. Furthermore, peer reviewers provide the paper's author with suggestions on how to improve it. During this seminar we want to introduce you to this aspect of scientific practice, too.

Consequently, every participant has to write two reviews of other students' term papers. All reviews should be constructive and name clearly both positive and negative issues with the paper in question. Each such review should contain the following three sections:

  • A short summary of the paper
  • Suggestions for the author, regarding both content and presentation
  • A list of the major positive and negative issues

There is no page limit for the reviews; however, 500 words is a good guideline for a single review.

Grading

The overall grade for the seminar is determined by three factors: the talk given, the paper handed in, and the reviews made. Furthermore, we will consider your participation in the discussion following each talk; it counts towards the grade received for your reviews. Overall, the three factors are weighted 40 : 40 : 20, respectively. In other words, both the talk and term paper are of equal importance.

Please note that it is possible, due to the fact that each participants talk and reviews are graded individually, that different members of a group are assigned different overall grades.