Language Design for Reactive Software. Many modern software systems are reactive: they respond to the occurrence of events of interest by performing some computation, which may in turn trigger new events. Reactive languages support dedicated abstractions for this class of software. For example, REScala is a reactive language which integrates concepts from event-based and functional-reactive programming into the object-oriented world. REScala supports the development of reactive applications by fostering a functional and declarative style which complements the advantages of object-oriented design. Events and signals have their advantages and disadvantages and event-based applications cannot be refactored to use only signals without loss of desired properties. We derive that there is a need for a language design that supports a fluid transition between the two worlds and seamlessly integrates them into the OO setting.
[ECOOP'18][OOPSLA'18][ICFP'18][OOPSLA'14] [IEEE Software'14] [MODULARITY'14] [MODULARITY'14] [MODULARITY'13]
Tool Support for Reactive Programming. Reactive programming relieves developers from manually updating outputs when the inputs of a computation change, it overcomes a number of well-know issues of the Observer design pattern, and it makes programs more comprehensible. Unfortunately, complementing the new paradigm with proper tools is a vastly unexplored area. Hence, as of now, developers can embrace reactive programming only at the cost of a more challenging development process. We investigate a primary issue in the field: debugging programs in the reactive style. We analyze the problem of debugging reactive programs, show that the reactive style requires a paradigm shift in the concepts needed for debugging, and propose RP Debugging, a methodology for effectively debugging reactive programs. These ideas are implemented in Reactive Inspector, a debugger for reactive programs integrated with the Eclipse Scala IDE.
Lightweight, Flexible Object-Oriented Generics. The Genus programming language is an ongoing project involving researchers from Cornell University, MIT, and TU Darmstadt. It is an object-oriented language that aims to provide an expressive, lightweight genericity mechanism with better code reuse than Java and stronger static checking. The core idea of Genus is to add constraints that are predicates describing features of types that are required by generic code and models that show how types can satisfy constraints. To make the mechanism lightweight, types induce natural models for constraints when the operations of the type already match what the constraint requires. In typical use, models do not need to be defined or mentioned, yet the expressive power to provide a customized model is always present. Genus integrates this mechanism with object-oriented inheritance so that models can be later enriched in a modular way to handle future subclasses.
Middleware for Distributed Reactive Applications. Recent research on reactive languages successfully addresses the drawbacks of the Observer pattern – the traditional way reactive applications are implemented in the object-oriented setting – by introducing time-changing values and other ad-hoc programming abstractions. However, those approaches are limited to local settings, but most applications are distributed. Distributed reactive programming not only moves reactive languages to the distributed setting, but is a promising concept for middleware and distributed systems design.
Security. With information and communication technologies becoming ubiquitous, security has emerged as a primary issue in computer science. I’ve been working on security areas which include malware analysis and identification, network intrusion detection and malware naming (in) consistencies. Our main contribution, Reanimator, in collaboration with TU Wien, was the first approach to use information gathered by dynamic execution to harvest malware behavior with static analysis.
[PASS'19][Scala'16][ICISS'11] [IEEE S&P'10] [EC2ND'09]
Languages for self-adaptive software. Self-adaptive software modifies its behavior at run time to satisfy changing requirements in a dynamic environment. Aspect-oriented programming (AOP) and context-oriented programming (COP) has been proposed as a specialized programming paradigm for context-aware and adaptive systems. Our main project in this area, ContextErlang, is a programming language that takes into account the needs of a context-aware system, including distribution, dynamic adaptation and asynchronous communication.
[SCP'15] [TAAS'13] [JSS'12] [MODULARITY'12] [SEAMS'11] [COP'11] [SEAMS'10] [COP'10]