The members of the Computational Reflection Research Group have been involved in different research projects. Common research topics in these projects are runtime adaptation and optimization. The following is a sort description of the projects, ordered by date in descending order:
We apply big data and machine learning techniques to massive open source code databases to create tools and services aimed at improving the software development process. In particular, we are working on improving decompilation of binary files, source code representation and analysis using overlaid graph representations, source code classification, runtime performance prediction of gradually typed languages, and structured data mining.
The StaDyn programming language. A programming language that combines the benefits of static typing (performance, early error detection, better documentation and legibility, and better IDE features) and dynamic typing (flexibility, rapid prototyping, less verbose, less rigid, and dynamically adaptable). It follows the Separation of Concerns principle, making possible to modify the dynamism of (part of) an application without modifying its source code. This project is actively under development. We are concluding the first stage of three. More information available here.
The DSAW AOSD Platform is a Dynamic and Static Aspect Weaver. DSAW supports dynamic AOP in a real fashion. This system uses the .Net platform to dynamically add and replace aspects of any .Net program at runtime. It also includes static aspect weaving to obtain a better performance. Therefore, the dynamism concern is separated from the aspect-oriented development. This project is actively under development. More information available here.
The main objective of the ЯRotor project is the significant optimization of dynamic languages by means of JIT compilation. Using the Shared Source implementation of the CLI, the .Net platform has been enhanced to support computational primitives of dynamic languages. We provide native support of structural reflection in the .Net prlatform. Dynamic inheritance has also been added. More information available here.
stypy is a tool to detect type errors in Python programs with no type annotations. stypy translates each Python program into Python code that type-checks the original program. The generated code replaces each variable with a type variable, evaluating expression types instead of their values. The generated type checker detects type errors in different tricky Python idioms, and ensures termination. stypy in a preliminary stage. Eventually, we also plan to use stypy to optimize Python programs.
Jindy is a library Java that provides the use of the
invokedynamic opcode to any high-level language running on the Java platform. Jindy postpones until runtime method invocation and field access. It also offers an alternative use to the reflection API, providing optimizations that avoid type conversions. It is also possible to provide custom bootstrap methods that resolve the method to invoke at runtime. Jindy has also been used to measure the benefits of the
invokedynamic opcode to optimize dynamic languages.
nitrO is the work designed as the PhD thesis of Francisco Ortin. It is based on a reflective abstract machine that provides runtime structural reflection. Over this layer, a non-restrictive reflective system provides behavioral reflection. Using behavioral reflection, a dynamically adaptable persistence system has been developed (PhD thesis of Benjamin Lopez).
The nitrO virtual machine is a reflective abstract machine implementation that uses reflection in order to build an extensible and adaptable computational system, capable of being deployed over heterogeneous environments. Programming on its own language, its computational abstraction level can be increased. As an example, different garbage collectors, persistence systems, object distribution and thread synchronization have been developed by using its own programming language: no modification on its initial implementation has been performed. This project finished in 2002.
The nitrO non-restrictive reflective system offers a dynamic behavioral and linguistic reflection. This means that any programming language feature can be changed at runtime. Different examples are the modification of the message passing mechanism, inheritance or how objects are created. The main contribution of this system is that there are no previous limitations of what can be reflectively customized. The level of adaptability is much higher than the one offered by Meta-Object Protocols. MOPs. This project finished in 2002.
The implicit reflective persistence system is a practical use of the nitrO non-restrictive reflective system. This project demonstrates how computational reflection can be employed as a suitable technique to overcome runtime adaptability and language independence. Over our reflective system, implicit and dynamically adaptable persistence was achieved, so that the user does not need to take special action to make objects persist. At runtime, persistence characteristics of applications can be modified without any restriction in a programmatically way, regardless of the programming language used. This project finished in 2005.
Zero is an object-oriented, prototype-based, dynamic virtual machine, in collaboration with the University of Vigo. It supports structural reflection and persistence. Two interoperable programming languages have been developed for it, one of them being a class-based, strict type-checked language. More information available here.
TIC4BOT is a robotics framework that can be programmed in Java and any dynamic language supported by the standard Java Scripting API, as is the case of Python. Using the metaprogramming features of dynamic languages, the TIC4BOT framework allows hot reprogramming of robots.
TyS (Typechecking System) is an object-oriented type checker framework. TyS supports the automatic task of building object-oriented type checkers, to be used in language processors such as compilers (static type systems) or interpreters (dynamic type systems). It covers the existing lack of automatic implementation of (part of the) semantic analyzers in programming languages processors. More information about TyS.