One of the main promises of aspect-oriented programming (AOP) is to promote improved modularization of crosscutting concerns, thereby enhancing the software stability in the presence of changes. This paper presents a quantitative study that assesses the positive and negative effects of AOP on typical maintenance activities of a Web information system. The study consists of a systematic comparison between the object-oriented and the aspect-oriented versions of the same application in order to assess to what extent each solution provides maintainable software decompositions. Our analysis was driven by fundamental modularity attributes, such as coupling, cohesion, conciseness, and separation of concerns. We have found that the aspect-oriented design has exhibited superior stability and reusability through the changes, as it has resulted in fewer lines of code, improved separation of concerns, weaker coupling, and lower intra-component complexity. 1.

Information systems based on the World Wide Web increased the impact of concurrent programs. Such increase demands the definition of methods for obtaining safe and efficient implementations of concurrent programs, since the complexity of implementation and tests in concurrent environments is bigger than in sequential environments. This work defined guidelines to restructure object-oriented software in order to modularize concurrency control using aspect-oriented programming. Those guidelines are supported by a concurrency control implementation that guarantees system correctness without redundant concurrency control, both increasing performance and guaranteeing safety. We define abstract aspects that constitute a simple aspect framework that can be reused to implement concurrency control in other applications. The achieved modularization makes the concurrency control easy to evolve and decreases the complexity of other parts of the software, such as business and data management modules, by decoupling concurrency control code from them. Categories and Subject Descriptors

This is a preprint of a paper that is submitted for publication.

When using Aspect-Oriented Programming, it is sometimes difficult to determine at which join point an aspect will execute. Similarly, when considering one join point, knowing which aspects will execute there and in what order is nontrivial. This makes it difficult to understand how the application will behave. A number of visualization tools have been proposed that attempt to provide support for such program understanding. However, they neither scale up to large code bases nor scale down to understanding what happens at a single join point. In this paper, we present AspectMaps – a visualization that does scale in both directions, thanks to a multi-level selective structural zoom. We show how the use of AspectMaps allows for program understanding of code with aspects, revealing both a wealth of information of what can happen at one particular join point as well as allowing to see the “big picture ” on a larger code base. This paper makes heavy use of colors in the figures. Please obtain and read a color version of this paper to better understand the ideas presented here. 1.

Este trabalho foi apresentado à Pós-graduação em

Abstract. Aspect Oriented Programming (AOP) is becoming increasingly accepted as an approach to deal with crosscutting concerns in software development. However, AOP is known to raise software integrity issues. For example, join point shadows may easily omit crucial join points or include inappropriate ones. In this paper, we propose an extensible framework called CIF that constrains aspect-oriented software design and composition with the intent to maintain the integrity of the final composed system. CIF controls the composition of aspects and the base application in three dimensions: where the composition occurs, how the composition is carried out and what exactly is being composed. The framework is intended to be used in a team-based software development environment. We demonstrate the applicability of the framework through an application case study. 1

Abstract not found

Software engineers often rely on communication middleware platforms to design and implement distributed systems. However, middleware functionality is usually invasive, pervasive and tangled with business-specific concerns. In this paper, we describe an aspect-oriented distributed programming system that encapsulates middleware services provided by Java RMI and Java IDL. The proposed system, called DAJ, handles the basic service provided by such object-oriented middleware platforms, i.e., synchronous remote calls using call by-serialization and call by-remote-reference semantics. The paper documents our experience in using DAJ to modularize middleware concerns from three legacy distributed systems.

Object remoting middleware greatly facilitates creating distributed, object-oriented systems. However, developers face many situations in which a middleware’s invocation and message processing architecture fails to fully support all their requirements. This problem is caused, for instance, by limitations in realising certain invocation styles (e.g., one-way and two-way conversations) on top of a shared processing infrastructure, in adding extensions to invocation handling (i.e., add-on services such as security and inspection), and in bypassing selected steps in the invocation handling to balance resource consumption and invocation performance. Often, these limitations are caused by design and implementation decisions taken early when crafting the middleware framework. To better explain the needed decision making, and help developers to apply adaptations or guide the selection of alternatives, we present a pattern language that captures the essentials of invocation and message processing in object remoting middleware. We also outline instantiations of the patterns and their relationships in existing middleware frameworks. Evans ’ improved mill [22, Plate VIII] advanced the automation of pre-industrial further processing and refinement of wheat into flour. It is commonly regarded as an early predecessor of Fordist and more recent assembly line or production flow systems [44]. Copyright retain by author(s). Permission granted to Hillside Europe for inclusion in the CEUR archive of conference proceedings and for Hillside Europe website F3 – 1 1