Si, fue mostrado por Alejandro.

2008/9/9 Marcelo Cortez <[EMAIL PROTECTED]>

> Hernan
>
> Muy interesante , por casualidad no fue mostrado  este trabajo  en
> Smaltalk`s 2007?
> saludos
> MDC
>
> 2008/9/9 Hernan Wilkinson <[EMAIL PROTECTED]>
>
> 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