Que tal,
 el miércoles 17 de Septiembre a las 10 hrs. (aula a determinar), Alejandro
Gonzalez presentará su trabajo de Tesis de Licenciatura que trata sobre el
estudio e implementación de "Refactorings para Traits".
 El mismo se basó en realizar cambios a jerarquías de clases existentes
utilizando un nuevo elemento de representación de conocimiento denominado
Trait (o Rasgo en castellano). Al ir realizando estos cambios se tomó nota
de aquellos procesos comunes que pudiesen ser creados como Refactorings,
para luego implementarlos como tal.
 El trabajo se realizó con Squeak (una implementación open source de
Smalltalk) y se amplió la funcionalidad del Refactoring Browser. El mismo se
encuentra disponible para ser utilizado en SqueakSource.

 Esta es la primer presentación de un conjunto de tesis que tratan sobre la
utilización de Traits en ambientes de objetos que utilizan clasificación
como metodología de representación de conocimiento. El resto de los trabajos
se irán presentando en los próximos meses.
 El jurado estará compuesto por Máximo Prieto, Gabriela Arévalo y Hernán
Wilkinson.

 A continuación se adjunta un resumen:
---
Traits es un nuevo concepto para estructurar programas orientados a objetos.
Este concepto, permite que el comportamiento total de una clase pueda ser
construido
composicionalmente a partir de pequeños rasgos de comportamientos llamados
traits.

Traits complementa a la herencia simple y es por esto,
que su inclusión conlleva la necesidad de querer refactorizar nuestros
diseños,
ya que con ellos ahora se pueden resolver cuestiones antes no resueltas, o
mal resueltas, por la herencia.
En particular, aquellas jerarquías cuestionadas por hacer un fuerte uso de
la herencia
como único mecanismo para compartir comportamiento, son las que se
convierten en candidatas a ser refactorizadas con traits.
Pero estas refactorizaciones no pueden ser realizadas eficientemente sin la
asistencia de una herramienta apropiada.

Muchos ambientes de desarrollo incluyen herramientas para refactorizar
código.
Éstas soportan, a menudo, refactorings típicos que pueden realizarse en
forma semi-automática,
como por ejemplo Push up method y Rename method.
El problema es que, éstas operan sobre conceptos conocidos del paradigma:
jerarquía de clases, métodos, variables de instancia, etc.
Actualmente, ninguna brinda soporte para la refactorización con este nuevo
concepto, traits.

En este trabajo se investigan, tanto desde un punto de vista conceptual como
implementativo, nuevos refactorings para traits.
El resultado es un nuevo conjunto de operaciones de refactorings que,
inicialmente surgieron de ideas básicas y operaciones típicas al programar
con traits,
pero que luego fueron refinándose a medida que las comenzamos a utilizar
para realizar diferentes refactorizaciones.

Estos nuevos refactorings se implementaron en Squeak, un dialecto
open-source de Smalltalk,
dado que éste es el único ambiente que incluye una implementación sólida de
ambos,
el nuevo concepto de traits y una herramienta de refactorings conocida como
refactoring browser.
------------------------------------------------------------------------------------------------------------
Abstract:
---------
Traits is a new concept for structuring object-oriented programs.
This concept allows us to build the whole behavior of a class by composing
it from small building blocks of behaviors, called traits.

Traits complement single inheritance,
thus their inclusion creates the need for a re-design of our applications,
since with them we can now solve design issues that were not solved, or
 improperly solved, by using single inheritance.
Particularly, those hierarchies criticized for a strong use of the
inheritance as the only mechanism to share behavior,
become candidates to be refactored towards traits.
However, these refactorings cannot be efficiently addressed without the
assistance of appropriated tools.

Most development environments include tools to refactor code.
These tools support typical refactorings that can be applied
semi-automatically,
such as Push up method and Rename method.
The problem is that these tools work on well known concepts of the paradigm:
class hierarchies, methods, instance variables, etc.
Currently, none of them give support for a refactorization towards this new
concept, traits.

In this work we investigate, from both a conceptual and an implementative
point of view, new trait's refactorings.
The outcome is a new set of refactoring operations that
initially came up from basic ideas and typical operations when working with
traits,
but then were polished as we use them to perform some refactorings.

These refactorings were implemented in Squeak, an open-source Smalltalk
dialect,
since it's the only environment which includes a solid implementation of
both,
the traits concept and a refactoring tool called refactoring browser.
-------------

 Saludos,
 Hernán.

--~--~---------~--~----~------------~-------~--~----~

To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]

http://www.clubSmalltalk.org
-~----------~----~----~----~------~----~------~--~---

Responder a