J. Baltasar García Perez-Schofield

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.

Visual Zero: A persistent and interactive object-oriented programming environment

In this article, an ongoing research project held in the Computer Science department of the University of Vigo is described. Its main objective is to develop an interactive object-oriented environment, serving as a vehicle for learning object-oriented programming. It currently consists of a virtual machine, an assembler, compilers for two high-level programming languages, and an educational visual programming environment. Its main characteristics are (a) the support of prototype-based object orientation, which is a model of object orientation that actually wraps the class-based model; (b) the support for object persistence, which simplifies all input/output issues to the minimum, and (c) the availability of a new visual programming environment is an invaluable help. We the authors think that the combination of all of these possibilities, will lead to an interesting, useful tool that would be recommended for object-oriented teaching. The whole system has been successfully employed in a number of different courses, allowing students to concentrate on objects and their relationships from the very beginning, and thus helping them to achieve a high degree of knowledge about the object-oriented programming paradigm.

Towards an object‐oriented programming system for education

In this article, an ongoing research project conducted in the Computer Science department of the University of Vigo is described. Its main objective is to serve as a vehicle for learning object‐oriented programming. Although it is still in development, it has been successfully employed in a number of different courses. Its main characteristics are (a) support of prototype‐based object orientation, which is a model of object orientation that actually wraps the class‐based model; (b) future support for object persistence, which simplifies to the minimum all input/output issues; and (c) support of multiple platforms, through a portable bytecode. We think that the combination of all of these possibilities, the obtained results in its first use, and the further development of this project will lead to an interesting, useful tool which would be recommended for object‐oriented teaching. The simplicity of the prototype‐based model of object orientation, the dramatic decrease in complexity for programs due to the direct support of persistence, and all facilities naturally provided by the feature of multiplatform support makes it the ideal tool for learning, allowing the educator to stress on the actually important issues of object‐oriented programming.

Expert in conflicts

Aspect-oriented programming (AOP) is an emergent technology for the modularization of crosscutting concerns. The most used approach to support the AOP paradigm is based on the aspect notion, as the basic unit that contains the crosscutting concern logic and a method (pointcuts, advice, and join-points) that relates it to the functional components. This mechanism, popularized by tools like AspectJ, restricts and limits the handling of conflicts among aspects. In this work, a flexible, wide and powerful approach is presented. This strategy is based on two main mechanisms: definition of associations and symbolic rules. An expert embedded system detects and solves conflicts automatically. The approach presented is implemented in a prototype denominated MEDIATOR.

Modularizing application and database evolution – an aspect-oriented framework for orthogonal persistence

In the maintenance of software applications, database evolution is one common difficulty. In object‐oriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require significant effort from programmers and database administrators. In this paper, we propose orthogonal persistence and aspect‐oriented programming to support semi‐transparent database evolution. A default mechanism for instance evolution is defined, but the user may provide modularized solutions using the aspect‐oriented paradigm. We present our framework AOF4OOP to test the feasibility of our proposed approach. This prototype allows programmes to transparently access data in other versions of the database schema. We evaluate our framework, comparing it to related approaches using two real applications and measuring the improvement of the productivity of the programmer. Copyright

Towards a Flexible and Transparent Database Evolution

Applications refactorings that imply the schema evolution are common activities in programming practices. Although modern object-oriented databases provide transparent schema evolution mechanisms, those refactorings continue to be time consuming tasks for programmers.

Evolution of the Application and Database with Aspects

Generally, the evolution process of applications has impact on their underlining data models, thus becoming a time-consuming problem for programmers and database administrators. In this paper we address this problem within an aspect-oriented approach, which is based on a meta-model for orthogonal persistent programming systems. Applying reflection techniques, our meta-model aims to be simpler than its competitors. Furthermore, it enables database multi-version schemas. We also discuss two case studies in order to demonstrate the advantages of our approach.

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.