Juan Manuel Cueva

Dynamic adaptation of application aspects

In todays fast changing environments, adaptability has become an important feature in modern computing systems, programming languages and software engineering methods. Different approaches and techniques are used to achieve the development of adaptable systems. Following the principle of separation of concerns, aspect-oriented programming (AOP) distinguishes application functional code from specific concerns that cut across the system, creating the final application by weaving the programs main code and its specific aspects. In many cases, dynamic application adaptation is needed, but few existing AOP tools offer it in a limited way. Moreover, these tools use a fixed programming language: aspects cannot be implemented regardless of its programming language.We identify reflection as a mechanism capable of overcoming the deficiencies previously mentioned. We have developed a nonrestrictive reflective technique that achieves a real computational-environment jump, making every application and language feature adaptable at runtime--without any previously defined restriction. Moreover, our reflective platform is independent of the language selected by the programmer. Using the reflective capabilities of the platform presented, an AOP framework that achieves dynamic aspect weaving in a language-independent way has been constructed, overcoming the common limitations of existing AOP tools.

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.

Design Patterns for Teaching Type Checking in a Compiler Construction Course

A course in compiler construction seeks to develop an understanding of well-defined fundamental theory and typically involves the production of a language processor. In a graduate degree in software engineering, the development of a compiler contributes significantly to the developers comprehension of the practical application of theoretical concepts. Different formal notations are commonly used to define type systems, and some of them are used to teach the semantic analysis phase of language processing. In the traditional approach, attribute grammars are probably the most widely used ones. This paper shows how object-oriented design patterns represented in unified modeling language (UML) can be used to both teach type systems and develop the semantic analysis phase of a compiler. The main benefit of this approach is two-fold: better comprehension of theoretical concepts because of the use of notations known by the students (UML diagrams), and improvement of software engineering skills for the development of a complete language processor.

Non-restrictive computational reflection

Adaptable software systems and architectures give the programmer the ability to create applications that might customize themselves to runtime-emerging requirements. Computational reflection is a programming language technique that is commonly used to achieve the development of this kind of systems. Most runtime reflective systems use Meta-Object Protocols (MOPs). However, MOPs restrict the amount of features an application can customize, and the way they can express its own adaptation. Furthermore, this kind of systems uses a fixed programming language: they develop an interpreter, not a whole language-independent platform.What we present in this paper a non-restrictive reflective platform, called nitrO, that achieves a real computational-environment jump, making every application and language feature adaptable at runtime--without any previously defined restriction. Moreover, the platform has been built using a generic interpreter, in which the reflection mechanism is independent of the language selected by the programmer. Different applications may dynamically adapt each other, regardless of the programming language they use.

Implementing a real computational-environment jump in order to develop a runtime-adaptable reflective platform

Different techniques are emerging in order to build adaptable computing systems and software engineering methods. Two examples in the software engineering field are aspect-oriented programming and multi-dimensional separation of concerns. They distinguish functional code from reusable crosscutting aspects, creating the final application by weaving the program and its specific aspects. They lack runtime adaptability, simply offering design-time adaptation.Dynamic adaptability is offered by MOP-based reflective systems. However, meta-object protocols (MOPs) restrict the amount of features an application may customize, and the way they can express this customization. Furthermore, this kind of systems uses a fixed programming language.What we present in this paper is a non-restrictive reflective system that achieves a real computational jump, making every application and language feature adaptable at runtime-without any previous restriction. Moreover, the reflection mechanism is independent of the language selected by the programmer.

The reflective nitrO abstract machine

Abstract machines have been widely employed in computing systems in order to obtain different aims. Compiler simplification, platform neutrality, code distribution, interoperability, and direct support for specific paradigms are examples of the benefits they offer. Although performance has been its main drawback, the use of modern techniques like adaptive (hotspot) just in time compilation has overcome this weakness. Nowadays, well-known platforms based on abstract machines such as Java#8482; or Microsoft .NET are commercially used.With the purpose of supporting any programming-language computational-model in heterogeneous environments, we have noticed that most abstract machines have extensibility, adaptability and heterogeneously lacks. We have designed an abstract machine that, using reflection as the main design principle, overcomes the limitations discovered. In this paper, we describe its objectives, its design, a sample implementation, and a comparison with other similar platforms.

ALMcss: a javascript implementation of the CSS template layout module

Traditionally, web standards in general and Cascading Style Sheets (CSS) in particular take a long time from when they are defined by the W3C until they are implemented by browser vendors. This has been a limitation not only for authors, who had to wait even years before they were able to use certain CSS properties in their web pages, but also for the creators of the specification itself, who were not able to test their proposals in practice. In this paper we present ALMcss, a JavaScript prototype that implements the CSS Template Layout Module, a proposal for an addition to CSS to make it a more capable layout language. It has been developed inside the W3C CSS Working Group by two of the authors of this paper. We present the rationale of the module and an introduction to its syntax, before discussing the design of our prototype. ALMcss has served us as a proof of concept that the Template Layout Module is not only feasible, but it can be in fact implemented in current web browsers using just JavaScript and the Document Object Model (DOM). In addition, ALMcss allows web designers to start to use today the new layout capabilities of CSS that the module provides, even before it becomes an official W3C specification.

Towards the evaluation of usability in educative websites

This article presents a methodological approach of evaluation of the usability in educational environments ME-UsitE, an analysis of the necessity to implement a tool of evaluation and measurement of the usability to support the methodology, that contributes to the detection of problems and failures of usability from the perspective of the user of educative websites in a real work environment. Taking into account that the websites are designed and implemented for a domain and audience in particular, it is important to consider factors like these for the implementation of a tool that allows not only to carry out the evaluation process but also to support the analysis of the gathered data. Thus, the obtained results may allow us to establish policies for the improvement of the usability of the site, when providing a score that determines whether the level of usability offered covers the requirements for the proposed audience and the profile of the participant user in the evaluation.

Proposal of a Tool of Support to the Evaluation of User in Educative Web Sites

This article presents an analysis of the necessity to implement a tool of evaluation and measurement of the usability to support the ME-USitE methodology that contributes to the detection of problems and failures of usability from the perspective of the user of educative Web sites in a real work environment. Taking into account that the Web sites are designed and implemented for a domain and audience in particular, its important to consider factors like these for the implementation of a tool that allows not only to carry out the evaluation process but also to support the analysis of the gathered data. Thus, the obtained results may allow us to establish policies for the improvement of the usability of the site, when providing a score that determines whether the level of usability offered covers the requirements for the proposed audience and the profile of the participant user in the evaluation.

BDOviedo3: data XML storage and management

OOBDMS provide a good solution for the management of XML documents. This article shows the different approach (specific and generic) of coupling an object model with XML and emphasizes the possibilities offered by BDOviedo3 system. It is an object-oriented database built over an integral object-oriented system. The flexibility provided by its object-oriented construction and the extensibility of its mechanisms (such as indexing) can transform it into a XML document manager.