|
ALIA4J
|
- Project Website
- ALIA4J, short for Advanced-dispatch Language Implementation Architecture for JVM-based languages, defines how compilers and execution environments for Advanced-dispatch languages should be implemented in order to provide themost natural support for advanced dispatching constructs like predicate dispatch or aspects. The center of this architecture is a flexible meta-model, called LIAM (Language-Independent Advanced-dispatch Meta-Model). A compiler generates a corresponding model for the aspects in the program under compilation. ALIA also provides a generic implementation of execution environments with support for the Execution Model and dynamic deployment.
|
|
AO4BPEL
|
- Project Website
- AO4BPEL is an aspect-oriented extension to BPEL4WS that enables modular and dynamically-adaptable web service composition. AO4BPEL uses AOP techniques to overcome the shortcomings of workflow oriented web service composition languages with respect to modularization of crosscutting concerns and support for runtime change.
|
|
CaesarJ
|
- Project Website
- is a new AOP language compatible to Java and AspectJ, which enables the componentization of crosscutting concerns such that they become reusable independent entities and facilitates the integration of third party components without modifying your code. CaesarJ also provides a new deployment concept for aspects supporting aspectual polymorphism.
|
|
Co-Contextual Java
|
- Project Website
- A type checker has an important role to ensure that programs exhibit a desired behavior. It uses the typing context to coordinate type checking from different subexpression of the typing derivation, therefore dependencies are build between subexpressions. These dependencies prevent the type checker to be incremental.
We propose an extension of co-contextual type checking to support Featherweight Java. Co-contextualizing type rules is a technique for constructing type systems that are easy to be incremental. To co-contextualize Featherweight Java we eliminate the context and the class table, where Featherweight Java for type checking uses a typing context and a class table, and replace them by a different structure. As a result, eliminating the context and the class table, and having co-contextual formulation of type rules, we remove the unnecessary dependencies between subexpressions, and facilitate the Featherweight Java type system to be incremental. We describe a method to construct co-contextual type rules, from constraint-based type rules for Featherweight Java. We have an implementation of co-contextual Featherweight Java type, use cases and as well a theorem as proof of equivalence between Featherweight Java and co-contextual Featherweight Java type systems.
|
|
Eko Project
|
- Project Website
- The Eko project is part of the Software Campus, a program funded by the German government that supports young researchers and brings academia and industry together. We cooperate with DHL IT Services to develop an approach for API misuse detection. The goal is to mine usage patterns from existing software code, to detect violations in code under development, and to propose fixes for the findings.
|
|
EScala
|
- Project Website
- EScala is an extension of the Scala programming language integrating declarative events as part of objects. EScala provides a way to declare imperative events and to combine events together in order to create more complex events. It also provides the possibility to intercept some joinpoints which generate implicit events.
|
|
FlowTwist
|
- Project Website
- FlowTwist’s primary goal is to develop a highly precise and scalable automated code analysis that is able to detect security vulnerabilities in the Java Runtime Library. The main challenge is that existing techniques are either precise or scale to huge applications, but usually not both. Therefore, new techniques are being developed as part of the project that are not only applicable in the projects specific context, but in general.
|
|
i3QL
|
|
|
JEScala
|
- Project Website
- JEScala captures coordination schemas in a more expressive and modular way by leveraging a seamless integration of an advanced event system with join abstractions. JEScala is validated with case studies and provide a first performance assessment.
|
|
KaVE Project
|
- Project Website
- The KaVE project is part of the Software Campus, a program funded by the German government that supports young researchers and brings academia and industry together. We work together with an industry partner and develop a recommender system for Visual Studio/C#. The term “KaVE” is an abbreviation for the German title “Kombination automatisierter Verfahren mit Expertenwissen” (“Combination of automated approaches with experts knowledge”). The goal of the project is to enrich statically mined models with feedback provided by experts.
|
|
NFComp
|
- Project Website
- NFComp (Non-functional Composition) is a model-driven approach for the composition of non-functional concerns (NFC) such as security, performance, reliability etc. NFComp has been applied to Web Services which can be regarded from different views.
|
|
PACE
|
|
|
Pattern Language (π)
|
- Project Website
- π is a pattern language: its only language concept is the pattern, which can be best imagined as a function with a signature like a context-free grammar rule. Due to this flexibility, patterns abstract other language constructs and π can be syntactically extended by defining new patterns.
|
|
PEAKS
|
- Project Website
- PEAKS is an acronym for “Platform for the Efficient Analysis and Secure Composition of Software Components”. A fundamental building block in making software engineering more efficient is the reuse of existing components and libraries. Applications are composed of a stack of libraries in conjunction with the respective business code. But as the code of the libraries becomes a part of the control flow of the application, it will run in the same process and thus in the same security context as the main application regardless of the actual need for such a privilege. We aim to build a tool to detect these unnecessary permissions in software libraries and to recommend procedures to limit these privileges or their impact.
|
|
Pegasus Project
|
- Project Website
- Pegasus Project aims at creating a naturalistic programming language, that is, a programming language directly incorporating basic mental concepts such as objects, actions, statements, events, rules and others. This direct mapping of program ideas onto real programs makes programming much more straightforward as it avoids to force our ideas into a very constrained specific programming concept. In addition to that, it increases the readability and understandability of computer programs as well as their sustainability since programs written in natural(istic) language will be readable as long as the respective natural language is spoken.
|
|
POPART
|
- Project Website
- POPART provides a meta-aspect protocol that allows to adapt AO semantics at run-time. While alternative semantics for aspect-oriented abstractions can be defined by language designers using extensible aspect compiler frameworks, application developers are prevented from tailoring the language semantics in an application-specific manner. To address this problem, we propose an architecture for aspect-oriented languages with an explicit meta-interface to language semantics.
We demonstrate the benefits of such an architecture by presenting several scenarios in which aspect-oriented programs use the meta-interface of the language to tailor its semantics to a particular application execution context.
|
|
Scala Benchmarking Project
|
- Project Website
- The Scala Benchmarking Project attempts to answer the following research question: Scala ≡ Java (mod JVM)? Does Scala code differ significantly from Java code when viewed at the level of the Java Virtual Machine. The first major contribution of the Scala Benchmarking Project has thus been to complement a popular Java benchmark suite with a large set benchmarks based on real‐world Scala applications, thereby allowing JVM researchers to finally compare and contrast the performance characteristics of Java and Scala programs beyond the level of micro‐benchmarks.
|
|
SID-UP / Distributed REScala
|
- Project Website
- Distributed REScala is the first language to bring Reactive Programming to the distributed setting. It is build around SID-UP (short for Source IDentifier Update Propagation), an update propagation algorithm that supports the full feature set of Reactive Programming extended to cover Remote Reactives – Reactives that can be shared with and used transparently on remote hosts. SID-UP was designed with distribution in mind, minimizing the amount of coordination and remote communication required to execute glitch-free update turns for distributed reactive applications.
|
|
Veritas
|
- Project Website
- Veritas is a workbench for simplifying the development of sound type systems. Veritas provides a single, high-level specification language for type systems, from which it automatically tries to derive soundness proofs and efficient and correct type-checking algorithms.
|
