Jose Manuel Redondo

Efficient virtual machine support of runtime structural reflection

Increasing trends towards adaptive, distributed, generative and pervasive software have made object-oriented dynamically typed languages become increasingly popular. These languages offer dynamic software evolution by means of reflection, facilitating the development of dynamic systems. Unfortunately, this dynamism commonly imposes a runtime performance penalty. In this paper, we describe how to extend a production JIT-compiler virtual machine to support runtime object-oriented structural reflection offered by many dynamic languages. Our approach improves runtime performance of dynamic languages running on statically typed virtual machines. At the same time, existing statically typed languages are still supported by the virtual machine. We have extended the .Net platform with runtime structural reflection adding prototype-based object-oriented semantics to the statically typed class-based model of .Net, supporting both kinds of programming languages. The assessment of runtime performance and memory consumption has revealed that a direct support of structural reflection in a production JIT-based virtual machine designed for statically typed languages provides a significant performance improvement for dynamically typed languages.

OPTIMIZING REFLECTIVE PRIMITIVES OF DYNAMIC LANGUAGES

Dynamic languages are becoming widely used in software engineering due to the flexibility needs of specific software systems. Different example scenarios are the development of dynamic aspect oriented software, Web applications, adaptable and adaptive software or application frameworks. One important lack of these languages is compile-time error detection offered by static languages. However, runtime performance is the most serious limitation to use them in commercial software development. Although JIT optimizing compilation is a widely used technique to speed up intermediate code execution, this has not been successfully applied to dynamically adaptive platforms yet. We present an approach to improve the structural reflective primitives offered by dynamic languages. Looking for a language-neutral platform with a good JIT-based runtime performance, we have used the Microsoft shared source implementation of the CLI. Its model has been extended with semantics of prototype-based object-oriented models, much more suitable than the class-based one for reflective environments. This augmented semantics together with JIT generation of native code has produced significantly better runtime performance than the existing implementations.

A Comprehensive Evaluation of Common Python Implementations

Python is a widely used general-purpose dynamic language. Owing to its popularity, many implementations exist for the two distinct Python 2 and Python 3 language versions. Researchers evaluated seven implementations of both language versions to facilitate the selection of one of them. For this purpose, they carefully selected 523 programs to execute in each implementation. They evaluated run-time performance and memory consumption and investigated each implementations important qualitative characteristics.

Efficient support of dynamic inheritance for class- and prototype-based languages

Highlights? We define language-neutral dynamic inheritance for both class- and prototype-based object models. ? The semantics has been included as part of a production JIT-compiler virtual machine. ? The resulting virtual machine has been evaluated to provide significant runtime performance benefits with low memory consumption. ? Our platform supports both dynamically and statically typed languages, allowing a direct interoperation between them. ? Backward compatibility with existing. Net applications is maintained. Dynamically typed languages are becoming increasingly popular for different software development scenarios where runtime adaptability is important. Therefore, existing class-based platforms such as Java and .Net have been gradually incorporating dynamic features to support the execution of these languages. The implementations of dynamic languages on these platforms commonly generate an extra layer of software over the virtual machine, which reproduces the reflective prototype-based object model provided by most dynamic languages. Simulating this model frequently involves a runtime performance penalty, and makes the interoperation between class- and prototype-based languages difficult.Instead of simulating the reflective model of dynamic languages, our approach has been to extend the object-model of an efficient class-based virtual machine with prototype-based semantics, so that it can directly support both kinds of languages. Consequently, we obtain the runtime performance improvement of using the virtual machine JIT compiler, while a direct interoperation between languages compiled to our platform is also possible. In this paper, we formalize dynamic inheritance for both class- and prototype-based languages, and implement it as an extension of an efficient virtual machine that performs JIT compilation. We also present an extensive evaluation of the runtime performance and memory consumption of the programming language implementations that provide dynamic inheritance, including ours.

Achieving Multiple Dispatch in Hybrid Statically and Dynamically Typed Languages

Multiple dispatch is a feature provided by some programming languages, in which the actual method to be executed is dynamically determined by the runtime types of its arguments. Although some programming languages such as CLOS, Xtend and Dylan provide this feature, many widespread languages such as Java, C# and C++ only support single dispatch by means of dynamic binding. Therefore, different implementation techniques are commonly used to obtain multiple dispatch from within these single-dispatch languages. We propose a new approach to obtain multiple dispatch in single-dispatch hybrid static and dynamic typing languages. Using C# as an example, the proposed approach is compared with the existing ones, considering factors such as software maintainability and readability, code size, parameter generalization, compile-time type checking, and runtime performance. The example implementation of the hybrid statically and dynamically typed approach in .Net has shown a runtime performance 1.26 times lower than the statically typed approach, and 6.27 times higher than the dynamically type one.

Towards the Integration of Metaprogramming Services into Java.

Dynamic languages are widely used in scenarios where runtime adaptability is a strong requirement. The metaprogramming features provided by these languages allow the dynamic adaptation of the structure of classes and objects, together with the evaluation of dynamically generated code. These features are used to build software capable of adapting to runtime changing environments. However, this flexibility is counteracted with the lack of static type checking provided by statically typed languages such as Java. Static type checking supports the earlier detection of type errors, involving a valuable tool in software development. In this position paper, we describe the steps we are following to add some runtime metaprogramming services to Java. We intend to provide the runtime flexibility of structural intercession and dynamic code evaluation provided by most dynamic languages, without losing the robustness of the compile-time type checking of Java. The metaprogramming services are provided as a library so, unlike other existing systems, any standard virtual machine and language compiler could be used.

A SaaS Framework for Credit Risk Analysis Services

Credit Risk Analysis (CRA) software services are becoming very important nowadays due to the financial crisis. Adapting the existing Enterprise Resource Planning (ERP) systems to include CRA services commonly involves a high cost, mainly caused by particular requirements of each company. On contrary, the CRA systems not included in the company ERP still require the ERP data. In this paper we describe OneRate, a Software as a Service (SaaS) CRA solution. OneRate frees the companies from the cost of adapting their current ERPs and from maintaining a separate CRA product. Our solution is highly customizable to the particular needs of each client company, so that customers benefit from the existing CRA capabilities while they also have a personalized product. OneRate is currently supporting more than 300 users of 32 different companies.

Design of a Programming Paradigms Course Using One Single Programming Language

Undergraduate students of a Software Engineering degree must be able to select the appropriate paradigm to solve a problem. They must also be able to know the foundations of concurrent and parallel programming. In the Software Engineering degree taught in the University of Oviedo, both competencies were assigned to the Programming Technology and Paradigms course. In this article, we present the approach we followed in the design of that course to teach object-oriented, functional, concurrent and parallel programming to second year undergraduate students with basic knowledge of Java. Due to the time limitations of the course, the proposed design uses one single programming language besides Java. We describe the most important challenges we faced and how we addressed them.

Towards a Java Library to Support Runtime Metaprogramming

Statically typed languages such as Java offer two key advantages: robustness increase due to compile time error detection, and better runtime performance caused by the reduction of runtime type checking. However, dynamic languages are sometimes preferred in scenarios where runtime adaptability is a strong requirement, such as building software capable of adapting to runtime changing environments. The metaprogramming features of dynamic languages allow the runtime adaptation of class and object structures, modifying inheritance relationships, and the evaluation of dynamically generated code. In this position paper, we describe the steps we are following to add to Java some of the metaprogramming services provided by most dynamic languages. The objective is to provide the runtime flexibility of structural intercession, dynamic inheritance and dynamic code evaluation, without losing the robustness of compile-time type checking. The metaprogramming services are provided as a library so, unlike other existing systems, any standard virtual machine and language implementation could be used.

Extending the SSCLI to Support Dynamic Inheritance

This paper presents a step forward on a research trend focused on increasing runtime adaptability of commercial JIT-based virtual machines, describing how to include dynamic inheritance into this kind of platforms. A considerable amount of research aimed at improving runtime performance of virtual machines has converted them into the ideal support for developing different types of software products. Current virtual machines do not only provide benefits such as application interoperability, distribution and code portability, but they also offer a competitive runtime performance.