Abstract
In object oriented languages the problem of crosscutting concerns, due to limitations in the composition mechanisms, is recurrent. In order to reduce this problem we propose to use roles as a way of composing classes that extends the Object Oriented approach and can be used to model crosscutting concerns. To support our approach we developed a role language that extends Java, while being compatible with existing virtual machines. As validation we conducted a case study using three open source systems. We identified crosscutting concerns in the systems and then modeled them using our role approach. Results show that roles are a viable option for modeling crosscutting concerns. Copyright © 2013 ACM.

Abstract
A single decomposition strategy cannot capture all aspects of a concept, so we need to extend Object Oriented Decomposition (today most used strategy). We propose roles as a way to compose classes that provides a modular way of capturing and reusing those concerns that fall outside a concept's main purpose, while being a natural extension of the OO paradigm. Roles have been used successfully to model the different views a concept provides and we want to bring that experience to the programming level. We discuss how to make roles modular and reusable. We also show how to compose classes with roles using JavaStage, our role supporting language. To validate our approach we developed generic and reusable roles for the Gang of Four patterns. We developed reusable roles for 10 out of 23 patterns. We also were able to use some of these roles in JHotDraw framework.

Abstract
The existence of replicated code in a system makes that system harder to maintain and evolve. To remove replicated code the usual way is to use refactorings. However there are always clones that cannot be removed by refactorings alone. Some are due to lack of composition mechanisms in the underlying programming language. We propose the use of roles to remove such clones since roles provide a finer degree of composition. We sketch four role refactorings to remove code clones and apply them in a case study using the JHotDraw framework. Results show that roles have a positive impact in clone reduction as they were able to remove almost all clones traditional refactorings could not. © 2013 IEEE.

Abstract
The presence of code replication can be a consequence of a lack in the composition mechanisms where classes are insufficient to reuse the code that is replicated. To extend the reuse of pieces of code some proposals have been made that try to compose classes using those pieces of code. In this paper we compare two of those approaches: Traits and Roles. We compare their compositions mechanisms and how we can use them to reduce code replication. To study the extent to which they reduce code replication we conducted a case study using the JHotDraw framework where we detect and remove code replication using each technique. Results from the case study show that roles have an advantage over traits, as they are capable of removing more code replication.

Abstract
Code replication has significant drawbacks in system maintenance. Code replication can have its origins in the composition limitations of the language. Several proposals have tried to overcome these limitations. A popular one is traits. However, traits do not support state or visibility control. Static roles are also a way of composing classes that has the benefits of traits and offers state, visibility control and other advantages as block renaming. We compare both approaches on how they are used to compose classes, and how they can be used to reduce code replication caused by composition limitations. As a case study we will compare how both approaches can reduce code replication by detecting and removing code clones within the JHotDraw framework. Results show that roles are capable of reducing a larger amount of replicated code than traits.

Abstract