The Second Hessian Workshop on Programming Languages takes place in 2014 in Marburg.

Program for the Workshop on June 28, 2013

(in S202/B002, TU Darmstadt, Dept. of computer science, Hochschultstraße 10)

Session 1 (Chair: Sebastian Erdweg)
10.15Programming Languages for Reactive Applications slides
Guido Salvaneschi, TU Darmstadt
Reactive applications are difficult to implement. Traditional solutions based on event systems and the Observer pattern have a number of inconveniences, but programmers bear them in return for the benefits of OO design. On the other hand, reactive approaches based on automatic updates of dependencies - like functional reactive programming and dataflow languages - provide undoubted advantages but do not fit well with mutable objects.
We present a research roadmap to overcome the limitations of the current approaches and to support reactive applications in the OO setting. We establish the connections with the related fields, including complex event processing and incremental computation. We present our current research results concerning the development and validation of the REScala language.
10.40Finite Difference for First-Class Functions: Incrementalizing λ-Calculus slides
Yufai Cai, University of Marburg
If the result of an expensive computation is invalidated by a small change of the input, the whole computation needs to be run again, even if the small change to the input eventually leads only to a small change in the result. One way to avoid the unnecessary recomputation of unchanged parts of the result is by transforming a program into its finite difference. The finite difference maps changes in the program's input directly to changes in the program's output, without executing the original program. We present the first fully-automatic compile-time transformation of a program into its finite difference that supports first-class functions. The finite difference is determined statically, incurring no runtime overhead in keeping track of changes or in maintaining dataflow dependencies. Many straightforward optimization techniques are applicable to our program transformation and produce significant gain in performance.
11.05Software Engineering & Programming Languages at Goethe University Frankfurt slides
Christoph Reichenbach, Goethe University Frankfurt
This talk gives a quick overview over the three current main strands of research in our new group at Goethe University. The first topic is PQL/Java, a declarative query language modelled on first-order logic and embedded into Java. PQL/Java can concisely express many complex computations and parallelise them effectively on multicore machines. The second topic is Smart Modules, a project that combines implementation alternatives with decision procedures that automate the task of picking the best implementation for a set of requirements. The final topic is the software tools evaluation project STEP, in which we are building a platform and a network for sharing and collaboratively evaluating novel software tools.
11:30Coffee break
Session 2 (Chair: Tillmann Rendel)
12:00The Transparent Developer – Collecting Data for Effective Code Recommendation slides
Sebastian Procksch and Sven Amann, TU Darmstadt
The idea of supporting developers in their IDEs is not new and research is engaged in that area for quite some time now. So far, the focus of our group was to replace several completion engines in Eclipse with smarter versions, the call completion is perhaps the most known example and is nowadays used in standard Eclipse configuration.
We are able to provide those recommender systems by combining a statical analysis of source code with machine learning approaches to learn usage models for several framework APIs. In the future, we plan to further enhance the underlying concepts and algorithms by taking additional sources of information - like expert knowledge or implicit feedback - into account.
An important research question in this area that was not answered so far is, how much more efficient a developer is when getting support like this. We want to answer that question and to be able to do so, we need to get a clear understanding on how developers actually work, first. For that reason we are currently working on a concept to gather data from developers about how they are using their IDE. We are going to discuss this concept in our part of the workshop.
12:25Lightning Talks
Present your idea related to programming language research in ca. 3 minutes.
Sign up at the workshop
13.00Lunch (sardegna da franco)
Session 3 (Chair: Guido Salvaneschi)
14:30Semantics-First Extensibility slides
Yi Dai, University of Marburg
Offering syntactic extensibility via systems other than the core language imposes burdens on both language implementers and language users. The design of most syntactically-extensible languages fall into this trap because they take syntax first and alone into account for extensibility. We propose a semantics-first approach in which syntactic extensibility follows from semantic extensibility. In our approach, only the core language system is of concern, reducing the overhead on both language implementers and language users.
14:55Dynamic Analysis of Metaprograms with Typesmart Constructors slides
Sebastian Erdweg, TU Darmstadt
A key problem in metaprogramming is to guarantee that generated code is well-formed with respect to the syntactic and semantic constraints of the target language. We propose typesmart constructors as a dynamic approach to enforcing the well-formedness of generated code. A typesmart constructor is a function that is used in place of a regular constructor to create values, but it may reject the creation of values if the given data violates some language-specific constraint. We report on our successful application of typesmart constructors for checking syntactic language constraints at program-construction time, and discuss how to use typesmart constructors for checking semantic language constraints such as the well-typedness of generated programs.
15:20Open GADTs and Declaration-site Variance: A Problem Statement slides
Paolo G. Giarrusso, University of Marburg
Generalized algebraic data types (GADTs) allow embedding extensible typed ASTs and transformations on them. Such transformations on typed ASTs are useful for code optimization in deeply embedded DSLs, for instance when using Lightweight Modular Staging (LMS). However, in Scala it is hard to make transformations for typed ASTs type-safe. Therefore, AST transformations in LMS are often not fully typechecked, preventing bugs from being caught early and without extensive testing.
We show that writing type-safe transformations in such embeddings is in fact not just hard, but impossible without using unsafe casts or significantly restricting extensibility: Declaration-site variance opens GADTs representing typed ASTs not only to desirable extensions, but also to extensions that introduce exotic terms. We make the problem concrete on an embedding of λ<: through covariant GADTs. We discuss solution approaches, and sketch a Scala extension to address this problem without either introducing unsafe casts or restricting extensibility.
We believe a complete solution would significantly ease writing transformations by allowing type-checking to verify them, and thus would ease their development.
15:45Coffee break
Session 4 (Chair: Paolo G. Giarrusso)
16:15CODANA – A New Policy Language for Securing Android Applications slides
Sigfried Rasthofer, EC Spride
Smartphones have become ubiquitous. They typically contain users' private and confidential data. This data is increasingly becoming the target of malicious applications, which try to steal such information. Alternatively, malicious applications may cause direct financial harm to a user, for example, by sending premium-rate SMSes. Furthermore, the mobile world still has malware that is similar to those in the desktop world, like privilege escalation attacks or web-based vulnerabilities.
To mitigate those vulnerabilities, we are working on a policy language called CODANA that allows security analysts the definition of data-centric policies, such as usage control or information flow policies. The policies will be enforced by an hybrid code analysis approach directly on the Android bytecode. This talk will highlight current Android security threats, will describe that current policy languages are not able to describe most of those threats and will give a first light-weight draft of CODANA.
16:40A Brief Overview of Common Software Security Architectures … And Why No Human Being Can Maintain This Anymore – Horror, Terror, Suspense slides
Ben Hermann, TU Darmstadt
Widely used programming languages usually come with their own security architectures to provide their users with means to write applications reaching certain security properties and to protect end-users from malicious software. We will take a roller-coaster ride through C++, Java, .NET, Android and JavaScript and stop at the top for a horrifying look at the abyss of the nasty reality. After we had some time to catch our breath again we will take a look at our possibilities as programming language researchers to actually do better.
17:05Prealgebras as Reusable Components for Compositional Functions slides
Tillmann Rendel, University of Marburg
To increase modularity and reuse, we should decompose complex compositional functions into smaller, reusable components. What is the right component abstraction for this task?
In mathematics, compositional functions are studied in universal algebra. From the theory of universal algebra, we know that we can express every compositional function as a generic fold function and an algebra. The algebra describes how to compute a function for a composite term if the result is already known for all immediate subterms. In object-oriented design, this idea corresponds to the internal visitor pattern. So can we use algebras as reusable components?
Already simple example show why algebras are not quite composable enough to serve as reusable components. The problem is that with algebras, we have to consume exactly the same type of information from the immediate subterms as we produce for the composite term. To decouple these two types of information, we introduce prealgebras as a generalization of algebras. Prealgebras admit a rich set of prealgebra combinators that can be used to decompose many compositional functions into simple and reusable prealgebraic fragments. We conclude that prealgebras are indeed the component abstraction we look for.
18.00Dinner (zoo)

Registered participants

Sven Amann TU Darmstadt
Jonathan Brachthäuser University of Marburg
Yufei Cai University of Marburg
Ervina Cergani TU Darmstadt
Yi Dai University of Marburg
Joscha Drechsler TU Darmstadt
Sebastian Erdweg TU Darmstadt
Stefan Fehrenbach University of Marburg
Paolo G. Giarrusso University of Marburg
Bastian Gorholt TU Darmstadt
Markus Hauck TU Darmstadt
Ben Hermann TU Darmstadt
Gerold Hintz TU Darmstadt
Florian Jakob TU Darmstadt
Lev Lamberov University of Marburg
Johannes Lerch TU Darmstadt
Sven Keidel TU Darmstadt
Moritz Lichter TU Darmstadt
Mira Mezini TU Darmstadt
Sebastian Proksch TU Darmstadt
Siegried Rasthofer EC SPRIDE
Christoph Reichenbach Goethe University Frankfurt
Tillmann Rendel University of Marburg
Felix Rieger TU Darmstadt
Guido Salvaneschi TU Darmstadt
Jan Sinschek TU Darmstadt
Jurgen van Ham TU Darmstadt
Pascal Weisenburger TU Darmstadt

Call for participation

We warmly invite all programming-language researchers in Hesse to the First Hessian Workshop on Programming Languages in Darmstadt on June 28, 2013.

The goal of this day-long workshop is to bring our community closer together, to encourage communication, and to foster collaboration. All participants are invited to present their work in short talks (15 minutes) and we will have ample time for discussions.

When: June 28, 2013, 10.00 - 17.00
Where: S202/B002, TU Darmstadt, Dept. of computer science, Hochschultstraße 10

Please indicate participation until June 16 via email to Sebastian Erdweg. Please include the following details:

  • when can you arrive
  • when do you have to leave
  • will you join the (non-sponsored) workshop dinner

We encourage all participants to give a talk about their (possibly ongoing) work. Please send a title and abstract until June 23 via email to Sebastian Erdweg.

Should you have any questions, please do not hesitate to contact any of the organizers.