José Baltasar García Pérez-Schofield

Including both static and dynamic typing in the same programming language

Dynamic languages are becoming increasingly popular for different software development scenarios such as Web engineering, rapid prototyping or the construction of applications that require runtime adaptiveness. These languages are built on the idea of supporting reasoning about (and customising) program structure, behaviour and environment at runtime. The dynamism offered by dynamic languages is, however, counteracted by two main limitations: no early type error detection and fewer opportunities for compiler optimisations. To obtain the benefits of both dynamically and statically typed languages, the authors have designed the StaDyn programming language that provides both approaches. StaDyn keeps gathering-type information at compile time, even when dynamic variables are used. This type information is used to offer early type error detection, direct interoperation between static and dynamic codes and better runtime performance. Following the Separation of Concerns principle, it is possible to customise the trade-off between runtime flexibility of dynamic typing and safety, performance and robustness of static typing. A runtime performance assessment is presented to show an estimate of the benefits of combining dynamic and static typing in the same programming language.

Separating adaptable persistence attributes through computational reflection

To receive persistence capabilities, applications usually must explicitly access database management systems, such as object-oriented databases or object-relational mapping products. The usual way of building an application is tangling its functional code with explicit structured query language (SQL) or object query language (OQL) persistence statements. This tangling has several drawbacks: deficiencies in source code legibility, maintainability, and portability; lack of persistence functionality reuse; and low adaptability of persistence attributes. Separating crosscutting concerns such as persistence from the main application code can reduce software complexity and facilitate concerns reuse. A prototype persistence system shows how to use computational reflection to completely separate and adapt application persistence attribute at runtime.

Neuro-Lab: A highly reusable software-based environment to teach artificial neural networks

It is increasingly usual to find notions of artificial neural networks (ANNs) included in the curricula of many engineering studies. In this article, we present Neuro‐Lab, a simulation software to teach basic concepts of ANNs to undergraduate students of the Computer Engineering School in the University of Vigo (Spain). Neuro‐Lab was designed with the aim of offering a very easy‐to‐use user interface, support of exploratory learning activities, and also high reusability. This feature allows for an easy extension, integration, and interoperation of the software with other applications.

R-Interface: An Alternative GUI for MATLAB

We present R‐Interface, a software application that offers an alternative graphical user interface (GUI) to MATLAB engine and functionality. The purpose of this work is to present a solution based on encapsulating and reusing proprietary environments. This will allow developing custom user interfaces where we can enhance particular features, as educational ones, in order to have more comprehensive and really user friendly GUIs. Since functionality is reused, and therefore it does not have to be implemented, we will have the possibility to build powerful and ad hoc tools for teaching and investigating, in a short term and at low costs.

Two-Layer Wrapping for COTS Software Integration: An Experience with Matlab

Although commercial-off-the-shelf (COTS) product integration presents clear advantages in a variety of engineering fields, several problems can arise in part due to their heterogeneous nature. Little research addresses the integration of particular COTS to specific domains. A University of Vigo project for reusable software development in the engineering domain adopted this approach. The underlying hypothesis was that making COTS integration easier would facilitate the development of domain-specific applications. The solution consists of a two-layer wrapping approach. The first layer captures the COTS domain model, facilitating integration of general-purpose functionality. A second layer provides better integration of more domain-specific functionality. Several real software development projects have used the proposed solution, and the results yielded notable effort savings, showing the approachs utility in reducing COTS integration efforts.