2008/9/11 Andres Valloud <[EMAIL PROTECTED]>

>
> Acerca del encapsulamiento roto por herencia... que se yo, a mi me da
> la sensacion de que encarar el asunto de programar con el baticinturon
> de la seguridad y el miedo de que se rompan las cosas causa que un
> monton de codigo innecesario aparezca sin contribuir a la solucion del
> problema.


<cowboy coder detector on>

;-)


>   En otras palabras, siento que cosas como final en Java son
> una reaccion externa ante un miedo interno que no necesariamente tiene
> que ver con el problema real.


Los tipos estrictos han sido ampliamente criticados, probablemente las ideas
màs inteligentes son 100 veces màs difìciles en Java que en Smalltalk, sino
basta ver cómo se implementan los proxies en Java y en Smalltalk, en Java al
punto de que los proxies requieren que el compilador sea modificado para que
funcione...

Pero finalmente SUnit fue el procursor de JUnit, de modo que al parecer eso
del baticinturòn es un problema transversal a todos los lenguajes que usan
herencia... (no he escuchado de LispUnit aùn).


>
>
> Lo que a mi juicio sucederia si me dejara controlar por esos miedos es
> que a final de cuentas iria bastante mas lento de lo que ya
> experimente, y no quiero perder la eficiencia que viene con no andar
> sintiendo miedo.


Creo que a la hora de hacer prototipos, sì es mejor olvidarse de los tests.
Pero a veces los tests sorporenden al revès, porque la soluciòn es mucho màs
simple de lo que te imaginabas. Generalmente y sorprentemente eso pasa en
las soluciones a los problemas que se veìan màs complicados, aunque si lo
pensamos un poco, es obvio que asì deberìa ser, porque lo que tenemos es un
problema de apreciaiciòn.

>
>
> Ahora bien, de ahi a programar mal y escribir cualquier cosa... ahi
> creo que vamos a estar de acuerdo de un modo u otro.
>

Esta frase es autoreferente, ¿no?

>
> Andres.


Saludos,
Guillermo.

>
>
>
> 2008/9/11 Hernan Wilkinson <[EMAIL PROTECTED]>:
>  > que tal gente,
> >  perdón que no participé antes... me parece muy interesante la discusión
> y
> > no tengo mucho tiempo para comentar, así que voy a ser escueto y por
> serlo
> > espero no ser aspero
> > 1) Guillermo, no se donde aprendiste objetos pero no es así como lo
> > enseñamos en la UBA. Es verdad que la mayoría de la gente lo enseña como
> > decís o peor. Fijate que en ningún momento hablaste de objeto ni mensaje
> > (como dice Andrés) que es lo más importante.
> > 2) Un trait no es un proxy y viceversa. Por empezar un proxy es un objeto
> > distinto al que proxea y esto no aplica para los traits quienes son
> > utilizados para componer comportamiento. Por ejemplo, un proxy adolece
> del
> > problema del "identidad" mientras que eso ni se puede pensar en un trait.
> > 3) Recalco lo que dice Gabriel, no hay que perder nunca la pata
> conceptual.
> > Conceptualmente trait es distinto de clase y de proxy, representan cosas
> > completamente distintas.
> > 4) No es lo mismo el concepto de trait en Self que en Smalltalk, por eso
> > quizá la confusión con proxy... es así?
> > 5) El encapsulamiento no solo se rompe en la subclasificación por acceder
> a
> > las variables de instancias sino por el hecho de poder redefinir
> > comportamiento o utilizar super, etc. Hacer estas cosas implica saber
> como
> > está implementada la superclase y por lo tanto hace que las clases sean
> > "cajas blancas" y no "cajas negras", por eso se dice que rompe el
> > encapsulamiento....
> > chau chau chau chauuuuu
> >
> > 2008/9/11 Guillermo Schwarz <[EMAIL PROTECTED]>
> >>
> >> Estoy 100% de acuerdo contigo aunque puede que no estés 100% de acuerdo
> >> conmigo... ;-)
> >>
> >> Supongo que el problema es la manera en que se enseña orientación a
> >> objetos:
> >>
> >> OO = Herencia + Encapsulación + Polimorfismo
> >>
> >> Polimorfismo = Herencia + Encapsulación
> >>
> >> => OO = 2 * Polimorfismo
> >>
> >> Luego se enteran que:
> >>
> >> Herencia => ! Encapsulación
> >> Y colapsan.
> >>
> >> Lo que yo haría diferente es explicar a los nuevos estudiantes de OO lo
> >> siguiente:
> >>
> >> 1. El punto está  en que lo que se quiere lograr es el polimorfismo y el
> >> mecanismo para lograr eso podría ser herencia + encapsulación.
> >> 2. Como herencia => ! encapsulación, miremos una alternativa que son los
> >> proxies. ¿Cómo podemos hacer todo con proxies en vez de herencia?
> >>
> >> Entonces la idea de los traits parece una buena idea. Si se usa un
> >> compilador o no ya es otro cuento.
> >>
> >> Saludos,
> >> Guillermo.
> >>
> >> 2008/9/10 Marcelo Cortez <[EMAIL PROTECTED]>
> >>>
> >>> A mi me parece que un traits es un intento de usar mas composicion
> >>> sobre clasificacion , que la la clase puede componerse de varias
> >>> responsabilidades que quedan unida a la clase , en traits /( hasta
> donde se
> >>> ) se descompone ese comportamiento en traits yt luego ese
> comportamiento
> >>> puede ser reutilizado para rehusar ese comportamiento/protocolo en una
> >>> manera mas modular.
> >>> personalemente me agrada pero no se porque tuvo tan poca aceptacion en
> la
> >>> comunidad de squeak ( digo squeak porque es en donde mayormente lei o
> vi
> >>> algo al respecto) ,
> >>> igualmente tiene cierto parecido a mixins ( alguien mas podra
> referenciar
> >>> con mas claridad los papers que apuntan a estas "ideas")
> >>> quizas se deba a que ls herramientas para administrar nunca fueron (
> >>> hasta donde yo se) integradas con exito y eso dificulto el uso y
> aceptacion.
> >>> de la comunidad ( aclaro nuevamente de squeak).
> >>> por eso  la presentacion en smalltalk 2007 de este trabajo que
> mencionaba
> >>> hernan , me soprendio gratamente que me atrveria a recomendar  que no
> se la
> >>> pierdan si pueden.
> >>> lo que tengo entendido de proxy "viene de la parte de patens" y no le
> veo
> >>> tampoco la similutud con traits.
> >>> Ojo mi ignorancia es muy grande asi que no me sorprenderia que alguien
> >>> explique esto traits/proxy con muchisimo mas conicimiento del tema.
> >>> igualmente pienso que estos temas son interesantes y recomiendo que no
> se
> >>> pierdan la charla .y que asistan todos los que puedan a este tipo de
> eventos
> >>> , smalltalk's 2008 , etc.
> >>> saludos
> >>> mdc
> >>>
> >>> 2008/9/10 Gabriel <[EMAIL PROTECTED]>
> >>>>
> >>>> Que significa oversized Proxy?
> >>>> Segun tengo entendido la idea es que un trait sea como un
> "repositorio"
> >>>> de comportamiento compartible entre objetos.
> >>>> Si bien una clase tambien cumpliria este rol, también estaría
> cumpliendo
> >>>> el de "Clase" utilizada para clasificar, o sea el de definir un grupo
> en una
> >>>> taxonomia, en una organizacion de conocimiento (y tambien provee de la
> >>>> implementación del estado de los objetos).
> >>>> Me equivoco? De ser así cuál seria la relación entre trait y  proxy?
> >>>> (pregunto desde mi ignorancia)
> >>>>
> >>>> El 10 de septiembre de 2008 19:49, Guillermo Schwarz
> >>>> <[EMAIL PROTECTED]> escribió:
> >>>>>
> >>>>> y una pregunta, ¿no les parece que Traits no es más que un nombre
> nuevo
> >>>>> para un oversized Proxy?
> >>>>>
> >>>>> No es que esté menospreciando a los Traits, pero me parece
> interesante
> >>>>> que los conceptos sean simplemente aplicar buenos conceptos antiguos
> "más a
> >>>>> fondo"...
> >>>>>
> >>>>> 2008/9/9 Hernan Wilkinson <[EMAIL PROTECTED]>
> >>>>>>
> >>>>>> 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.
> >>>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>>
> >>>>>
> >>>>>
> >>>>>
> >>>>> --
> >>>>> Saludos cordiales,
> >>>>>
> >>>>> Guillermo Schwarz
> >>>>> Sun Certified Enterprise Architect
> >>>>>
> >>>>>
> >>>>
> >>>>
> >>>>
> >>>
> >>>
> >>
> >>
> >>
> >> --
> >> Saludos cordiales,
> >>
> >> Guillermo Schwarz
> >> Sun Certified Enterprise Architect
> >>
> >>
> >
> >
> > >
> >
>
> >
>


-- 
Saludos cordiales,

Guillermo Schwarz
Sun Certified Enterprise Architect

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

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