Archive for the ‘Programación Orientada a Objetos’ Category

Podés estar seguro que no entendiste el Proceso Unificado cuando…

Posted on the agosto 14th, 2008 under Proceso Unificado,Programación Orientada a Objetos by

Un extracto del Libro de Larman (Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development, Third Edition) mientras termino un post donde resumimos largas charlas presenciales y virtuales con Milton acerca de las metodologías para el desarrollo de software.

2.13. You Know You Didn’t Understand Iterative Development or the UP When…

Here are some signs that you have not understood what it means to adopt iterative development and the UP in a healthy agile spirit.

  • You try to define most of the requirements before starting design or implementation. Similarly, you try to define most of the design before starting implementation; you try to fully define and commit to an architecture before iterative programming and testing.
  • You spend days or weeks in UML modeling before programming, or you think UML diagramming and design activities are a time to fully and accurately define designs and models in great detail. And you regard programming as a simple mechanical translation of these into code.
  • You think that inception = requirements, elaboration = design, and construction = implementation (that is, superimposing the waterfall on the UP).
  • You think that the purpose of elaboration is to fully and carefully define models, which are translated into code during construction.
  • You believe that a suitable iteration length is three months long, rather than three weeks long.
  • You think that adopting the UP means to do many of the possible activities and create many documents, and you think of or experience the UP as a formal, fussy process with many steps to be followed.
  • You try to plan a project in detail from start to finish; you try to speculatively predict all the iterations, and what should happen in each one.

Destaco por ahora la ante última oración para los detractores y que dicen que es poco ágil.

Más información acerca del UP, Rational UP, y otras “instancias” del UP.

http://www.agilemodeling.com/essays/agileModelingRUP.htm

Desarrollo con Mono (.Net) en varios lenguajes – parte 1

Posted on the marzo 5th, 2008 under Código Experimental,GNU/Linux,Investigación,Probando herramientas,Programación Orientada a Objetos,Software Libre by

Para la cátedra de Administración de Recursos el año pasado, debíamos realizar un trabajo de investigación y desarrollo, en el cuál se mostraran nuevas tecnologías que permitieran integrar sistemas. Buscando cumplir con el objetivo asignado por la cátedra y a la vez investigar en algo que aún no hubiéramos profundizado fue lo que nos llevó a la plataforma Mono.

Milton ya estaba desarrollando un sistema utilizando esta plataforma, César ya había programado con .Net (C# y VB.Net) para un TP anterior y yo algo de Web Services ya había utilizado (consumido con PHP, pero nunca creado) y además estaba usando C# para algunas cosas.

Sin embargo queríamos probar la madurez del proyecto Mono, utilizar las últimas versiones de MonoDevelop como IDE y las librerías y compiladores que pudieramos. Se nos ocurrió implementar un sistema de mensajería instantánea al estilo Gaim, obviamente que con la única posibilidad de enviar mensajes de texto y ver la lista de usuarios conectados. Pero, a medida que avanzabamos, le ibamos agregando cosas.

Smalltalk Express corriendo con Wine (de nuevo)

Posted on the marzo 4th, 2008 under GNU/Linux,Smalltalk by

ste-transcript-mini.jpgRecuerdo que el último trabajo práctico que realicé en Smalltalk fue cuando ya no utilizaba Windows como sistema operativo. Estaba utilizando Debian GNU/Linux en ese momento y pensando en pasarme a Ubuntu, debido a su frecuente actualización de paquetes y una comunidad creciente detrás. Esto fue en el año 2005, creo que con la versión Dapper. Para mi sorpresa, habiendo decidido implementar dicho trabajo práctico en Smalltalk y usar STE (Smalltalk Express) que ya conocíamos le ambiente todos los integrantes, se me ocurrió probarlo con Wine. Anduvo perfecto! O casi… Algunas cositas como copiar y pegar no funcionaban del todo bien. Quizá se debiera a que es una aplicación de 16 bits.

Pasaron 2 años, y quisé abrir nuevamente una instancia de STE y la mayoría de las pantallas creadas con WindowBuilder tenían un fondo negro, y no se identificaban los controles. Sin embargo el resto del sistema, Transcript, el Browser de Classes y otras básicas andaban ok.

Intenté volver a esa versión de Wine, sin éxito. Probé con varias configuraciones y no había caso. Probé en una máquina virtual con Dapper y ahí funcionó bien!. Justo cuando me decidía a postear en Wine que con versiones posteriores había dejado de funcionar algo, con la última actualización de a la versión 0.9.55 ¡volvió a funcionar! ¡Y mejor! (al momento de escribir el artículo era la 0.9.55, pero con la 0.9.56 sigue funcionando)

Les dejo un repositorio para tener la versión más actualizada de Wine en su distro sin tener que compilar o andar buscando (usando apt).
En un archivo nuevo (para tener separado del resto de los repositorios)

sudo vim /etc/sources.list.d/winehq.list

Agregar las siguientes lineas

deb http://wine.budgetdedicated.com/apt gutsy main #WineHQ - Ubuntu 7.10 "Gutsy Gibbon"
deb-src http://wine.budgetdedicated.com/apt gutsy main #WineHQ - Ubuntu 7.10 "Gutsy Gibbon"

Para agregar la clave

wget -q http://wine.budgetdedicated.com/apt/387EE263.gpg -O- | sudo apt-key add -

Luego con un apt-get update van a tener las listas actualizadas para poder instalar la última versión de Wine.

Para ejecutarlo, probé con varias configuraciones de Wine (Win98, Windows XP, etc) y funcionó perfecto. Lo que hay que tener en cuenta es que debe encontrarse en un directorio que no tenga espacios en todo el path, y debe ser ejecutado desde una consola mediante

wine VW.EXE

Algunas capturas de STE bajo Wine

smalltalk-ide-450.jpg

window-builder.jpg

Pequeñas ayudas para la programación en Smalltalk (Express)

Posted on the marzo 4th, 2008 under Investigación,Programación Orientada a Objetos,Smalltalk by

Este texto es la junta de varios post por separado que tenía en borrador y que decidí postearlos todos juntos. Creo que así es más sencillo de ubicar y poder agregar otros luego. Son algunas cosas que observé o hice cada vez que tuve algún tiempo con Smalltalk. Acá van 😛

Escondiendo el Transcript en Smalltalk Express

El Transcript que utilizamos para trabajar es un workspace. Este objeto viene por defecto “vivo” en el entorno de Smalltalk Express. Se lo puede cerrar enviándole el mensaje close al mismo (a través de la variable global Transcript).
El método “esconderTranscript” podría ser implementado en la ventana principal de la aplicación, para poder esconder el Transcript una vez que no lo necesitemos.

1
2
3
esconderTranscript
    Transcript close.
    Transcript := nil.

Lo que si, una vez cerrado, ¿cómo volvemos a abrirlo? ¿a quién le enviamos un mensaje? MDITranscript es la clase responsable de la inicialización del mismo. O sea, deberíamos tener alguna manera siempre de poder hacer un “do it” sobre alguna ventana para poder volver a mostrar el Transcript.
El método “mostrarTranscript” podría ser implementado en la ventana principal de la aplicación, para poder esconder el Transcript una vez que no lo necesitemos.

1
2
3
mostrarTranscript
    (Transcript = nil) ifFalse: [Transcript close.].
    Transcript := MDITranscript initializeTranscript.

transcript-show-hide.png

Serializando Objetos en Smalltalk

Con la clase ObjectFiler podemos guardar una representación binaria de nuestro objeto en un archivo en el disco. De esta manera, si nuestro objeto tiene referencias a otros objetos (haya ciclos o no), estos serán serializados también. Esto nos permitiría poder guardar los datos de nuestra aplicación en un archivo en vez de usar la imagen de Smalltalk. Por ejemplo el método guardar a continuación, está serializando el objeto referenciado por la variable Instancia.

1
2
guardar
    ObjectFiler dump: Instancia.

Si queremos recuperarlo desde el disco, bastará con tener implementado algún método que utilice el ObjetFiler de la siguiente manera:

1
2
cargar
    Instancia := ObjectFiler load.

Aclaración: Para poder reconstruir el objeto es necesario que las clases que definen su estructura se encuentren cargadas en el entorno.

smalltalk-load-filer.png

Cambiando la forma en que el Inspector nos ve en Smalltalk

Cuando hacemos un inspect de un objeto generalmente si tiene referencias a otros objetos vemos que la representación textual de estas referencias dice “anObjeto”, “aSystem”, “aTalCosa”. Esto es además de un poco molesto, incómodo si se desea hacer un debug rápido y saber de que objeto se está hablando. Para esto, podemos reeimplementar en nuestra clase el método “printOnStream”, que es el que se ejecuta cuando el objeto recibe el mensaje con el mismo nombre desde el Inspector. ¿Cómo lo reimplementamos? Le podemos agregar a esa salida algún valor clave que identifique a nuestro objeto, o lo que necesitemos ver en un inspect típico conservando quizá el a y an object agregados.

1
2
3
4
5
6
7
8
9
10
printOn: aStream
        "Agregaremos el DNI de la persona y delegaremos el
         resto a la implementación de la clase Object"
    | aString |
    "aquí le pedimos el DNI y lo guardamos en aString.
     Además le concateno una barra para separarlo luego
     de la salida por defecto de la clase Object "
    aString := (self getTitulo) , ' / '.
    aStream nextPutAll: aString.
    super printOn: aStream.

La implementación original en la clase Object:

1
2
3
4
5
6
7
8
9
10
11
12
printOn: aStream
        "Append the ASCII representation of the receiver
         to aStream.  This is the default implementation which
         prints 'a' ('an') followed by the receiver class name."
    | aString |
    aString := self class name.
 "debido a las reglas del inglés, si comienza con vocal se antepone 'an'
y sino 'a'. Ej anObject (en castellano sería unObjeto)"
   (aString at: 1) isVowel
        ifTrue: [aStream nextPutAll: 'an ']
        ifFalse: [aStream nextPutAll: 'a '].
    aStream nextPutAll: aString

smalltalk-inspector.png

Exportando/Importando clases de Smalltalk

Para exportar desde el Transcript una clase de Smalltalk, podemos usar la clase ClassReader. El método forClass, instancia un ClassReader para una determinada clase. Esto es, si tenemos una clase Persona, obtendremos la instancia con

1
ClassReader forClass: Persona

A este objeto le podemos enviar el mensaje fileOutOn: file, donde file es una instancia de File.
Para esto, en un TP que implementamos hace un tiempo, creamos una clase ABackUp, para exportar de forma sencilla todas las clases de nuestro sistema en un solo archivo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
Object subclass: #ABackUp
  instanceVariableNames: ''
  classVariableNames:
    'LasClases '
  poolDictionaries: ''  !
!ABackUp class methods !
backup
|  reader      file |
ABackUp inicializar.
file := File newFile: 'export\backup.cls'.
    LasClases do: [:c |
        c fileOutOn: file.
        file nextChunkPut: String new.
        (ClassReader forClass: c class) fileOutOn: file.
        (ClassReader forClass: c) fileOutOn: file ].
    file close.!
inicializar
LasClases := OrderedCollection new.
" Carga de las clases a backupear "
LasClases
    add: Articulo;
    add: ArticuloDB;
    add: ArticuloEstado.    LasClases := (LasClases,ArticuloEstado allSubclasses).
LasClases
    add: ComunidadCientificaDB;
    add: Congreso;
    add: CongresoDB;
    add: PanelArbitros;
    add: Persona;
    add: Recibo;
    add: Reporte;
    add: Simposio;
    add: SistemaCongreso;
    add: Principal;
    add: AsignarCalificacionJuez;
    add: AsignarJuez;
    add: CrearCongreso;
    add: NuevoSimposio;
    add: RanckingArticulos;
    add: RegistrarAutor;
    add: RegistrarJuez;
    add: RegistrarPersona;
    add: SubirArticulo;
    add: Rol.  LasClases := (LasClases,Rol allSubclasses).
    LasClases add: ABackUp.!
 
new
    ^super new inicializar.! !
 
!ABackUp methods ! !

Cada vez que creábamos una clase nueva la agregábamos en la implementación del método “inicializar”. Se podría haber realizado de otra forma, algo más automático o dinámico, como ser las clases utilizadas, pero esta fue la solución más rápida.
Luego desde el Transcript, haciendo un “do it” sobre “ABackUp backup.”, obtenemos una serialización de las mismas en un archivo de texto.

Esto es todo por ahora. Si alguno tiene algo que quiera aportar y quiera que agregue en este mini artículo, coméntelo o me lo manda por email que lo agrego. Nos vemos en el próximo. 🙂

Parche para más de 256 colores (> 8 bits) Smalltalk Express

Posted on the febrero 9th, 2008 under Smalltalk by

A muchos no les anduvo (o les cansó) trabajar en Smalltalk con la configuración de base, que no permite tener un modo de pantalla con más de 256 colores. Con este parche correrá tanto en 16 o 24 bits (16535 o 16 millones de colores).

Para instalar el Parche para Smalltalk Express:

  1. Instalar el SE teniendo la PC en modo 8 bits 256 colores.
  2. Luego instalar el parche
    1. File (o archivo)/Install (o instalar)
    2. Buscar el archivo install.st
    3. Si todo salió bien seguir con el otro paso, sino instalar el parche nuevamente.
  3. Salvar la imagen y salir de SE.
  4. Cambiar a la configuración de color que usas habitualmente (seguro 24 o 32 bits)
  5. Iniciar nuevamente el SE.

Voy a ver si encuentro la licencia de Smalltalk Express y ver si me permite hacer pública una imagen de la VM ya parcheada y limpia (como viene de base).

Espero que esto les facilite la búsqueda!

De paso les dejo unos links con mucha información de Smalltalk

Grupo de Usuarios de Yahoo! de Smalltalking.net
http://ar.groups.yahoo.com/group/smalltalking

El parche
http://www.smalltalking.net/Goodies/Express/Files/SmalltalkExpress.zip

Smalltalk para .Net
http://www.refactory.com/Software/SharpSmalltalk/

Noticias de Smalltalk
http://www.smalltalk.org/