libro smalltalk

Sin embargo, este libro no pretende ser un manual bsico y de aprendizaje de Smalltalk, para eso ya existen manuales de calidad en el mercado a los que hacemos referencia en esta misma obra. El objetivo del autor al escribir este manual ha sido el de mostrar la losofa inherente a Smalltalk, la manera en que sta impacta en la creacin de software y, a su vez, cmo esta forma de trabajar genera software de mayor calidad en menos tiempo que con otras herramientas. Desarrollaremos paso a paso algunas aplicaciones de ejemplo para mostrar cmo se trabaja en un ambiente de objetos e iremos introduciendo conceptos y descripciones conforme lo vayamos necesitando.ISBN 84934371-3-1

Programando con

Smalltalk

El ambiente de Smalltalk est compuesto por un extenso grupo de objetos. En Smalltalk TODO es un objeto y TODO es modicable. Y es esta versatilidad la que le permite mejorar dos aspectos claves en el objetivo del desarrollo del software: el aumento de la productividad y generar software de calidad. Con Smalltalk esto es posible y convierte la programacin en un proceso mucho ms interactivo que el clsico ciclo edicin/compilacin/ejecucin.

Bienvenidos al mundo fascinante de Smalltalk!9

Programando con

por Diego Gmez Deck

R

esulta muy complicado explicar qu es Smalltalk en toda su dimensin. Smalltalk es considerado el primer lenguaje de programacin orientado a objetos. Sin embargo, es mucho ms que un mero lenguaje, Smalltalk es un ambiente completo de desarrollo con varios miles de clases y mtodos.

788493 437138

La ilustracin de la portada est basada en la obra The computer language Smalltalk que Robert Tinney realiz para la portada de la revista BYTE (agosto, 1981).

SmalltalkUn ambiente de objetos vivos

Avda. Portugal, 85-local 28011 Madrid Tlf.: 91 577 03 55/18 Fax.: 91 577 06 18

A todos aquellos que saben que la verdadera revolucin de la informacin no ocurrir hasta que seamos capaces de romper unas cuantas barreras

Disculpen mi falta de originalidad, pero tengo que agradecer especialmente a mi ncleo familiar por el soporte y comprensin que me han brindado. Mil gracias a mi compaera de viaje Raquel y a mis hijos Nicols y Nahuel; ellos son los que realmente han hecho sacricios para que este libro llegue a buen trmino.

Autor: DIEGO GMEZ DECK Responsable editorial: SORAYA MUOZ Responsable de Marketing y Comunicacin: LVARO GARCA Diseo y maquetacin: CARLOS MONTES ISBN: 978-84-934371-3-8 Depsito Legal: Edita: EDIT LIN EDITORIAL, S.L, 2006 Avda. Portugal, 85- local 28011 Madrid (Espaa) Tels.:91 577 03 55 Fax: 91 577 06 18 www.librosdelinux.com [email protected] LICENCIA Se permite la copia y distribucin de la totalidad o parte de esta obra sin nimo de lucro. Toda copia total o parcial deber citar expresamente el nombre del autor, nombre de la editorial e incluir esta misma licencia, aadiendo, si es copia literal, la mencin copia literal. Se autoriza la modicacin y traduccin de la obra sin nimo de lucro siempre que se haga constar en la obra resultante de la modicacin el nombre de la obra originaria, el autor de la obra originaria y el nombre de la editorial. La obra resultante tambin ser libremente reproducida, distribuida, comunicada al pblico y transformada en trminos similares a los expresados en esta licencia. Impreso en Espaa (Printed in Spain)*Este libro ha sido realizado con Software Libre, concretamente con: Squeak, OpenOfce.org, Evolution, Mozilla, GIMP.

PRLOGO

S

7

ndiceIntroduccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Enfoque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Metodologa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Alcance del libro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Audiencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Licencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sitio web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Captulo 1. Qu es Smalltalk? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.1 Conceptos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mensajes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Interfaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encapsulacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variables de Instancia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mtodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Programar es simular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Historia del Smalltalk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Aportes del Smalltalk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Qu es Squeak? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Captulo 2. Programando con Smalltalk. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2. 1 La curva de aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Prepararse para un shock cultural . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tirar cdigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Trabajo incremental . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . No hay archivos fuentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 El camino es largo, mejor no ir solo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4 Sintaxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Literales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mensajes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

prologo

S

8

S

9

Precedencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cascading messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Los nombres de clases son, tambin, variables globales . . . . . . . . . . . . . . . . . . . . . . . . Bloques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mtodo de Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.5 Herramientas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6 Librera de Clases y Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.7 Mquina Virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Captulo 3. Manos a la Obra! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1 Modificando Objetos Vivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . El Mundo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Browser de Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tipos de Browser de Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Categoras de Clase y Mtodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Squeak y el Ratn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Foco de teclado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workspace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tipos de Workspace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Evaluando Cdigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sentencias de Ejemplo para evaluar, imprimir, inspeccionar o explorar . . . . . . . . . . Inspector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hot-Keys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Parser de XML basado en una Pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Smalltalk con Estilo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . NombreDeClase>>nombreDeMtodo 3.3 Importador de Wikipedia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Wikipedia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mtodos de Clase vs. Mtodos de Instancia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Plantilla para nuevos mtodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Archivos de ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pre-Depurador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Depurador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Depurador 100% en Smalltalk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Convencin de nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Valor de retorno por defecto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones mensaje #add: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Explorador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones OrderedCollection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inicializacin de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MessageTally TimeProfilerBrowser

3.4 Motor de Workflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Test Driven Development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SUnit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring Browser. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Los mtodos de testing comienzan por #test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Consejo: Pensar primero en la interfaz pblica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Estructura de los test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SUnit Test Runner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones mensaje #collect: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Consejo: Es ms barato escribir cdigo limpio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Explaining Temporary Variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones mensaje #, . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Consejo: Probar las situaciones lmite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mensaje #halt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Consejo El depurador nos brinda ms informacin a la hora de implementar. . . Colecciones mensaje #includes:. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Senders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Los tests son, tambin, documentacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones mensaje #anySatisfy: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Composed Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Los tests aumentan la confianza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones mensaje #select:thenCollect: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones mensaje #select: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones mensaje #at:ifAbsentPut: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Colecciones Dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Transcript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Patrn de Diseo Adapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mtodos privados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Browser Jerrquico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Usar el fuente de un mtodo para crear otro mtodo parecido . . . . . . . . . . . . . . . . . Mensaje #subclassResponsibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Captulo 4. La yapa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1 Mensaje #become: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Mensaje #doesNotUnderstand: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Mensajes #perform:, #perform:with:, #perform:withAll:, etc. . . . . . . . . . . . . . . . . . . . . 4.4 Pseudo-variable thisContext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5 SLang, mquina virtual y plugins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6 FFI Foreign Function Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.7 Metaprogramacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.8 Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9 SqueakMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.10 MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.11 Morphic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.12 Algunos proyectos con Squeak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

S

10

S

11

Captulo 5. Futuroa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1 Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Tweak . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 64 bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4 OpenCroquet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Cmo continuara.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Libros Papers o artculos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Grupos de Usuarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conclusin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Apndices Bibliografa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Herramientas usadas en el libro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Introduccin Smalltalk es mucho ms que un lenguaje de programacin. Se trata del resultado de un proceso de investigacin y desarrollo, liderado por Alan Kay, que ya lleva ms de 30 aos tratando de inventar el ordenador personal. Smalltalk, adems de ser un lenguaje de programacin muy poderoso y verstil, es una interpretacin de cmo deberan utilizarse los ordenadores, ya que estos deberan ser herramientas para amplicar el espritu creativo de las personas. Smalltalk no es la culminacin de esa visin, es slo un paso. Pero si tiene un objetivo en s mismo, se es el de servir como instrumento para crear la herramienta que vuelva obsoleto al mismo Smalltalk. Lamentablemente, las ideas que subyacen de Smalltalk no son las ms extendidas en el mundo de la informtica, y aunque muchas innovaciones del proyecto han perdurado hasta nuestros das, stas han llegado despojadas de lo fundamental, adquirindose slo la parte ms supercial de las ideas. Este hecho ha provocado que la primera experiencia o toma de contacto con Smalltalk sea negativa y desconcertante, incluso para una persona ya acostumbrada al manejo de ordenadores y con conocimientos de programacin. No obstante, el esfuerzo de entrar en un rea desconocido tiene su recompensa. Muchos, entre ellos nuestro autor, son los que sienten que Smalltalk les ha devuelto la fascinacin que les produjo usar un ordenador por primera vez. No es extrao ver cmo gente que comienza a programar, gracias a Smalltalk cambia su concepcin de los fundamentos de los ordenadores. Prcticamente, todos los programadores de Smalltalk utilizan el entorno no slo para trabajar y producir software, sino tambin como una herramienta de investigacin. Resulta muy comn, por tanto, encontrar proyectos muy peculiares e innovadores desarrollados con Smalltalk porque, justamente, este entorno sirve como amplicador del espritu creativo que todos llevamos dentro.

S

13

Programando con

SmalltalkEnfoque

Alcance del libro Este libro no es una gua completa de Smalltalk, slo pretende mostrar la losofa de uso del entorno y servir de referencia para nuevos usuarios de Smalltalk. La mayora de las respuestas a las preguntas que nos hacemos cuando programamos en este entorno, estn dentro del mismo Smalltalk. Por esta razn, esta documentacin pretende ensearnos a buscar esas respuestas en el entorno, en lugar de contestarlas directamente. En el apndice dedicado a la bibliografa, el autor ha incluido un listado de referencias de manuales sobre Smalltalk que pueden servir como complemento a este libro. Algunos de esos ttulos pueden ser descargados gratuitamente de Internet.

Este libro pretende mostrar a personas con algunos conocimientos de programacin, cmo el hecho de vivir en un ambiente de objetos impacta sobre el ciclo de desarrollo del software. La programacin con Smalltalk es muy diferente al clsico ciclo edicin/compilacin/ejecucin que predomina sobre la mayora de las herramientas usadas hoy en da, ya que con este entorno se da un proceso mucho ms interactivo. De esta manera, no se penaliza la investigacin ni se castiga de manera ms fuerte las primeras decisiones. Al minimizar el costo de los cambios, se pueden posponer las decisiones ms importantes del diseo hasta el momento en que tengamos los conocimientos lo sucientes. Esto es, en Smalltalk se promueve un mtodo de desarrollo donde el software se modica conforme se va generando. Esta obra pretende mostrar una parte de todo ese proceso, para lo que desarrollaremos algunas aplicaciones de ejemplo paso a paso e iremos introduciendo conceptos, descripciones, etc. conforme lo vayamos necesitando. Bien, estos casos prcticos nos servirn de excusa para mostrar el uso del entorno de Smalltalk, no son objetivos en s mismos y no se van a desarrollar al 100%. Metodologa Aunque todos los programadores Smalltalk comparten ciertas costumbres, cada uno lo congura y utiliza de forma diferente, ya que programar en este entorno se convierte en tarea muy personal, puesto que no olvidemos que ha nacido como la concepcin del ordenador personal. En este manual el autor nos va a mostrar cmo usa l el entorno, lo que no quiere decir que sea la nica o mejor manera de trabajar en Smalltalk. Del mismo modo, tampoco pretende imponer su forma de trabajo ni nada parecido, desea que cada uno de nosotros hagamos uso de Smalltalk de la forma que ms nos guste, y que compartamos con la comunidad las mejoras que consigamos en nuestros entornos. Probablemente, reconoceremos algunos aspectos de las, ahora denominadas, metodologas ligeras. Bien, esto no debera extraarnos, ya que la principal metodologa gil, que es la Extremme Programming (Programacin Extrema), se formaliz en un proyecto desarrollado con Smalltalk, del que Kent Beck formaba parte.

Audiencia El libro que el lector tiene en sus manos no pretende ser una gua para aprender a programar desde cero, sino que se presupone que el lector tiene conocimientos bsicos de programacin, incluso, que est familiarizado con los conceptos de la programacin orientada a objetos. Por tanto, este manual pretende ser la referencia para programadores que estn buscando nuevas y mejores formas de producir software y que vean en Smalltalk una opcin alternativa y vlida. Es ms, aunque no se tenga la oportunidad de usar Smalltalk en el da a da, conocer este entorno y el paradigma de objetos tal cual fue creado, les convertir en mejores programadores. Licencia Hemos pretendido ser eles al ideal de libertad que rigi el desarrollo del proyecto Smalltalk, por lo que hemos publicado este libro bajo una licencia que permite la libre circulacin de los contenidos de sus contenidos. Se permite la copia y distribucin de la totalidad o parte de esta obra sin nimo de lucro. Toda copia total o parcial deber citar expresamente el nombre del autor, nombre de la editorial e incluir esta misma licencia, aadiendo, si es copia literal, la mencin copia literal.

S

14

S

15

Se autoriza la modicacin y traduccin de la obra sin nimo de lucro siempre que se haga constar en la obra resultante de la modicacin el nombre de la obra originaria, el autor de la obra originaria y el nombre de la editorial. La obra resultante tambin ser libremente reproducida, distribuida, comunicada al pblico y transformada en trminos similares a los expresados en esta licencia. Sitio web El enfoque de esta obra hace que sea prioritario reducir al mnimo el tiempo de espera antes de adentrarse en el entorno, ya que la experiencia es fundamental para aprender a usar Smalltalk. Para acelerar el proceso inicial, nuestro autor ha trabajado sobre una imagen de Squeak pre-congurada con las herramientas ms habituales a la hora de programar. En uno de los apartados del libro se explica en detalle qu aspectos se instalaron y modicaron sobre un Squeak virgen. Podemos encontrar la imagen, as como otros datos de inters relacionados con este libro, en el wiki:http://smalltalk.consultar.com

CAPTULO 1

? SMALLTALK/SQUEAK QU ES

Resulta muy complicado ofrecer una explicacin exacta acerca de qu es Smalltalk y por qu es tan diferente a otras herramientas de programacin ms populares y utilizadas por los desarrolladores. El origen del distanciamiento por parte de la comunidad de desarrolladores respecto a este entorno, es consecuencia de que el proyecto Smalltalk estuvo - y sigue estando - regido por una concepcin diferente acerca de cmo usar los ordenadores. Este concepto que siempre ha marcado la lnea de Smalltalk puede resumirse, en palabras de nuestro autor, en esta frase: Las computadoras deben ser herramientas que sirvan como amplicadores del espritu creativo de las personas. Esto implica, entre otras cosas, las siguientes armaciones: Todo el sistema tiene que ser inteligible y, por consiguiente, modicable, por una sola persona.

S

16

S

17 Qu es Smalltalk / Squeak?

Programando con

SmalltalkTanto el lenguaje, como la librera de clases y el entorno de desarrollo llevan ms de 30 aos de uso y depuracin. No en vano, Smalltalk ha sido la referencia para el desarrollo de lenguajes y entornos de programacin.1.1 Conceptos

El sistema tiene que estar construido con un mnimo juego de partes intercambiables. Cada parte puede ser modicada sin que altere el resto del sistema. Todo el sistema tiene que estar construido basndose en una metfora que pueda ser aplicada en todas las partes que lo constituyen. Cada componente del sistema ha de poder ser inspeccionado y modicado. Smalltalk es un ambiente de objetos. Los objetos interactan envindose mensajes entre s. Smalltalk incluye un lenguaje de programacin que tambin ha sido desarrollado usando los principios que hemos enumerado anteriormente. Esto quiere decir, por ejemplo, que el lenguaje Smalltalk puede ser modicado - como cualquier otra parte - y reemplazado por otro, o que pueden convivir diferentes lenguajes de programacin en el mismo ambiente, entre otros aspectos. Un entorno de Smalltalk tpico tambin est constituido por muchas herramientas que asisten en la tarea de programacin. Y, como todo en este entorno, son suceptibles de ser modicadas o reemplazadas por otras. Asimismo, el entorno de Smalltalk incluye objetos para crear interfaces grcas de usuarios. Eso s, todo escrito en Smalltalk, todo a la vista y todo modicable. Los lectores tienen ante s un libro de programacin para desarrolladores con un mnimo de conocimiento, por lo que vamos a centrarnos en las posibilidades que ofrece un entorno Smalltalk para la creacin de software. No obstante, hemos de tener muy presente que las ideas sobre las que se fundamenta Smalltalk son lo sucientemente poderosas como para generar un sistema operativo completo. Estas ideas tienen la capacidad de convertir el uso de los ordenadores en una actividad mucho ms creativa que la mera experiencia que tenemos al trabajar con software que usamos normalmente. Desde el punto de vista de simples programadores, podemos decir que Smalltalk:

Smalltalk est denido por un conjunto muy pequeo de conceptos, pero que poseen un signicado muy especco. Resulta fcil confundir los conceptos porque estos son usados en distintos lenguajes, con deniciones muy diferentes tambin.Objetos

Todo en Smalltalk es un objeto. Un objeto es una parte perfectamente diferenciada del resto del ambiente, con caractersticas y responsabilidades bien denidas.Mensajes

Un mensaje es un requerimiento que se le hace a un objeto determinado para que ste lleve a cabo algunas de sus responsabilidades. Por tanto, un mensaje especifica qu es lo que se espera del receptor (el objeto que recibe el mensaje) pero no obliga a responder de una determinada manera. Esto es, el receptor es el responsable de decidir cmo se lleva a cabo la operacin para contestar al mensaje.Interfaz

El juego de mensajes que un determinado objeto puede entender se denomina su interfaz. Por tanto, la nica forma de interactuar con un objeto es a travs de su interfaz.Encapsulacin

Incluye un lenguaje de programacin Incluye una librera de clases Incluye un entorno de desarrollo. Se llama encapsulacin al hecho de que ningn objeto puede acceder a la estructura interna de otro objeto. As pues, slo el objeto conoce, y puede manipular, su propia estructura interna.

S

18

S


Programando con

SmalltalkTodos los objetos de Smalltalk son instancia de alguna clase. La programacin en Smalltalk, por tanto, consiste en crear clases, crear instancias de esas clases y especicar la secuencia de envo de mensajes entre esos objetos.Herencia

Esto, sumado a que los mensajes slo especican qu se espera del receptor pero no indican cmo se debe realizar la tarea, asegura que ningn objeto dependa de la estructura interna de otro. El envo de mensajes junto a la encapsulacin permiten el desarrollo de sistemas muy modulares, ya que cualquier parte del mismo puede ser reemplazada por otra mientras sta ltima respete la interfaz de la parte reemplazada.Polimorsmo

Las clases, en Smalltalk, estn organizadas jerrquicamente. Una clase rena el concepto de otra clase ms abstracta. La clase ms abstracta es Object. Todas las clases son herencias de Object (porque todo es un objeto) o herencia de alguna clase que hereda de Object. La relacin que existe entre la clase ms abstracta (la superclase) y la clase ms concreta (la subclase) permite clasicar el conocimiento que tengamos del dominio diseado.1.2 Programar es simular

Dos objetos son polimrcos entre s cuando un determinado emisor no puede distinguir uno del otro. Dicho de otra forma, si podemos cambiar un objeto por otro, en un determinado contexto, es porque son polimrcos.Clases

Una clase describe la implementacin de un conjunto de objetos. Los objetos individuales descritos por las clases se llaman instancias. La clase describe la estructura interna de los objetos, al igual que especica, tambin, cmo se responde a los mensajes.Variables de instancia

Programar con objetos es programar una simulacin. La metfora en la programacin con objetos est basada en personicar a un objeto fsico o conceptual del dominio real en objetos simulados del ambiente. O lo que es lo mismo, tratamos de dar vida a los objetos reales en el ambiente dotndolos de las mismas caractersticas y funcionalidades que los objetos reales a los que representan.1.3 Historia del Smalltalk

La estructura interna de los objetos est compuesta por variables de instancia. As pues, las variables de instancia son nombres que el objeto puede usar para hacer referencia a otros objetos.Mtodos

Los mtodos son la manera de especicar cmo responden a los mensajes los objetos de una determinada clase. Cada mtodo especica cmo se lleva a cabo la operacin para responder a un determinado mensaje. Un mtodo puede acceder a la estructura interna del objeto as como, tambin, enviarse mensajes a s mismo o a otros objetos. Los mtodos describen, igualmente, cul es la respuesta que recibe el emisor (el objeto que enva el mensaje).

Smalltalk (no se escribe SmallTalk, ni Small-talk, ni Small-Talk) es un proyecto que lleva ms de 30 aos de desarrollo. ste fue inventado por un grupo de investigadores liderados por Alan Kay, en Xerox PARC (Palo Alto Research Center), durante la dcada de los 70. Dicho proyecto de investigacin dio lugar a varios resultados intermedios que fueron conocidos como Smalltalk/71, Smalltalk/72, Smalltalk/76 y Smalltalk/80 (http:// en.wikipedia.org/wiki/Smalltalk)

S

20

S

Smalltalk en el ao 1977

S


Programando con

Smalltalk

La versin del Smalltalk usadaactualmente es un descendiente directo del Smalltalk/80 y conserva prcticamente todas sus caractersticas. El proyecto, desde sus inicios, ha generado una gran cantidad de invenciones que han llegado hasta nuestros das.Aportes del Smalltalk

Por razones que desconoce nuestro autor, el proyecto Smalltalk no cuenta con la reputacin y la fama que se merece. En la actualidad, es muy frecuente encontrarse con profesionales de la informtica que no conocen nada acerca del proyecto ni de sus aportes. Sin embargo, utilizamos a diario algunas de las ideas que se han desarrollado en Smalltalk y muy pocos desarrolladores son conscientes de ello.Ordenador personal

La idea de que cada persona pueda disponer de un ordenador de uso personal, con una potencia de clculo suciente como para ser la herramienta de acceso a la informacin, tiene sus races en las ideas de la Dynabook de Alan Kay (http://en.wikipedia.org/wiki/ Dynabook).

Informtica

S

Smalltalk en el ao 80

Resulta difcil enumerar la cantidad de aportes que Smalltalk ha hecho a la informtica en general. Empezando, por ejemplo, con el paradigma de orientacin a objetos y terminando con aspectos ms tcnicos como la operacin BitBlt (http://en.wikipedia.org/wiki/Bit_blit). Pero la lista contina con las metodologas giles (http://en.wikipedia.org/wiki/Extreme_ Programming), los patrones de diseo (http://en.wikipedia.org/wiki/Design_Patterns), el concepto de entorno de desarrollo... o conceptos como Unit Testing (http://en.wikipedia. org/wiki/Unit_test), Refactoring y Refactoring Browser (http://en.wikipedia.org/wiki/Refactoring). Asimismo, el proyecto Smalltalk tambin ha ayudado a aanzar el uso de los lenguajes dinmicos, los recolectores de basura, el uso de mquinas virtuales y un largo etctera.

Interfaces grcas de usuario

S

Maqueta de la Dynabook.

1.4 Qu es Squeak?

Squeak es un Smalltalk moderno, de cdigo abierto, escrito en s mismo, muy portable y muy rpido. En la actualidad, Squeak puede correr en plataformas Windows, Apple, Linux, iPaqs, etc. Puede considerarse a Squeak como la continuacin del proyecto original de Smalltalk y cuenta con los aportes de varios de los desarrolladores originales de los aos 70, como Alan Kay, Dan Ingalls, Ted Kaehler...

Smalltalk, desde sus inicios, ha contado con una intuitiva interfaz grca de usuario manejable por un ratn. Las ventanas superpuestas, las barras de desplazamiento, la funcin de copiar y pegar, los mens de contexto, etc... forman parte de todos los desarrollos del proyecto que, aos ms tarde, Apple ayud a masicar.

S

22

S


Programando con

SmalltalkLa aplicacin de dicho concepto convierte a Squeak en un ambiente muy multimedia, donde todos los medios de expresin y soporte de informacin pueden conuir en una nica herramienta. Squeak cuenta con excelente soporte para grcos 2D y 3D, procesamiento de texto y numrico, msica (MP3, MIDI, generador de sonido FM), procesamiento de vdeo, entre otras muchas funcionalidades. Adems, Squeak tambin dispone de excelentes herramientas de programacin como el Refactoring Browser, editores de cdigo con sintax-highlight, framework para unit-testing, etc. Y, por supuesto, incluye inmejorables opciones para desarrollo de software comercial como Seaside (un frameworks de desarrollo de aplicaciones web basado en continuations), acceso a bases de datos ODBC, bases de objetos como Magma, rST Remote Smalltalk (soporte de objetos distribuidos), etc. Maqueta de la Dynabook. A da de hoy, nales de enero de 2006, existen ms de 600 paquetes con aplicaciones para instalar en Squeak registradas en SqueakMap (http://map1.squeakfoundation.org/sm). Squeak es el dialecto de Smalltalk escogido para este libro. Sin embargo, hay que saber que el 95% de lo que se aprenda en un determinado dialecto es perfectamente vlido para el resto de los dialectos. Por tanto, si Squeak no es la herramienta que ms nos guste, podemos probar con cualquiera de las otras alternativas que nos ofrece Smalltalk.

La comunidad de desarrolladores y usuarios de Squeak se extiende por todo el mundo, cubriendo un gran abanico de reas, entre ellos: educacin, investigacin, desarrollo multimedia, desarrollo web, entre otros.

El proyecto Squeak comenz en Apple, en el ao 1995, porque los autores necesitaban un entorno de desarrollo de software educativo que pudiera ser usado e incluso programado por personas no tcnicas. Los detalles de la motivacin que dio lugar al proyecto Squeak pueden leerse en el documento Back to the Future The Story of Squeak, a practical Smalltalk written in itself (ver bibliografa). Squeak, en cierta forma, es un regreso a las ideas que haban motivado todo el desarrollo del proyecto Smalltalk en los 70. Algunos de los dialectos comerciales de Smalltalk han perdido parte de la concepcin original y Squeak vuelve a retomar esos valores. Todo lo que pueda hacerse con un ordenador, tiene que poder hacerse con Squeak.

S

Squeak versin 3.4.

S

24

S


CAPTULO 2

SMALLTALK

PROGRAMANDO

CON

El comienzo con Smalltalk, en un principio, puede resultar complicado para personas que proceden de otros entornos. Por ello, vamos a hacer mencin a algunos consejos y comentarios con el objetivo de facilitar su acceso.2.1 La curva de aprendizaje

Preparados para un nivel de aprendizaje alto en nuestro primer contacto con Smalltalk? Como hemos comentado en la Introduccin, Smalltalk ofrece una perspectiva distinta acerca de cmo debera ser nuestra experiencia con los ordenadores. Esa novedosa concepcin es la causa del desconcierto que puede provocar el primer acercamiento con Smalltalk entre los usuarios ya iniciados en informtica.2.2 Shock cultural

La mayora de las desavenencias iniciales tienen que ver con esta forma distinta de ver y entender la informtica. Smalltalk no es difcil, slo es diferente.

S

27 Programando con Smalltalk

Programando con

Smalltalk2.3 Tirar cdigoobjeto mensaje.

El cdigo escrito es importante, pero lo es mucho ms el conocimiento que vamos obteniendo a conforme programamos. Si adquirimos conocimiento en el da a da, probablemente el cdigo antiguo ya no nos sea de tanta utilidad. Tirar cdigo no es malo, sin embargo, el no aprender a diario s que nos puede resultar negativo como programadores.2.4 Trabajo incremental

2.7.1 ExpresionesSmalltalk es un lenguaje que est basado en expresiones. Por tanto, una expresin es una secuencia de caracteres que puede ser evaluada. La expresiones pueden ser de cuatro tipos: literales, variables, expresiones de mensajes y expresiones de bloque.

Un ambiente como Smalltalk es ideal para trabajar de forma incremental. Los vicios que hemos adquirido, como consecuencia del ciclo de desarrollo edicin/compilacin/prueba, no tienen sentido en Smalltalk y, en cierta manera, tenemos que aprender a programar de forma distinta. Por otro lado, los cambios en Smalltalk suponen mucho menos esfuerzo que en otros lenguajes, aspecto que permite relajarse y demorar las decisiones importantes de diseo hasta que sepamos suciente acerca del dominio. No es de extraar, por tanto, que las metodologas giles hayan sido desarrolladas en Smalltalk.2.5 No hay archivos fuentes

LiteralesAlgunos objetos son conocidos por el compilador y pueden ser instanciados (crear un objeto a partir de una clase especca en la programacin orientada a objetos) con literales. El valor de una expresin literal es siempre el mismo objeto. A continuacin vamos a ver los distintos tipos de constantes literales.

NmerosSmalltalk cuenta con una rica variedad de objetos numricos: enteros (SmallInteger, LargePositiveInteger y LargeNegativeInteger), coma otante (Float), fracciones (Fraction), decimales (ScaledDecimal), etc. Estos estn representados por una secuencia de dgitos que pueden estar precedidos por un signo y/o un punto decimal. Algunos de esos objetos pueden instanciarse usando los siguientes literales.Enteros 1. -1. 12345678901234567890. -12345678901234567890. Coma otante 1.1. -1.1. 12345678901234567890.0. -12345678901234567890.0.

En Smalltalk no existe un archivo con los fuentes, es ms, el cdigo est dentro del ambiente de objetos. No obstante, esto no impide mover cdigo entre imgenes de Smalltalk, incluso, existen distintas opciones para trasladar cdigo de un ambiente Smalltalk a otro.2.6 El camino es largo, mejor no ir solo

Quizs la forma ms fcil de aprender Smalltalk sea al lado de un experto, aunque sabemos que es difcil conseguir un tutor a tiempo completo y de forma presencial. Sin embrago, al igual que en otras comunidades de programadores, para Smalltalk tambin existen listas de correos y grupos de usuarios que pueden ayudarnos bastante en los comienzos.2.7 Sintaxis del lenguaje

Prcticamente todo el paradigma de objetos se puede resumir en objetos que reciben mensajes. La sintaxis Smalltalk es una consecuencia directa de ello, as, su estructura bsica es:

S

28

S


Programando con

SmalltalkCaracteresCada elemento que constituye un Array es un literal. Por lo que el literal para crear un Array es una secuencia de literales separadas por espacios en blanco, encerradas entre parntesis ( ). y precedidas por #.Array #(1 2 3 4). #(1 1.0 $a un string #unSmbolo). #(#(1) #(2)).

Los caracteres (Character) pueden instanciarse, tambin, usando constantes literales. Siempre deben estar precedidos por el smbolo $.Caracteres $a. $b. $. $1. $$.

En Squeak (y en ningn dialecto ms) se puede instanciar un Array con el resultado de la evaluacin de expresiones Smalltalk separadas por un punto y encerradas entre llaves {}.Arrays en Squeak {1 + 1. 2 class}. {#(1) class}.

Cadenas de caracteresLas cadenas (String) son una secuencia de caracteres. stas responden a mensajes para acceder a caracteres individuales, sustituir secuencias, compararlas con otras y concatenarlas. La secuencia de caracteres se representa encerrada entre comillas .Cadena de Caracteres !Hola mundo!. Smalltalk. . Un string con una comilla simple ()

Mensajes Los mensajes representan la interacin entre los componentes de un sistema Smalltalk. Un mensaje es un encargo que un objeto le hace a otro objeto. Por tanto, el mensaje est compuesto por el receptor (el objeto al que se le da el aviso), el selector (el nombre del mensaje) y, si corresponde, por los argumentos. Desde el punto de vista sintctico, hay tres tipos de mensajes: Unary, Binary y Keyword.

SmbolosLos smbolos (Symbol) son cadenas de caracteres (String) usadas por el sistema como nombre de clase, mtodos, etc. Nunca aparecern, en todo el sistema, dos smbolos con los mismos caracteres, lo que permite comparaciones muy rpidas. Los smbolos se representan como una secuencia de caracteres alfanumricos precedidos por #Smbolos #unSmbolo. #un smbolo con espacios.

Mensajes Unary Los mensajes Unary son mensajes sin argumentos. De ah que sean los ms simples y slo consten de: receptor mensaje.

Array Un Array (arreglo) es una estructura de datos simple que permite acceder a los elementos contenidos indicando la posicin con un nmero.

Ejemplos de mensajes Unary -1 abs. 2 class. 1000 factorial. aeiou size. Date today. Time now. OrderedCollection new. #smbolo class. String category.

S

30

S


Programando con

Smalltalkal receptor. Por otro, el receptor devuelve informacin con un objeto como resultado del envo de mensajes. Los mtodos, que son la forma que tienen los objetos de responder a los mensajes, pueden especicar el valor de retorno usando el carcter ^.unMtodoConValorDeRetorno1 Este es un ejemplo de mtodo que responde nil como valor de retorno ^ nil

Mensajes Binary La sintaxis de los mensajes binarios tiene un slo argumento, adems del receptor y selector. Los mensajes Binary estn constituidos de la siguiente forma: receptor unOperador argumento. Los operadores vlidos estn compuestos por uno o ms de los siguientes caracteres: [email protected]%&*+=\|?/> 7. 3 = 5. 2 @ 10. Un String , concatenado a otro. Alan Kay -> Smalltalk.

unMtodoConValorDeRetorno2 Este es un ejemplo de mtodo que responde al mismo receptor como valor de retorno. Si el mtodo no tiene un valor de retorno explcito, el receptor es el resultado

Mensajes Keyword Los mensajes Keyword estn formados por una o ms palabras claves, con sus respectivos argumentos, con la siguiente estructura: receptor palabraClave1: argumento1. O, tambin, de esta manera: receptor palabraClave1: argumento1 palabraClave2: argumento2. Y as con tres, cuatro o ms palabras claves y sus respectivos argumentos, pero la palabra clave siempre termina en :Ejemplos de mensajes Keyword Un String rst: 3. Un String allButFirst: 3. Un String copyFrom: 2 to: 5. 5 between: 1 and: 10. 1 to: 5. Array with: 1 with: nil with: string

Precedencia Los mensajes se evalan de izquierda a derecha. As, los mensajes Unary tienen precedencia sobre los Binary y, a su vez, los Binary tienen precedencia sobre los mensajes Keyword. No obstante, siempre se pueden romper las reglas de precedencia utilizando el parntesis.string at: -2 negated >>> string at: (-2 negated) string at: 2 + -1 negated >>> string at: (2 + (-1 negated))

Las simples reglas de precedencia, de la sintaxis Smalltalk, tienen algunas implicaciones imprevistas para personas acostumbradas a otros lenguajes de programacin. Por ejemplo, en Smalltalk el compilador no sabe de sumas y multiplicaciones. Esto implica que el compilador no puede determinar que, cuando operamos con nmeros, la multiplicacin tiene precedencia sobre la suma. Bien, analicemos la siguiente sentencia:

Valor de retorno El lenguaje Smalltalk provee un mecanismo doble de comunicacin. Por un lado, el selector y los argumentos del mensaje permiten que el emisor le enve informacin3 + 2 * 4 >>> 20

S

32

S


Programando con

Smalltalkargumento: argumento al mtodo variableTemporal: variable temporal al mtodo variableDeInstancia: variable de instancia Smalltalk: variable global each: argumento para el bloque | variableTemporal | variableTemporal := Smalltalk allClasses. 3 + (2 * 4) >>> 11 variableDeInstancia := variableTemporal select:[:each | | variableTemporalAlBloque | variableTemporalAlBloque := 1. each name beginsWith: argumento ].

Segn las reglas de precedencia de Smalltalk, se enva primero el mensaje + (con el argumento 2) y al resultado (5) se le enva el mensaje * (con el argumento 4). De esa forma, el resultado es 20 y no 11 como hubiese sido lo normal en otros lenguajes. No obstante, hemos de saber que siempre podemos utilizar parntesis para forzar la precedencia que deseamos:

Cascading messages (mensajes en cascada) En algunas ocasiones es necesario enviarle varios mensajes al mismo receptor. En el lenguaje Smalltalk existe una forma sintctica de enviar ms de un mensaje al mismo receptor. Esta manera de la que hablamos consiste en terminar el envo del primer mensaje con el carcter punto y coma ; y, a continuacin, escribir el siguiente mensaje.Mensajes en cascada Transcript clear; show: algo en el Transcript; cr; show: y algo ms; cr.

La estructura de un nombre de variable se compone de una secuencia de letras y d dgitos, pero siempre empezando por una letra. Las variables temporales y de instancia comienzan con una letra minscula y las globales comienzan con una mayscula. Otra convencin en lo que respecta al nombre de las variables es que, si ste est compuesto de varias palabras, cada una (excepto la inicial en algunos casos) debe comenzar por mayscula.

Los nombres de clases son, tambin, variables globalesCuando se crea una clase, Smalltalk genera una variable global que hace referencia al objeto clase. De ah se desprende que la convencin de nombres de clase sea la misma que la convencin de nombres de variables globales. Una constante literal siempre se reere a un nico objeto, pero una variable puede referirse a distintos objetos en diferentes momentos. Tipos de variables Existen dos tipos de variables: variables privadas y variables compartidas.

Variables La memoria disponible para un objeto se organiza en variables. Todas las variables tienen un nombre y cada una de ellas hace referencia a un nico objeto en cada momento. Todas las variables han de declararse antes de usarlas, la declaracin consiste en una sentencia en la que gura el tipo de dato y el nombre que asignamos a la variable. Una vez declarada se le podr asignar valores. El nombre de las variables puede ser usado en expresiones que quieran hacer referencia a ese objeto.mtodoDeEjemplo: argumento Este mtodo muestra el uso de diferentes tipos de variables.

Variables privadas Estas variables slo son accesibles por un objeto y, a su vez, pueden ser: variables de instancia y variables temporales.

S

34

S


Programando con

Smalltalkvariable := ExpresinSmalltalk.Ejemplos de asignaciones x := 0. y := 1. punto := x @ y. clases := Smalltalk allClasses.

Las variables de instancia representan el estado del objeto y perduran durante toda la vida de ste. Dos objetos diferentes, aunque pertenezcan a la misma clase, pueden tener valores diferentes en sus variables de instancia. Adems, las variables de instancia pueden ser nombradas (cuando tienen asociado un nombre y se las identica a travs de l) e indexadas (no tienen nombre, por lo que slo se puede acceder a ellas enviando un mensaje a la instancia con un ndice especicando a qu variable quiere accederse). Pseudo-variables Las variables temporales estn denidas al comienzo de un mtodo. A diferencia de las variables de instancia, stas slo perduran mientras permanece en activo el mtodo, bloque o programa, representando, as, un estado transitorio del objeto. Variables compartidas Las variables compartidas son.......................................................................................... ..............................................................y tambin pueden ser de tres tipos: variables de clase, variables pool y variables globales. Las variables de clase son compartidas por las instancias de una clase y sus subclases, manteniendo el mismo valor para todas las instancias. Estas variables se declaran en la denicin de la clase. Las variables pool son variables compartidas por un subconjunto de clases en el sistema y almacenadas en diccionarios Pool (que son colecciones de variables cuyo mbito es un subconjunto denido de clases en el sistema). Es necesario declarar en la denicin de la clase el nombre del diccionario Pool que las contiene, para poder acceder a ellas. Y, por ltimo, las variables globales son aquellas variables compartidas por todos los objetos. Asignacin El objeto referenciado por una variable cambia cuando una asignacin es evaluada. Las asignaciones, en Smalltalk, tienen la siguiente estructura:

Una pseudo-variable es un identicador que referencia a un objeto. La diferencia con las variables normales es que no se pueden asignar y siempre aluden al mismo objeto. Esto es, el valor de una pseudo-variable no puede modicarse con una expresin de asignacin.Pseudo-variables constantes nil. Referencia a un objeto usado cuando hay que representar el concepto de nada o de vaco. Las variables que no se asignaron nunca, referencian a nil true. Referencia a un objeto que representa el verdadero lgico. false. Referencia a un objeto que representa el falso lgico.

Pseudo-variables no-constantes self. Referencia al receptor del mensaje. super. Referencia al receptor del mensaje, pero indica que no debe usarse la clase del receptor en la bsqueda del mtodo a evaluar. Se usa, sobre todo, cuando se especializa un mtodo en una subclase y se quiere invocar el mtodo de la superclase. thisContext. Referencia al objeto contexto-de-ejecucin que tiene toda la informacin referente a la activacin del mtodo.

Bloques En Smalltalk el comportamiento (el cdigo) tambin es un objeto. Los bloques son una forma de capturar comportamiento (cdigo) en un objeto para utilizarlo a nuestra discrecin.

S

36

S


Programando con

Smalltalk(nmero \\ 2) = 0 ifTrue:[paridad := 0] ifFalse:[paridad := 1]. Transcript show: el nmero , nmero asString, tiene paridad igual a , paridad asString; cr.

La forma bsica de un bloque es una lista de expresiones, separadas por un punto, encerradas entre corchetes []. [ExpresinSmalltalk1]. [ExpresinSmalltalk1. ExpresinSmalltalk2]. La forma de activar un bloque (de ejecutar el cdigo que encierra) es envindole el mensaje #value. La ltima expresin del bloque ser el valor de retorno.Ejemplo con un bloque sin argumentos ni variables temporales | bloque | bloque := [World ash]. En este punto el mundo NO parpadea bloque value. Ahora que evaluamos el bloque el mundo SI parpadea

Estructuras tipo IF | nmero paridad | nmero := 11. paridad := (nmero \\ 2) = 0 ifTrue:[0] ifFalse:[1]. Transcript show: el nmero , nmero asString, tiene paridad igual a , paridad asString; cr.

Un aspecto a muy interesante del lenguaje Smalltalk es que no existen, como parte de la sintaxis, las estructuras de control (Las formas de iteracin sirven para ejecutar ciclos repetidamente, dependiendo de que se cumplan ciertas condiciones. Una estructura de control que permite la repeticin de una serie determinada de sentencias se denomina bucle1 (lazo o ciclo). La funcionalidad que, en los lenguajes tradicionales, se da con extensiones en la sintaxis, en Smalltalk se resuelve con mensajes a objetos.Estructuras tipo IF Smalltalk allClasses size > 2000 ifTrue:[Transcript show: Cuantas clases!; cr]. Smalltalk allClasses size > 2000 ifTrue:[Transcript show: Cuantas clases!] ifFalse:[Transcript show: No son tantas las clases!]. Transcript cr.

Estructura tipo WHILE | index | index := 1. [index < 10] whileTrue:[ Transcript show: index; cr. index := index + 1 ]. Estructuras tipo FOR 1 to: 10 do:[:index | Transcript show: index; cr]. 1 to: 10 by: 2 do:[:index | Transcript show: index; cr]. 25 timesRepeat:[Transcript show: .]. Transcript cr.

Resulta muy interesante analizar la implementacin del los mtodos True>>ifTrue: ifFalse: y False>>ifTrue:ifFalse: para entender cmo funcionan las estructuras de control con objetos y mensajes. Igualmente, a los bloques tambin se les puede activar con argumentos. La sintaxis para denir un bloque que necesita argumentos para evaluarse es la siguiente:

Estructuras tipo IF | nmero paridad | nmero := 11.

[:argumento1 | Expresiones]. [:argumento1 :argumento2 | Expresiones].

S

38

S


Programando con

SmalltalkmtodoDeEjemplo: argumento Este es un pequeo mtodo que muestra varias de las partes de la sintaxis del lenguaje Smalltalk. El mtodo tiene envo de mensajes Unary, Binary y Keyword; declara argumentos y variables temporales; accede a una variable global; usa literales como array, character, symbol, string, integer y oat; usa las pseudo-variables true, false, nil, self y super; usa bloques con y sin argumentos, con y sin variables temporales al bloque; hace una asignacin; devuelve un resultado al nalizar y, fundamentalmente, no hace nada til. Basado en el mtodo encontrado en: http://wiki.cs.uiuc.edu/VisualWorks/A+small+method+that+uses+all+of+the+Smalltalk+syntax | variableTemporal bloqueConVariableTemporal | true & false not & (nil isNil) ifFalse: [self halt]. A las colecciones SortedCollection se les puede especicar un bloque con 2 argumentos como comparador | coleccin | coleccin := SortedCollection sortBlock:[:x :y | x size < y size]. coleccin add: un string ms largo. coleccin add: un string. coleccin add: #(#un #array #con @simbolos). Transcript show: coleccin; cr. variableTemporal := self size + super size. bloqueConVariableTemporal := [ | variableTemporalAlBloque | variableTemporalAlBloque := 1. variableTemporalAlBloque := variableTemporalAlBloque + 1 ]. bloqueConVariableTemporal value. #($a #a a 1 1.0) do: [:each | Transcript show: (each class name); show: ; cr]. ^ argumento < variableTemporal

Para activar un bloque que requiere un argumento se usa el mensaje #value:, para activar uno que requiere dos argumentos se usa el mensaje #value:value:, y as sucesivamente para bloques con tres o ms argumentos.El mensaje #do: requiere un bloque con un argumento | suma | suma := 0. #(2 3 5 7 11 13) do:[:primo | suma := suma + primo]. Transcript show: suma; cr. Lo mismo el mensaje #collect: | productos | productos := #(2 3 5 7 11 13) collect:[:primo | primo * primo]. Transcript show: productos; cr.

Y, por ltimo, se pueden declarar variables temporales al bloque con la siguiente sintaxis. [| variableTemporal | Expresiones]. [:argumento1 | | variableTemporal | Expresiones]. Comentarios Se pueden insertar comentarios en cualquier parte del cdigo, los cuales han de estar encerrados entre comillas dobles. El primer comentario de un mtodo se considera comentario del mtodo. El comentario es un texto adicional que se aade al cdigo para explicar su funcionalidad, por lo que es parte importante de la documentacin de una herramienta. Adems, no incrementa el tamao del archivo porque es ignorado por el compilador. Mtodo de ejemplo El siguiente mtodo de ejemplo muestra muchos de los aspectos de la sintaxis del lenguaje Smalltalk.

2.8 Herramientas

Un ambiente Smalltalk tpico cuenta con muchas herramientas que asisten en la tarea de desarrollo de software. Segn el estilo que hemos escogido para el libro, explicaremos las herramientas en funcin lo vayan requiriendo los ejemplos que desarrollamos en el captulo Manos a la Obra!2.9 Librera de Clases y Frameworks

La imagen de un Smalltalk cuenta con cientos, incluso miles, de clases cuyas funcionalidades son perfectamente aprovechables para nuestro desarrollo.

S

40

S


Programando con

Smalltalkde una coleccin con operaciones de insercin de elementos. Los tpicos mensajes de enumeracin de las colecciones de Smalltalk no permiten insertar elementos mientras se lleva a cabo la iteracin. La jerarqua de clases de Stream permite la iteracin (repeticin de una secuencia de instrucciones) de colecciones a la vez que la insercin de elementos. La metfora de los streams de objetos funcion tan bien en Smalltalk que, a partir de entonces, se usa para acceder a fuentes de datos externas en el ambiente y en muchos lenguajes orientados a objetos. Weak References Se puede hacer un uso avanzado del recolector de basura (mecanismo implcito de gestin de memoria) utilizando referencias dbiles a objetos. Las referencias dbiles, al contrario de las referencia normales o fuertes, no evitan que un objeto sea reclamado por el recolector. Un objeto puede ser requerido por el recolector cuando no tenga referencias en absoluto, o slo tenga referencias dbiles. Resulta muy til para implementar cachs, pool de instancias, mecanismos de nalizacin de objetos, etc. Multithreading Smalltalk soporta multithreading desde los inicios. Se cuenta con una rica variedad de clases para hacer programacin concurrente de forma sencilla. Las clases Process (Proceso = Thread) y Semaphore (Semforo) sirven de base para la programacin con threads. ExcepcioneS Smalltalk cuenta con un moderno esquema de excepciones. A diferencia de otros lenguajes, toda la implementacin de excepciones est escrita en el mismo lenguaje. Entre otras cosas, el mecanismo de excepciones de Smalltalk permite continuar con la ejecucin en el punto siguiente donde se produjo la excepcin. Metaclases Todo en Smalltalk es un objeto. Todos los objetos tienen una clase y, las clases, como todo, son objetos. Las clases, a su vez, tienen su clase, que se llama Metaclase. Todo el mecanismo de herencia est modelado con clases y metaclases.

Las clases incluidas en Smalltalk nos ofrecen, entre otras cosas, la siguientes utilidades: Nmeros Existen todo tipo de nmeros (enteros, coma otante, fracciones, etc.). Colecciones El framework de colecciones de Smalltalk es uno de los ms antiguos y ms funcionales que existen en la actualidad. La lista de colecciones incluye Bag, Set, OrderedCollection, SortedCollection, Dictionary, etc. String Soporte para cadenas de caracteres de bytes y cadenas que soportan caracteres unicode. Boolean Las clases Boolean, True y False se usan, entre otras cosas, para implementar algunas de las estructuras de control. Cronologa Clases como Date, Time, DateAndTime, Month, Week, Year, Grcos Smalltalk est muy relacionado con el desarrollo de las interfaces de usuario grcas. En los diversos ambientes de Smalltalk completamente auto-contenidos (como Squeak), todo lo referente al procesamiento grco est implementado en el mismo Smalltalk y, por ende, se puede inspeccionar y modicar por el usuario. As, se cuenta con operaciones 2D bsicas (como BitBtl) hasta soporte para grcos 3D con OpenGL. Squeak, a sa de hoy, tiene soporte para colores con el canal alfa (transparencia), anti-aliasing, renderizado de TTF (True Type Fonts), etc. Stream En algunas ocasiones es necesario combinar operaciones de acceso a los elementos

S

42

S


Programando con

Smalltalk

Manual de referencia

Seaside Es un framework para hacer aplicaciones web basado en continuations. Un framework como Seaside simplica muchsimo el manejo del ujo de un sitio web. SUnit ste es el framework del que derivan todos los frameworks de unit-testing que existen. Magma Base de datos de objetos, multiusuario, que permite una completa transparencia a la hora de persistir objetos.2.10 Mquina Virtual

CAPTULO 3

! MANOS A LA

Recordemos que la mquina virtual (virtual machine - VM) permite ejecutar distintos sistemas operativos simultneamente sobre el mismo hardware. La mquina virtual de Squeak est escrita en Smalltalk. El truco consiste en la utilizacin de un subconjunto del lenguaje Smalltalk que puede ser traducido a lenguaje C y compilado para la plataforma necesaria. Esto permite, entre otras cosas, un nivel de portabilidad muy alto que convierte a Squeak en una de las piezas de software ms portable contando, a da de hoy, unas 25 plataformas diferentes. Todo el proceso de depuracin de la mquina virtual puede hacerse en Squeak, lo que facilita mucho la investigacin con arquitecturas de VM diferentes, extensiones, etc. La VM de Squeak, en el momento de escribir este libro, es de 32 bits (aunque ya exista una VM de 64 bits) y cuenta con un recolector de basura (garbage collector) generacional de muy altas prestaciones.

! OBRA

En este captulo ya nos vamos a introducir de lleno en la programacin con Smalltalk. Veremos cmo aprender a programar en este entorno trasciende al mero aprendizaje de una sintaxis y una librera de clases. Digamos que es mucho ms importante saber cmo utilizar el entorno para nuestro benecio y cmo trabajar con un ambiente de objetos vivos. Smalltalk no es slo un lenguaje de programacin, sino que tambin es un entorno donde conviven objetos que interactan entre s mediante el envo de mensajes. Por tanto, toda la programacin se desarrolla como el resultado del envo de mensajes a los objetos. Cuando un usuario interacta con un ambiente Smalltalk, ste ltimo se ve modicado como efecto de esa interaccin. Recordemos que en Smalltalk todo es un objeto. Tanto las clases como los mtodos tambin son objetos, por lo que, para impactar sobre ellos, debemos enviarles mensajes. Esto implica que la programacin no es diferente a cualquier otra tarea que se haga en un entorno Smalltalk: objetos que reciben mensajes y que reaccionan como efecto de ese envo.

S

44

S

45

Programando con

SmalltalkA continuacin seleccionamos la opcin browser (b), tal y como vemos en la Figura 2.Figura 2

En Smalltalk no existe diferencia entre desarrollo y ejecucin, sino que la programacin se hace modicando objetos mientras estos estn en funcionamiento. Para ilustrar mejor esta idea vamos a desarrollar, paso a paso, tres ejemplos sencillos que tambin nos servirn para tomar un primer contacto con las principales herramientas de desarrollo en Smalltalk.Figura 1

3.1 Modicando objetos vivos

Y obtenemos el Browser de Clases, cuya apariencia es la que podemos ver en laFigura 3.

Vamos a crear una clase, de nombre Cliente, que ser la representacin en nuestro entorno de los clientes reales de un supuesto sistema de facturacin. Para esto utilizaremos una de las herramientas que nos ofrece Smalltalk para interactuar con el ambiente: el Browser de Clases.

Figura 3

S

S

Esta opcin la encontraremos activando el men del Mundo de Squeak con un clic y seleccionando la opcin open... para obtener el submen de la Figura 1.

El Mundo

El objeto grco que contiene a todos los dems objetos se llama Mundo. El Mundo de Squeak es similar al escritorio de los sistemas operativos actuales, pero respetando la regla bsica de Smalltalk: todo es un objeto. Por tanto, el Mundo es un objeto y disponemos de una variable global llamada World para acceder a l. Podemos evaluar algunas de las siguientes sentencias para ver cmo reacciona el Mundo:Cambiar el color al Mundo World color: Color lightYellow muchLighter. World color: Color white. El Mundo se oscurece por un instante World ash. Juguemos con el borde del Mundo World borderWidth: 4. World borderColor: Color red.

SBrowser de ClasesEsta herramienta nos permite ver y modicar todas las clases que tenemos en nuestro entorno. Adems, tambin tenemos la posibilidad de crear o eliminar Categoras de Clases, Clases, Categoras de Mtodos y Mtodos. Como Squeak est escrito en s mismo, a travs de esta utilidad podemos ver absolutamente todo su funcionamiento, desde el compilador hasta las ventanas, desde los nmeros enteros hasta los tipos booleanos, todo es visible y todo es modicable.

S

46

S

47 Manos a la obra

Programando con

SmalltalkTipos de Browser de ClasesBien, si seleccionamos una de las opciones del panel, en los paneles subsiguientes veremos la informacin correspondiente a la seleccin. Por ejemplo, si elegimos en el primer panel la categora de clases Kernel-Objects, en el segundo panel tendremos las clases dentro de esa categora como Boolean, DependentsArray, False, MessageSend, etc. De la misma forma, si ahora seleccionamos la clase Boolean en el segundo panel, en el tercero veremos las categoras de mtodos de esa clase; y si elegimos una categora de mtodos como controlling, obtendremos los mtodos en el ltimo panel. Por ltimo, si seleccionamos uno de los mtodos, veremos en el panel inferior el cdigo de dicho mtodo (ver Figura 5).Figura 5

Existen diferentes tipos de Browser de Clases, sin embargo, prcticamente todos comparten la funcionalidad bsica. En este manual usaremos el Refactoring Browser que, adems de brindarnos las caractersticas del Browser bsico, nos ofrece opciones para la refactorizacin del cdigo ( concepto que veremos ms adelante).

El Browser est compuesto principalmente por 4 paneles superiores y un panel inferior. En los paneles superiores encontraremos, de izquierda a derecha, las Categoras de Clases, las Clases, las Categoras de Mtodos y los Mtodos, tal como se indica en la Figura 4.Figura 4

S

Ahora vamos a crear una categora de clases para incluir dentro la nuestra, Cliente. Para conseguir esto, pedimos el men contextual, haciendo clic con el botn azul del ratn, del panel de Categoras de Clases y seleccionamos la opcin add item...( ver Figura 6).Figura 6

S

Categoras de Clases y Mtodos

Tanto las Categoras de Clases como las Categoras de Mtodos no tienen una semntica para Smalltalk en s mismo, sino que sirven para documentar el diseo agrupando clases y mtodos por funcionalidad para facilitar al usuario el manejo del sistema. En Smalltalk se lee mucho ms cdigo del que se escribe, por lo que todo el entorno promueve la escritura de cdigo limpio y documentado, vindose recompensado as el tiempo que utilicemos en la programacin.

S

48

S

S

49 Manos a la obra

Programando con

SmalltalkSqueak y el RatnSqueak es multiplataforma y a da de hoy funciona en ms de 20 plataformas diferentes: GNU/Linux, varios sabores de Unix, Windows, Apple, PDA como iPaq y un largo etctera. Sin embargo, esta variedad conlleva algunos problemas como, por ejemplo, el uso de los distintos tipos de ratones que posee cada una de ellas. Por motivos histricos que se remontan al ratn de la computadora Xerox Alto, a los 3 botones del ratn se les nombra con colores: Rojo, Amarillo y Azul. Botn Rojo: El Botn Rojo es el que se usa para seleccionar. En prcticamente todas las plataformas este botn se mapea al botn principal de la plataforma (normalmente, el botn izquierdo del ratn, o el tap del lpiz). Botn Amarillo: El Botn Amarillo se utiliza para pedir el halo de los objetos grcos. En GNU/Linux se utiliza el botn derecho, en Windows el botn del medio o ALT-clic y, en Apple, Opt-clic. Botn Azul: El Botn Azul se usa para obtener el men contextual. En GNU/Linux (y todos los sabores de Unix) obtenemos el men contextual haciendo clic con el botn del medio del ratn, en Windows se obtiene el men contextual con un clic del botn derecho y, en Apple, con Cmd-clic. Presionamos Intro o hacemos clic en el botn Accept(s) y obtenemos el resultado que nos muestra la Figura 8.Figura 8

SFoco del TecladoEn Squeak el foco del teclado est en el control al que est apuntado el puntero del ratn. Por ello antes de teclear algo hay que asegurarse que estemos apuntando al control con el ratn. Al crear una nueva categora, sta se selecciona automticamente y en el panel inferior aparece una plantilla (template) para crear una clase nueva. Para incluir una nueva clase tenemos que enviarle un mensaje a la superclase, accin que podemos ejecutar a travs de la plantilla que nos ofrece el Browser de Clases. Simplemente reemplazamos NameOfSubclass por el nombre de la clase que queremos crear (ver Figuras 9 y 10). Ahora debemos aceptar nuestro cambio usando la opcin accept (s) el men contextual del panel inferior, tal y como nos muestran las Figuras 11 y 12.

A continuacin tecleamos el nombre de la nueva categora, en nuestro caso, Facturacion (ver Figura 7).

S

Figura 7

S

50

S

51 Manos a la obra

Programando con

SmalltalkFigura 11

Figura 9

Figuras 9 y 10

SFigura 10

S SS52

Figura 12

Workspace

El Workspace (espacio de trabajo) es una ventana que nos permite ordenar el cdigo que vamos evaluando de forma interactiva en nuestro entorno. Por tanto, se trata de una herramienta importante y til, aunque en Smalltalk se puede evaluar cdigo en cualquier panel de texto y no slo en los espacios de trabajo.

S

53 Manos a la obra

Programando con

SmalltalkTipos de Workspace Evaluando CdigoAl evaluar cdigo Smalltalk de forma interactiva, disponemos de cuatro opciones sobre cmo tratar la respuesta. evaluar el cdigo e ignorar la respuesta. evaluar el cdigo e imprimir por pantalla la representacin como String de la respuesta. inspect it evaluar el cdigo e inspeccionar el resultado. sta es la opcin utilizada en el ejemplo. explore it evaluar el cdigo y explorar el resultado. El Explorer es otro formato de Inspector. do it print it

Un Shout Workspace es un espacio de trabajo que muestra sintax-highlight (aade colores segn la semntica de la sintaxis) conforme lo utilizamos. Para este libro usaremos esta herramienta porque es ms vistosa que el Workspace tradicional. No obstante, desde el punto de vista de funcionalidad no existe ninguna diferencia entre ambas alternativas.

Para abrir un Workspace o Shout Workspace, de nuevo usaremos el men del Mundo (World) | Open... | Workspace o Shout Workspace.Figura 13 y 14

Seguidamente escribimos en el recin abierto Workspace la siguiente instruccin: Cliente new

Sentencias de ejemplo para evaluar, imprimir, inspeccionar o explorarAlgunas cositas con String un string. un string , concatenado a otro. un string de cierto tamao size. *string* match: un string. Algunos nmeros 34. 1 / 3. (1 / 3) asFloat. 3.141592653589793. 1000 factorial.

Algo del Mundo World extent. World color. Expresiones Booleanas 1 > 3. true. false. Otras Expresiones nil. Date today. Time now. Time millisecondsToRun: [1000 factorial].

Lo seleccionamos con el ratn, activamos el men contextual y elegimos la opcin inspect it (i) (ver Figura 15).

S

S

S54

Algunas cositas con colecciones Smalltalk allClasses. Smalltalk allClasses collect:[:each | each name]. Smalltalk classNames. Smalltalk classNames size. Smalltalk classNames select:[:each | *String* match: each].Figura 15

S

55 Manos a la obra

Programando con

SmalltalkAs, volvemos al browse y nos aseguramos que estn seleccionadas la categora de clase Facturacion y la clase Cliente. Entre las comillas simples que estn detrs de la palabra instanceVariableNames tecleamos lo que vemos en la Figura 18.Figura 18

Esta accin nos brindar otra de las herramientas de Smalltalk: el Inspector (ver Figura 16).Figura 16

Inspector

S

El Inspector es una herramienta que nos permite ver cmo est compuesto un objeto, qu variables de instancia tiene y qu valores tienen estas variables de instancia. En Smalltalk, absolutamente todos los objetos pueden ser inspeccionados. Veamos ahora cmo est compuesto el Inspector que, como hemos dicho, nos ofrece la posibilidad de ver un objeto por dentro y enviarle mensajes.Figura 17

Y aceptamos los cambios como lo hicimos anteriormente (men contextual, opcin accept (s)).

SEjemplo:

Hot - KeysAlgunas de las opciones que hemos ido utilizando durante el ejemplo tienen una letra entre parntesis, el hot-key. Podemos invocar esas opciones presionando ALT y la letra.

En el panel de las variables de instancia tenemos dos variables especiales: self y all inst var. Al seleccionar self, en el panel de la derecha vemos la representacin como String del objeto inspeccionado. Y, si seleccionamos all inst var, vemos todas las variables de instancia como si fuesen una sola. Ahora vamos a modicar ligeramente la clase Cliente, pero lo haremos sin cerrar el Inspector a la instancia. Es decir, vamos a cambiar la estructura del objeto mientras ste est vivo.

S

browser (b) workspace (k) accept (s) inspect it (i) explore it (I)

ALT-b ALT-k ALT-s ALT-i ALT-MAYSCULA-i

Si todo ha salido bien, ya deberamos ver cmo el Inspector a la instancia de Cliente que dejamos abierto nos muestra una nueva variable de instancia (ver Figura 19).Figura 19

S

56

S

S

57 Manos a la obra

Programando con

Smalltalk3.2 Parser de XML basado en una Pila

Ahora vamos a ponerle un nombre a nuestro cliente, para lo que seleccionamos la variable de instancia en el panel de la izquierda y, a continuacin, escribimos pedro en el panel de la derecha: pedro Aceptamos los cambios (men contextual y opcin accept (s) o ALT-s), y el resultado lo vemos en la Figura 18.Figura 18

Para procesar archivos XML, tarea que realizaremos en el prximo ejemplo, usaremos una herramienta que simplica mucho la escritura de parsers de XML. El parser que utilizaremos funciona de la siguiente manera: cada vez que ste encuentra un nuevo tag de XML, enva un mensaje al objeto que est ms arriba en su pila y el resultado del envo se apila. Cuando ese mismo tag termina, el objeto se desapila. El primer objeto apilado es uno escrito manualmente, y es el que procesar los tags de ms alto nivel. El mensaje que se enva al objeto superior de la pila tiene como parmetro un diccionario que contiene los atributos del tag. Veamos un ejemplo lo sucientemente simple como para analizarlo por completo. Imaginemos un archivo XML como el siguiente:

SPara terminar este ejemplo saldremos de nuestro entorno grabando todos los cambios. Para ello, abrimos el men del Mundo (Word) y escogemos la opcin save and quit ( ver Figura 19).Cuando entremos nuevamente a nuestro Smalltalk, tendremos todo el entorno en el mismo estado en que lo dejamos.

Figura 19

Este archivo contiene los datos de una agenda, la cual tiene dentro personas y las personas direcciones y datos de contacto y, a su vez, las informaciones de contacto tienen telfonos y direcciones de email. A continuacin, instruimos al parser para que enve los siguientes mensajes segn el tag que se procese:Tag de XML Mensaje a Enviar #crearAgenda: #crearPersona: #crearDireccion: #crearInformacionContacto: #crearEMail: #crearTelefono:

ml x

El ejemplo que acabamos de hacer deja en evidencia una diferencia fundamental de Smalltalk respecto a los lenguajes de programacin tradicionales, en los que un objeto nunca sobrevive a un cambio del programa. En Smalltalk es posible, y habitual, modicar un sistema mientras est funcionando. Este ejemplo, adems, nos ha mostrado algunas de las herramientas principales de Smalltalk (Browser, Workspace e Inspector) de las que hemos visto su uso bsico. Por tanto, ya estamos preparados para pasar a un ejemplo ms complejo.

S

58

S

59 Manos a la obra

Programando con

SmalltalkLa pila, en este punto, contiene lo siguiente:una Agenda una Agendas

Antes de comenzar el parseo, incluiremos en la pila el objeto Agendas. Ese objeto es capaz de crear y almacenar agendas, es decir, posee la capacidad de responder al mensaje #crearAgenda: La pila del parser contendr, por tanto, lo siguiente:

una Agendas

Smalltalk con EstiloEn Smalltalk existe un idioma que consiste en nombrar a los objetos con a o an (uno o una en ingls) y el nombre de la clase. De esa forma, a una instancia de la clase String se le llama aString o a String, una instancia de Date se llama aDate o a Date, una instancia de Integer es anInteger o an Integer, etc. El lugar ideal para conocer todas las convenciones e idiomas que se usan en Smalltalk es el libro Smalltalk with Style (ver bibliografa).

Agenda>>crearPersona: aDictionary Crea una nueva persona y la guarda en el receptor | persona | persona := Persona apellido: (aDictionary at: apellido) nombre: (aDictionary at: nombre). self addPersona: persona. ^ persona.

El mtodo de la clase Agenda es muy similar al anterior mtodo #crearAgenda: excepto porque ste ltimo considera los atributos presentes en el tag , que vienen en el argumento aDictionary, para crear una Persona con nombre y apellido. Bien, ahora se ha apilado una Persona, por lo que este objeto es el responsable de contestar al mensaje #crearDireccion:una Persona nombre=Bob apellido=Gates una Agenda una Agendas

Agendas>>crearAgenda: aDictionary Crea una nueva agenda y la guarda en el receptor | agenda | agenda := Agenda new. self addAgenda: agenda. ^ agenda.

NombreDeClase>>nombreDeMtodoCuando es necesario volcar el cdigo fuente de un mtodo en panel, se utiliza la convencin de escribirlo con el nombre de la clase, seguido de >> y, a continuacin, el nombre del mtodo. Esto es una convencin para el papel y no es parte de la sintaxis de Smaltalk.

Persona>>crearDireccion: aDictionary Crea una nueva direccion y la guarda en el receptor | direccion | direccion := Direccion calle: (aDictionary at: calle) numero: (aDictionary at: numero) ciudad: (aDictionary at: ciudad) provincia: (aDictionary at: provincia). self addDireccion: direccion. ^ direccion.

Como el resultado de la evaluacin del mensaje #crearAgenda: es una Agenda, sta se apila y es ahora la responsable de contestar al mensaje #crearPersona:

La Direccion devuelta por el mtodo anterior se suma a los dems objetos, dejando la pila de la siguiente forma:

S

60

S

61 Manos a la obra

Programando con

Smalltalkuna Direccion calle=Pine Rd. numero=1239 ciudad=Los Angeles provincia=CA una Persona nombre=Bob apellido=Gates una Agenda una Agendas

La pila queda ahora de la siguiente forma:una Persona nombre=Joe apellido=Smith una Agenda una Agendas

Llegados a este punto, el parser se enfrenta, por primera vez en este ejemplo, al cierre del tag. Por tanto, al cerrarse el tag , el parser desapila la direccin.una Persona nombre=Bob apellido=Gates una Agenda una Agendas

A continuacin, el objeto superior de la pila (una InformacionContacto) recibe el mensaje #crearEMail:InformacionContacto>>crearEMail: aDictionary Crear un nuevo email y lo guarda en el receptor | eMail | eMail := EMail direccion: (aDictionary at: direccion). self addEMail: eMail. ^ eMail.

A continuacin, se cierra el tag , as que se desapila la persona.una Agenda una Agendas

El resultado del mtodo anterior (un EMail) se apila, pero inmediatamente despus se desapila puesto que el tag se cierra y la Informacin de Contacto nuevamente queda en la parte superior de la pila. El tag se procesa de forma similar al tag .

Ahora se enva otro mensaje #crearPersona: a la Agenda, creando una nueva Persona y apilndola.una Persona nombre=Joe apellido=Smith una Agenda una Agendas

InformacionContacto>>crearTelefono: aDictionary Crear un nuevo telfono y lo guarda en el receptor | telefono | telefono := Telefono numero: (aDictionary at: numero). self addTelefono: telefono. ^ telefono.

Seguidamente se enva un mensaje #crearInformacionContacto: a la Persona como reaccin al tag .

A continuacin se cierra el tag y se desapila la Informacin de Contacto. Despus, procesamos el tag del mismo modo en que se proces para la persona anterior, apilando el resultado y desapilndolo en cuanto se cierra el tag.

Persona>>crearInformacionContacto: aDictionary Crea una nueva informacion de contacto y la guarda en el receptor ^ informacionContacto := InformacionContacto new.

El estado de la pila, en este punto, es el siguiente:

S

62

S

63 Manos a la obra

Programando con

Smalltalkuna Persona nombre=Joe apellido=Smith una Agenda una Agendas

Con este concepto claro, vamos a llevar a cabo un ejemplo programando de la forma ms incremental posible, es decir, ejecutaremos todo el cdigo que podamos en el Depurador. Veamos un XML de ejemplo sacado de la Wikipedia en Latn, pero simplicado y acortado para poder analizarlo en toda su extensin:

Y, ya estamos terminando de procesar el XML, slo resta el cierre del tag y el del tag . Es decir, que se desapila la persona y, a continuacin, la agenda, quedando la pila en el mismo estado que estaba antes de comenzar el parseo.una Agenda una Agendas

Vicipaedia http://la.wikipedia.org/wiki/Pagina_prima MediaWiki 1.6devel rst-letter Specialis Disputatio Astronomia 1 46556

Una vez explicado cmo funciona el parser de XML basado en una pila, podemos comenzar ya con el importador de Wikipedia.3.3 Importador de Wikipedia

En este apartado nos ocuparemos de un ejemplo un poco ms complejo y, a su vez, ms completo, hablamos de crear un importador de los datos de la Wikipedia.

WikipediaWikipedia es un proyecto para escribir de manera comunitaria enciclopedias libres en todos los idiomas. ste fue fundado por Jimmy Wales y Larry Sanger basndose en el concepto wiki, que permite crear colectivamente documentos web sin que sea necesaria la revisin del contenido antes de su aceptacin para ser publicado en la Red. La versin en ingls comenz el 15 de enero de 2001 y tres aos y medio despus, en septiembre de 2004, unos 10.000 editores activos trabajaban en 1.000.000 de artculos en ms de 50 idiomas. Podemos obtener ms informacin en http:// es.wikipedia.org/wiki/Wikipedia - Archivos de la Wikipedia: http://download.wikipedia.org http://download.wikipedia.org/wiki/Importing_a_Wikipedia_database_dump_ into_Mediawiki Por tanto, el proyecto Wikipedia ofrece toda la informacin de sus sitios disponibles para bajar desde Internet, pudindose descargar todos los artculos de las distintas enciclopedias de diferentes idiomas en un archivo XML.

2005-10-31T22:28:43Z 80.136.214.100 Astronomia Auxilium 2 44264 2005-10-11T16:43:35Z 217.72.33.184 comment> better latin from italy [[:it:Utente:OrbiliusMagister]]>fromFileNamed: (por el que instruimos al parser para que procese cada tag), tal y como vemos en la Figura 42.Figura 42

Tecleamos la siguiente instruccin en el panel que muestra el cdigo del mtodo del Depurador y aceptamos los cambios (men contextual y opcin accept (s) o ALT-s).

onMediawiki: aDictionary No tiene sentido crear un Mediawiki si somos un Mediawiki ^ self

El Depurador se nos mostrar con la apariencia que vemos en la Figura 40.Figura 40

A continuacin, presionamos el botn Proceed y seguimos con el desarrollo (ver Figura 41).Figura 41

Ahora, si todo ha ido bien, el parser nos va a indicar que no sabe qu hacer con el tag , puesto que no le hemos dado ninguna orden de cmo actuar con los tags que no sean .

S S

A continuacin, en este mismo contexto, agregamos la siguiente secuencia:

S

parser onTag: siteinfo send: #onSiteinfo:.

S

78

S

79 Manos a la obra

Programando con

SmalltalkFigura 43

Para ganar ms tiempo podemos teclear las siguientes rdenes para varios tags, quedando el mtodo completo de la siguiente manera:

fromFileNamed: aString Crea una nueva instance del receptor desde el archivo llamado aString | archivo parser instancia | abre el archivo archivo := FileStream readOnlyFileNamed: aString. crea la instancia del receptor instancia := self new. instancia el parser parser := XMLStackParser on: archivo. la instancia recin creada es el primer objeto de la pila parser push: instancia. instruimos al parser sobre como procesar el tag parser onTag: mediawiki send: #onMediawiki:. parser onTag: siteinfo send: #onSiteinfo:. parser onTag: namespaces send: #onNamespaces:. parser onTag: namespace send: #onNamespace:. parser onTag: page send: #onPage:. parser onTag: revision send: #onRevision:. parser onTag: contributor send: #onContributor:. le pedimos al parser que haga su trabajo parser parseDocument. cerramos el archivo archivo close. devolvemos la instancia al remitente del mensaje ^ instancia

Es interesante que veamos qu ha pasado con la pila

libro smalltalk

Documents

OO e Smalltalk

Programando con Smalltalk

Smalltalk on Git

Redline Smalltalk (PowerPoint)

Smalltalk intro I

Smalltalk Is

Cincom Smalltalk: Present, Future & Smalltalk Advocacy

Pragmatic Smalltalk

Coleccion de Smalltalk

Smalltalk für Quereinsteiger

Smalltalk Programação Orientada a Objetos. Smalltalk A Origem do Smalltalk

Deep into Smalltalk

Smalltalk Presentation

Cincom Smalltalk News

Smalltalk by Example

SqueakPharo NYC Smalltalk

Inside Smalltalk

Early History SmallTalk

Smalltalk in Moodle

Informe Smalltalk

Smalltalk Language Mapping Specification - Patrick Muellermuellerware.org/papers/omg-smalltalk-99-07-65.pdf · Smalltalk Language Mapping i Contents Preface . . . . . . . . . .

Startup Smalltalk

Marketing Smalltalk

TM Smalltalk Cincom VisualWorks@ Smalltalk-VisualWorks ...smalltalk.cincom.jp/main/wp-content/uploads/... · TM Smalltalk Cincom VisualWorks@ Smalltalk-VisualWorks Cincom Smalltalk-VisualWorks

Continuous Integration for Pharo Smalltalk - Smalltalkと継続的インテグレーション

Cincom Smalltalk Update

Smalltalk: Yes, We Can - Heeg Smalltalk-Koeln… · Smalltalk: Yes, We Can Georg Heeg Executive Director STIC –Smalltalk Industry Council. STIC Industry Members •Board Members

Smalltalk prakticky [CZ]

Sapphire - Scripting Smalltalk

Resilient Smalltalk

VA Smalltalk Update

PDF in Smalltalk

RESTful Web Services in VA Smalltalk€¦ · Web Services and VA Smalltalk • Supported by VA Smalltalk since V 5.5 • Based on Server Smalltalk • Constantly improved in 6.x,

Smalltalk Primer Session

De Smalltalk-gids