The Second Hessian Workshop on Programming Languages takes place in 2014 in Marburg.
Program for the Workshop on June 28, 2013
|Session 1 (Chair: Sebastian Erdweg)|
|10.15||Programming 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.40||Finite 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.05||Software 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.|
|Session 2 (Chair: Tillmann Rendel)|
|12:00||The 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.
|Present your idea related to programming language research in ca. 3 minutes.|
Sign up at the workshop
|13.00||Lunch (sardegna da franco)|
|Session 3 (Chair: Guido Salvaneschi)|
|14:30||Semantics-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:55||Dynamic 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:20||Open 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.
|Session 4 (Chair: Paolo G. Giarrusso)|
|16:15||CODANA – 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:40||A Brief Overview of Common Software Security Architectures … And Why No Human Being Can Maintain This Anymore – Horror, Terror, Suspense slides|
|Ben Hermann, TU Darmstadt|
|17:05||Prealgebras 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.
|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.