Aspect] is a simple and practical aspect-oriented extension to Java With just a few new constructs, AspectJ provides support for modular implementation of a range of crosscutting concerns. In AspectJ's dynamic join point model, join points are well-defined points in the execution of the program; pointcuts are collections of join points; advice are special method-like constructs that can be attached to pointcuts; and aspects are modular units of crosscutting implementation, comprising pointcuts, advice, and ordinary Java member declarations. AspectJ code is compiled into standard Java bytecode. Simple extensions to existing Java development environments make it possible to browse the crosscutting structure of aspects in the same kind of way as one browses the inheritance structure of classes. Several examples show that AspectJ is powerful, and that programs written using it are easy to understand.

An overview of AspectJ

The Object Management Group's (OMG) Model Driven Architecture (MDA) strategy envisages a world where models play a more direct role in software production, being amenable to manipulation and transformation by machine. Model Driven Engineering (MDE) is wider in scope than MDA. MDE combines process and analysis with architecture. This article sets out a framework for model driven engineering, which can be used as a point of reference for activity in this area. It proposes an organisation of the modelling 'space' and how to locate models in that space. It discusses different kinds of mappings between models. It explains why process and architecture are tightly connected. It discusses the importance and nature of tools. It identifies the need for defining families of languages and transformations, and for developing techniques for generating/configuring tools from such definitions. It concludes with a call to align metamodelling with formal language engineering techniques.

Model Driven Engineering

Data centers are critical, energy-hungry infrastructures that run large-scale Internet-based services. Energy consumption models are pivotal in designing and optimizing energy-efficient operations to curb excessive energy consumption in data centers. In this paper, we survey the state-of-the-art techniques used for energy consumption modeling and prediction for data centers and their components. We conduct an in-depth study of the existing literature on data center power modeling, covering more than 200 models. We organize these models in a hierarchical structure with two main branches focusing on hardware-centric and software-centric power models. Under hardware-centric approaches we start from the digital circuit level and move on to describe higher-level energy consumption models at the hardware component level, server level, data center level, and finally systems of systems level. Under the software-centric approaches we investigate power models developed for operating systems, virtual machines and software applications. This systematic approach allows us to identify multiple issues prevalent in power modeling of different levels of data center systems, including: i) few modeling efforts targeted at power consumption of the entire data center ii) many state-of-the-art power models are based on a few CPU or server metrics, and iii) the effectiveness and accuracy of these power models remain open questions. Based on these observations, we conclude the survey by describing key challenges for future research on constructing effective and accurate data center power models.

Data Center Energy Consumption Modeling: A Survey

The model-driven software development paradigm requires that appropriate model transformations are applicable in different stages of the development process The transformations have to consistently propagate changes between the different involved models and thus ensure a proper model synchronization However, most approaches today do not fully support the requirements for model synchronization and focus only on classical one-way batch-oriented transformations In this paper, we present our approach for an incremental model transformation which supports model synchronization Our approach employs the visual, formal, and bidirectional transformation technique of triple graph grammars Using this declarative specification formalism, we focus on the efficient execution of the transformation rules and how to achieve an incremental model transformation for synchronization purposes We present an evaluation of our approach and demonstrate that due to the speedup for the incremental processing in the average case even larger models can be tackled

From model transformation to incremental bidirectional model synchronization

Since ontology-driven software development (ODSD) is an integration of ontology technologies and model-driven software development (MDSD), it is necessary to identify and analyse technologies applied in MDSD. We define basic concepts, such as model-driven engineering, metamodelling, model transformation and technological space, and describe the state-of-the-art implementations of these concepts.

Model-Driven Software Development

As aspect-orientation grows in influence, the scope of applicability also will need to expand. The new approaches for improved modularization offered by aspect-orientation can provide benefits not only to new development efforts, but to legacy systems as well. A difficulty with legacy system adoption of aspect-orientation, however, is in the construction of new weavers for the disparate programming languages in which the legacy software is coded. In this paper, we describe our experience with using a program transformation system as the underlying engine for weaver construction. In particular, the capability for weaving aspects into Object Pascal (Delphi) is demonstrated using the Design Maintenance System (DMS). From this Object Pascal weaving environment, the improved modularization of several crosscutting concerns in a commercial software application is shown. The paper also describes an initial approach for construction of language-independent aspect weavers.

/pdf/a-technique-for-constructing-aspect-weavers-using-a-program-1ew9wgdgtd.pdf

A technique for constructing aspect weavers using a program transformation engine

Reducing energy consumption of mobile systems in order to prolong their operating time has been an interesting research topic over the past several years. Such systems are typically battery powered. Hence, their uptime depends on the energy consumptions of the used components. By applying novel strategies that allow systems to dynamically adapt at runtime can be effectively used to reduce energy consumption. The focus of this paper is based on a case study that uses an energy management component that can dynamically choose the “best” sorting algorithm duing a multi-party mobile communication. The results indicate that Insertionsort is the most optimal sorting algorithm when in comes to saving energy.

Choosing the "best" sorting algorithm for optimal energy consumption

Most mobile and embedded devices are battery powered. Hence, their uptime depends on the energy consumption of the used components. Developers made severe effort to optimize hardware components in order to reduce their energy consumption. However, in this paper we show that one also has to consider energy awareness in terms of software. In this study we focus on sorting algorithms, which are not only used directly by the user of a device but also very often implicitly by other algorithms. Our experiments show,that different sorting algorithms consume different amounts of energy. In detail, the experiments show that there is no direct correlation between the time complexity of an algorithm and its energy consumption.

Exploring the Energy Consumption of Data Sorting Algorithms in Embedded and Mobile Environments

A common trend in programming language specification is to generate various tools (e.g., compiler, editor, profiler, and debugger) from a grammar. In such a generative approach, it is desirable to have the definition of a programming language be modularized according to specific concerns specified in the grammar. However, it is often the case that the corresponding properties of the generated tools are scattered and tangled across the language specification. In this paper, separation of concerns within a programming language specification is demonstrated by considering debugging support within a domain-specific language (DSL). The paper first describes the use of AspectJ to weave the debugging semantics into the code created by a parser generator. The paper outlines several situations when the use of AspectJ is infeasible at separating language specification properties. To accommodate such situations, a second approach is presented that weaves the debugging support directly into a grammar specification using a program transformation engine. A case study for a simple DSL is presented to highlight the benefits of weaving across language specifications defined by grammars.

/pdf/weaving-a-debugging-aspect-into-domain-specific-language-dwu2j594kq.pdf

Weaving a debugging aspect into domain-specific language grammars

Model-driven approaches to software development, when coupled with a domain-specific visual language, assist in capturing the essence of a large system in a notation that is familiar to a domain expert. From a high-level domain-specific model, it is possible to describe concisely the configuration features that a system must possess, in addition to checking that the model preserves semantic properties of the domain. With respect to large legacy applications written in disparate programming languages, the primary problem of transformation is the difficulty of adapting the legacy source to match the evolving features specified in the corresponding model. This paper presents an approach for uniting model-driven development with a mature program transformation engine. The paper describes a technique for performing widespread adaptation of source code from transformation rules that are generated from a domain-specific modeling environment for a large avionics framework.

https://gray.cs.ua.edu/pubs/gpce-2004.pdf

Suman Roychoudhury

Papers

A technique for constructing aspect weavers using a program transformation engine

Choosing the "best" sorting algorithm for optimal energy consumption

Exploring the Energy Consumption of Data Sorting Algorithms in Embedded and Mobile Environments

Weaving a debugging aspect into domain-specific language grammars

Model-driven program transformation of a large avionics framework