The AspectOPTIMA project aims to build an aspect-oriented framework that provides run-time support for transactions. The previously established decomposition of the ACID (atomicity, consistency, isolation, durability) properties into ten well-defined reusable aspects had one limitation: it didn't take into account the concerns of transaction life-time support, resulting in the creation of a cross-cutting concern among the aspects. This thesis removes the cross-cutting concern by integrating the transactional life cycle management issues such as determining the transaction boundaries, maintaining a well-defined state and managing the involvement of the participants. The integration process results in the creation of new aspects that serve as building blocks for various transactional models. The thesis also demonstrates how these base aspects can be configured and composed in different ways to design customized transaction models with different concurrency control and recovery strategies.

No description available.

Thesis (M.S.)--University of Texas at Dallas, 2007. / Includes vita. Includes bibliographical references (leaves 101-105)

Title from title page (viewed March 10, 2009) College of Computer and Information Science. Includes bibliographical references (p. 177-182).

With the advent of multicore processors, there is an increasing amount of interest in building concurrent applications capable of fully utilising their features. Developing applications for these platforms to take full advantage of the power of multicore capabilities remains a complex, error-prone, and challenging endeavour. Unfortunately, concurrency is not uniformly and externally expressed in most existing application models. The result is that concurrency and thread management are hidden within objects or components and intermixed with their functionalities. After demonstrating the tangling of code that results from the interaction of these two major concerns, this thesis describes a method of improving the concurrent program by applying a novel technique to separate the concerns: aspect-oriented programming, which aims to encapsulate concerns that crosscut the main program flow in separate entities into aspects. The most mature aspect-oriented tool available at the time this project was being undertaken is AspectJ, which is an extension of Java. AspectJ can be used to write an aspect to a separate concern in a sequential program to avoid code tangling, but it is often inapplicable for concurrent programs. The problem lies in the fact that the points where parallelisation should occur are not natural join points in AspectJ (i.e. points where AspectJ can intervene). Consequently, this thesis proposes a set of fine-grained join points capable of completely handling concurrent programs. This model goes beyond present AspectJ models and demonstrates the need to recognise complex behaviour for an effective separation of concerns. Finally, aspects for implementing concurrent programs according to different schemes are presented, together with evaluation results. This highlights the flexibility of aspects for implementing concurrent programs, a flexibility which is always a cross-cutting concern with respect to the main concern of base applications.

Aspect oriented programming is a relatively new programming paradigm aimed at improving the development of software through a mechanism that allows for crosscutting concerns to be better modularized. Such concern crosscutting is an element of software artifacts that affects one or more quality attributes and ultimately the ability of software to evolve to meet new functional requirements, or to take advantage of new hardware, or meet new business rules. The aim of this dissertation was to explore the relationship between the degree of crosscutting present in a software artifact and its evolvability. This research study illustrates the correlation between the homogeneity of a program's features and its ability to evolve. Throughout the study, such correlation was drawn from a three pronged approach, first by looking at measuring how invasive code changes are, second by identifying a measurable evolvability indicator, and third by using such indicator to propose changes in program constructs that can enhance or improve the evolvability of it. This study proposed the use of existing concern crosscutting metrics to measure invasiveness of code changes and the variability of such measurements to infer a measurable evolvability indicator. Through this approach a number of contributions were made to the body on knowledge, first the creation of a way to quantify evolvability of Aspect Oriented programmed software, and secondly, a way of identifying parts of an Aspect Oriented artifact that can contribute to the deterioration of the system by hindering its evolvability.

This study investigated the need for a pointcut for parallelizable loops in an aspect-oriented programming environment. Several prototype solutions exist for loop pointcuts, but the solutions are not very granular. In particular, they are not able to differentiate between loops that are parallelizable and those that are not. Being able to identify parallelizable loops automatically, as part of an aspect-oriented compiler's weaving process, is particularly important because (1) manually identifying parallelizable loops is known to be a difficult problem and (2) aspectizing parallelized loops can lead to a reduction in code tangling and an increase in separation of concerns. This paper describes the concepts behind the loop-pointcut problem. It then describes the approach used in this study for implementing a solution in the form of an aspect-oriented Java compiler with a parallelizable loop pointcut. Identifying parallelizable loops is known to be a difficult problem, and as such, this study's parallelizable loop pointcut implements a heuristic solution. The pointcut identifies many parallelizable loops as being parallelizable, but in erring on the side of conservatism, there are some parallelizable loops that the pointcut is unable to identify as parallelizable. To test the parallelizable-loop pointcut, the pointcut was applied to a benchmark set of parallelizable programs. There were two versions of each benchmark program - (1) an aspect-oriented version, where the aspect-oriented compiler's weaver added the multi-threading functionality, and (2) a non-aspect-oriented version, where the benchmark program's source code directly implemented the multi-threading functionality. For each benchmark program, the output from the aspect-oriented version was compared to the output from the non-aspect-oriented version. The study found that each loop that was deemed parallelizable by the aspect-oriented benchmark program was executed in parallel (with multiple threads) by both versions of the program - the aspect-oriented version and the non-aspect-oriented version. There were some loops in the non-aspect-oriented benchmark programs that were deemed parallelizable and executed in parallel, but those same loops were deemed non-parallelizable by their associated aspect-oriented benchmark program. This discrepancy is explained by the study's conservative approach to identifying loops as parallelizable.

<p>In this diploma thesis we have aimed to identify metrics that accommodate two chosen system quality factors and implementing the selected metrics in a metrics tool. The metrics chosen should measure change in the system quality factors reusability and maintainability for the middleware system COS at Telenor Mobile and similar systems. The metrics tool should support the aspect-oriented programming language AspectJ, and is planned to be a plugin to the open source code analysis framework XRadar. Changes due to introduction of aspects are of particular interest.</p><p>We have through a GQM process identified the following subcharacteristics for the chosen system quality factors: modularity, testability, analyzability, changeability and stability. Questions are formulated to analyze these sub factors, and metrics that can answer the questions are chosen.</p><p>We have implemented the tool AspectMetrics, which calculate metrics on Java and AspectJ code and generates an XML report containing the measurement results. A transformation from XML to HTML web pages is also provided. The metrics tool can measure size metrics, like the number of statements and the number of classes, coupling, fan-in/fan-out, cohesion and advice-in/advice-out. Advice-in and advice-out are two new metrics which respectively measures how many advice a class (or aspect) is affected by and how many joinpoints an advice hits on. These metrics are inspired by the concept for the fan-in and fan-out metrics.</p><p>The tool has been used to analyze two versions of the system DIAS v.2.0, which is a part of a diploma study in 2000. We have in our preparation project in 2003 added aspects to the DIAS system while keeping the system functionally equal to the original version. We have used our metrics tool to calculate the differences between the system with and the system without aspects. The introduction of aspects gave a positive change in coupling, fan-in/fan-out and size measures, while cohesion was negatively affected. The metrics thus, overall, indicated a positive change to the subcharacteristics testability, analyzability, changeability and stability and both the main quality factors. There was no indication of a positive change to modularity.</p><p>The analysis of the measurement results indicates that most of the metrics perform as intended. The size metrics, coupling, fan-in/fan-out, and advice-in/advice-out all gave results that corresponded to what we had expected. However, the cohesion measure did not behave in a way that could be correlated to the actual changes performed on the code. A closer analysis showed that moving and merging of functionality could result in either an increase or a decrease in cohesion. Thus we find that cohesion, at least in its current form, is not a suitable metric when using aspect-oriented programming. Further, this gave reason to reinvestigate the disappointing modularity results. With a reworked set of criteria we also found indication of improved modularity.</p>

In this diploma thesis we have aimed to identify metrics that accommodate two chosen system quality factors and implementing the selected metrics in a metrics tool. The metrics chosen should measure change in the system quality factors reusability and maintainability for the middleware system COS at Telenor Mobile and similar systems. The metrics tool should support the aspect-oriented programming language AspectJ, and is planned to be a plugin to the open source code analysis framework XRadar. Changes due to introduction of aspects are of particular interest. We have through a GQM process identified the following subcharacteristics for the chosen system quality factors: modularity, testability, analyzability, changeability and stability. Questions are formulated to analyze these sub factors, and metrics that can answer the questions are chosen. We have implemented the tool AspectMetrics, which calculate metrics on Java and AspectJ code and generates an XML report containing the measurement results. A transformation from XML to HTML web pages is also provided. The metrics tool can measure size metrics, like the number of statements and the number of classes, coupling, fan-in/fan-out, cohesion and advice-in/advice-out. Advice-in and advice-out are two new metrics which respectively measures how many advice a class (or aspect) is affected by and how many joinpoints an advice hits on. These metrics are inspired by the concept for the fan-in and fan-out metrics. The tool has been used to analyze two versions of the system DIAS v.2.0, which is a part of a diploma study in 2000. We have in our preparation project in 2003 added aspects to the DIAS system while keeping the system functionally equal to the original version. We have used our metrics tool to calculate the differences between the system with and the system without aspects. The introduction of aspects gave a positive change in coupling, fan-in/fan-out and size measures, while cohesion was negatively affected. The metrics thus, overall, indicated a positive change to the subcharacteristics testability, analyzability, changeability and stability and both the main quality factors. There was no indication of a positive change to modularity. The analysis of the measurement results indicates that most of the metrics perform as intended. The size metrics, coupling, fan-in/fan-out, and advice-in/advice-out all gave results that corresponded to what we had expected. However, the cohesion measure did not behave in a way that could be correlated to the actual changes performed on the code. A closer analysis showed that moving and merging of functionality could result in either an increase or a decrease in cohesion. Thus we find that cohesion, at least in its current form, is not a suitable metric when using aspect-oriented programming. Further, this gave reason to reinvestigate the disappointing modularity results. With a reworked set of criteria we also found indication of improved modularity.

In recent years, many aspect-oriented languages and methods have been proposed in the literature to support separation of concerns that can be spread throughout a software system and its components and to facilitate post-development and unpredictable system changes in the code of these systems. These languages and methods provide new abstraction and composition mechanisms to deal with some special concerns, which are called cross-cutting concerns. Cross-cutting concerns, by nature, encode structures that represent changes related to many different system modules, and are often difficult to understand. Also, the provision and support for metrics that can give quantitative estimates related to various software quality features had been a challenge. Because of the complexity and intricate relationships with the base code, techniques for more rigorous analysis are crucially needed to check whether, for instance, some aspects are interfering with other aspects in an undesirable way or not behaving according to the systems requirements and expected behaviour. In this thesis we advocate that by extending the metrics and analysis capabilities of current approaches, which are often restricted to code-level evaluations, we can (i) define an approach to analyze aspect-oriented systems based on design and architecture-level quality criteria and metrics, (ii) implement tool support for our approach and (iii) provided experimental support based on case studies indicating the usefulness and impact of the approach.