75.24 Teora de la Programacin 75.

31 Teora de Lenguajes

Smalltalk
Integrantes: Ignacio Bayetto Francisco Di Salvo Ignacio De Zan

Smalltalk

Contenido
1 . Historia ..................................................................................................................................4 2 . Arquitectura...........................................................................................................................7 2.1 . Imagen ...........................................................................................................................7 2.2 . Mquina Virtual .............................................................................................................7 3 . Caractersticas......................................................................................................................9 3.1 . Mensajes ......................................................................................................................12 3.1.1 . UNARIOS (UNARY MESSAGE) ......................................................................12 3.1.2 . BINARIOS (BINARY MESSAGE) ......................................................................12 3.1.3 . PALABRA CLAVE (KEYWORD MESSAGE) ...................................................13 3.2 . Herencia y Polimorfismo ............................................................................................14 3.2.1 Conceptos bsicos ................................................................................................14 3.2.2 Jerarqua de clases en Smalltalk .........................................................................15 3.2.3 Herencia de mtodos ............................................................................................15 3.2.4 Herencia de variables ...........................................................................................17 3.2.5 Clases abstractas ..................................................................................................18 3.2.6 Polimorfismo ...........................................................................................................20 3.3 . Clases y Metaclases ..................................................................................................21 3.3.1 Problema Huevo o la Gallina? ...........................................................................21 3.3.2. Reglas para clases y metaclases .......................................................................21 3.3.3. Regla 6: Toda clase es instancia de una metaclase .......................................22 3.3.4. Regla 7: La jerarqua de metaclases tiene la misma estructura que la jerarqua de clases ..........................................................................................................22 3.3.5 Regla 10: La metaclase de Metaclass es instancia de Metaclass ..................23 3.3.6 Resumen .................................................................................................................24 3.4 . Reflexin ......................................................................................................................25 3.4.1 Ejemplos .................................................................................................................25 4. Estructuras de control.........................................................................................................28 4.1 Selectivas/Alternativas: ...............................................................................................28 4.2 Iteracin/Repeticin .....................................................................................................28 5. Manejo de excepciones......................................................................................................31 5.1. Qu hacer con las excepciones? ............................................................................31 5.2. Jerarqua de excepciones...........................................................................................32 5.3. Excepciones propias ...................................................................................................32

Pgina 2

Smalltalk
6. Concurrencia .......................................................................................................................34 6.1 Process...........................................................................................................................34 6. 2 Semaphore ...................................................................................................................34 6.3 ProcessorScheduler .....................................................................................................35 6.4 Ejemplo concurrencia ...................................................................................................35 7 Manejo de memoria .............................................................................................................37 7.1 Object Memory ..............................................................................................................37 7.2 Almacenamiento Heap .................................................................................................37 7.3 Compactacin................................................................................................................38 7.4 La tabla de objetos .......................................................................................................38 7.5 Object Pointer ................................................................................................................38 8. Recoleccin de basura .......................................................................................................39 9. Implementaciones ...............................................................................................................40 10. Bibliografa .........................................................................................................................40

Pgina 3

Smalltalk

1 . Historia
La palabra Smalltalk es usualmente utilizada para indicar el lenguaje de programacin Smalltalk-80, la primera versin disponible pblicamente y creada en 1980. Smalltalk fue el producto de una investigacin liderada por Alan Key en Xerox Palo Alto Research Center (PARC). Alan Key dise las primeras versiones de Smalltalk las cuales fueron implementadas por Dan Ingalls. La primera versin, conocida como Smalltalk-71, fue creada por Ingalls en una apuesta por lograr que un lenguaje de programacin basado en el pasaje de mensajes, inspirado en Simula, pudiera ocupar slo una pgina de cdigo. Una versin posterior y ahora conocida como Smalltalk-72 fue utilizada para investigacin e influenciada por el desarrollo del modelo de actores (Actor Model). Su sintaxis y modelo de ejecucin cambiaron mucho en las posteriores versiones de Smalltalk. Luego de significativas revisiones, las cuales congelaron algunos aspectos de la ejecucin semntica para ganar performance (adoptando un modelo de ejecucin de clases y herencia parecido al de Simula), se cre Smalltalk-76. Este sistema tena un ambiente de desarrollo que ofreca la mayora de las herramientas de desarrollo que hoy conocemos (incluyendo una biblioteca de clases de navegador de cdigo / editor). Luego en 1980, Smalltalk-80 agreg las metaclases para ayudar a mantener el paradigma de todo es un objeto (excepto por las variables de instancia privada) asociando propiedades y comportamiento con clases individuales, e incluso primitivas tal como un integer y los valores booleanos (por ejemplo, para soportar diferentes formas de crear instancias). Smalltalk-80 fue la primer variante del lenguaje desarrollada fuera de PARC, primero como Smalltalk-80 versin 1 otorgada a un pequeo nmero de firmas (Hewlett-Packard, Apple Computer, Tektronix y DEC) y a universidades (UC Berkeley) para revisin por pares e implementacin de sus plataformas. Luego, en 1983, una implementacin pblica conocida como Smalltalk-80 Version 2, fue lanzada como una imagen (archivo -plataforma independiente con definicin de objetos) y una especificacin de la mquina virtual. ANSI Smalltalk ha sido la referencia estndar del lenguaje desde 1998. Dos de las ms populares implementaciones de Smalltalk son descendientes de la imagen original de Smalltalk-80. Squeak es una implementacin open source basada en Smalltalk-80 Version 1 a travs de Apple Smalltalk. VisualWorks es otra implementacin basada en Smalltalk-80 versin 2 a travs de Smalltalk-80 2.5 y ObjectWorks (ambos productos de ParcPlace Systemas, una compaa derivada de Xerox PARC para lanzar Smalltak al mercado).
Pgina 4

Smalltalk Cabe destacar que en 2002 Vassili Bykov implement Hobbes, una mquina virtual la cual corre Smalltalk-80 dentro de VisualWorks (Dan Ingalls utiliz Hobbes para Squeak). Durante los 80 hasta los 90, los ambientes de desarrollo de Smalltalk fueron vendidos por dos compaas: ParcPlace Systems y Digitalk, ambas situadas en California. ParcPlace Systems se focaliz en el mercado Unix/Sun Microsystems mientras que Digitalk se focaliz en el de las computadoras que corran Microsoft Windows o IBM OS. Ambas firmas lucharon por mantener a Smalltalk en el mainstream pero eso no fue posible debido a las necesidades de memoria sustanciales de Smalltalk, rendimiento limitado en tiempo de ejecucin, y la falta inicial de conectividad con el apoyo a los servidores de bases de datos relacionales basados en SQL. Mientras que el alto precio de ParcPlace Smalltalk limitaba su penetracin en el mercado a las organizaciones comerciales de tamao medio y grande, los productos Digitalk trataron comercializar a un precio ms bajo para intentar llegar a una audiencia ms amplia. IBM apoy inicialmente el producto Digitalk, pero luego en 1995 entr en el mercado con un producto de Smalltalk llamado VisualAge / Smalltalk. Por aquel entonces Caballete introdujo Enfin en Windows y OS / 2 y Enfin se volvi mucho ms popular en Europa, ya que IBM prioriz el desarrollo en sus departamentos de TI antes que el desarrollo de IBM Smalltalk (ms tarde VisualAge). Ms tarde Enfin fue adquirida por Cincom Systems, y ahora se vende bajo el nombre de ObjectStudio y forma parte de la suite de productos Cincom Smalltalk. En 1995, ParcPlace y Digitalk se fusionaron en ParcPlace-Digitalk y luego en 1997 cambiaron su nombre a ObjectShare ubicada en Irvine, CA. ObjectShare se mantuvo en el mercado hasta 1999 cuando se disolvi. La razn de su disolucin fue que esta fusin de empresas nunca pudo encontrar una solucin efectiva para responder a Java en el mercado. En 1999, Seagull Software compra el laboratorio de desarrollo de Java de ObjectShare, incluyendo el original Smalltalk/V y el equipo de desarrollo de VisualSmalltalk. An es duea de VisualSmalltalk, aunque los derechos de la distribucin en todo el mundo quedaron para ObjectShare quienes luego los vendieron a Cincom. VisualWorks fue vendido a Cincom y ahora es parte de Cincom Smalltalk. Cincom ha respaldado fuertemente a Smalltalk, lanzando nuevas versiones de VisualWorks y ObjectStudio desde 1999. Cincom, Gemstone y Object Arts, y otros tantos vendedores siguen vendiendo entornos Smalltalk. IBM tiene contrato de por vida (end of life) sobre VisualAge Smalltalk. A finales de 1990 decidi apoyar Java y es, a partir de 2006, con el apoyo de Instantiations, Inc., que se ha cambiado el nombre del producto VA Smalltalk y lanzado varias versiones nuevas. La aplicacin open source Squeak cuenta con una comunidad activa de desarrolladores, incluyendo muchos de la comunidad original Smalltalk, y se ha utilizado recientemente para proporcionar el ambiente Etoys en el proyecto OLPC, un
Pgina 5

Smalltalk conjunto de herramientas para el desarrollo de aplicaciones de colaboracin de proyecto Croquet, y la aplicacin en el mundo virtual de open Cobalt . GNU Smalltalk es una implementacin de software libre de un derivado de Smalltalk80 del proyecto GNU. Por ltimo, pero no menos importante Pharo Smalltalk (un tenedor de Squeak orientado hacia la investigacin y uso en entornos comerciales) una nueva y limpia MIT licencia de cdigo abierto Smalltalk que trae ideas frescas y de inters en el mercado de Smalltalk. Una novedad importante, que se ha extendido en todos los entornos Smalltalk actuales, es la creciente utilizacin de dos frameworks web, Seaside y AIDA / Web, para simplificar la creacin de aplicaciones web complejas. Seaside ha visto un inters considerable mercado con Cincom, Gemastone y Instantiations incrementando su extensin.

Pgina 6

Smalltalk

2 . Arquitectura
Podemos decir que Smalltalk es un sistema ms all que un lenguaje de programacin. La arquitectura de un sistema Smalltalk est basada en varios componentes: una Mquina Virtual, una Imagen y el propio cdigo Smalltalk. La mquina virtual es quin se encarga de la ejecucin de las aplicaciones en Smalltalk y trabaja con una imagen. Al iniciar una aplicacin lo primero que hace Smalltalk es levantar su imagen. Cabe aclarar que el desarrollo en Smalltalk est basado en su imagen y no en archivos. Por ejemplo, cuando un programador desarrolla una aplicacin en C o JAVA organiza cada componente de su cdigo en archivos. Esto no pasa en Smalltalk. Cuando un programador desarrolla una aplicacin en Smalltalk va a trabajar sobre una imagen nica en la cual va a escribir las distintas clases que hacen al sistema en s. Todo va a estar guardado en la imagen y dicha imagen es lo que se va a estar ejecutando. 2.1 . Imagen

Qu es la imagen de Smalltalk? Es un archivo que contiene todos los estados de los objetos del sistema. A continuacin describiremos brevemente como est compuesta la imagen de Smalltalk. Librera de clases en cdigo binario. Estructura de datos. Interfaz de usuario. Herramientas de desarrollo. Es independiente de la maquina virtual. Representa el estado actual del sistema como una coleccin de objetos siendo creados, destruidos y modificados. System browser permite examinar y modificar las clases contenidas en la imagen.

2.2 . Mquina Virtual

De qu se encarga?
Pgina 7

Smalltalk Interprete de programas escritos en lenguaje Smalltalk. Manejo de memoria (object memory). Recoleccin de basura. Existe un modelo de intrprete, el cual se puede tomar como base para implementar nuestra propia maquina virtual. A continuacin enumeramos una serie de ejemplos de las distintas Mquinas Virtuales desarrolladas para Smalltalk: Tektronix Smalltalk Berkeley Smalltalk Squeak DEX VAX

Pgina 8

Smalltalk

3 . Caractersticas
En esta seccin, desarrollaremos las principales caractersticas del lenguaje explicando brevemente cada una y haciendo nfasis en las que consideramos las ms importantes del lenguaje. Smalltalk posee las siguientes caractersticas: Es la representacin ms pura de los lenguajes orientados a objetos. TODO es un objeto No hay tipos primitivos Las variables son objetos Los bucles y las clases tambin son objetos

Tipado dinmico Esto significa que una misma variable puede tomar valores de distinto tipo en distintos momentos. Compilacin en tiempo de ejecucin o distribucin o del proveedor) interpretado (depende de la

Smalltalk es un sistema que usa compilacin a bytecode, como tambin la utilizan por ejemplo Perl, GNU CLISP o las primeras versiones de Java, el cdigo fuente es traducido a un cdigo intermedio llamado bytecode. El bytecode no es el cdigo mquina de ninguna computadora en particular, y puede por tanto ser portable entre diferentes arquitecturas. El bytecode es entonces interpretado, o ejecutado por una mquina virtual. Aplica Herencia simple Posee un recolector de basura Ahondaremos sobre este tema ms adelante en este informe. Existen mltiples implementaciones A continuacin se muestra un listado de implementaciones ms conocidas del lenguaje de programacin Smalltalk, y una tabla comparativa de algunas caractersticas relevantes para cada implementacin:

Pgina 9

Smalltalk NOMBRE Ambrai AmigaTalk Digitalk Methods Dolphin GNU Smalltalk Little Smalltalk ENTORNO Interactivo Scripting Scripting Interactivo Interactivo Scripting PLATAFORMA Mac OS AmigaOS DOS Win32 Unix Unix, Win32 Win32 Unix, Win32 Win32 Palm OS Win32 Win32 Unix, Win32 Win32

LSW Vision-Smalltalk Interactivo Parla PDST Pocket Smalltalk Smalltalk Express Smalltalk MT Smalltalk/X SmallScript Squeak StepTalk Strongtalk VisualAge VisualSmalltalk Scripting Scripting Scripting Interactivo Interactivo Interactivo Interactivo

Interactivo Unix, Mac OS, Win32, WinCE, RISC OS Scripting Interactivo Interactivo Interactivo Unix, Win32 Win32 Unix, Win32, OS/2, z/OS, OS/390 Win32

Pgina 10

Smalltalk NOMBRE VisualWorks ENTORNO Interactivo PLATAFORMA Unix, Mac OS, Win32, WinCE

Interaccin de los objetos mediante el envo de mensajes Explicaremos cmo se realiza esta interaccin en la prxima seccin.

Pgina 11

Smalltalk

3.1 . Mensajes
Como mencionamos anteriormente en Smalltalk los objetos interactan mediante el envo de mensajes. Existen tres tipos de mensajes Unarios Binarios Palabra Clave

3.1.1 . UNARIOS (UNARY MESSAGE)

Los mensajes UNARIOS son el tipo de mensaje soportado por Smalltalk que ms prioridad de ejecucin tiene. Consiste de un nombre de mensaje y un operando. Los objetos se colocan antes del nombre del mensaje. Ejemplo:

3.1.2 . BINARIOS (BINARY MESSAGE)

Un mensaje binario puede ser de uno o dos caracteres de longitud. Son utilizados para especificar operaciones aritmticas, lgicas y de comparacin con cualquiera de los siguientes caracteres especiales:

:+ / \ * ~ < > = @ % | & ? ! ,

Ejemplo:

Pgina 12

Smalltalk 3.1.3 . PALABRA CLAVE (KEYWORD MESSAGE)

Son equivalentes a la invocacin de un procedimiento con al menos dos argumentos. Dentro de los tres tipos de mensajes, este es el que menos prioridad tiene. Se coloca primero el nombre del objeto al cual se enva el mensaje, luego el nombre del mensaje (o nombre del mtodo) y por ltimo el parmetro que se desea pasar.

Ejemplo:

Pgina 13

Smalltalk

3.2 . Herencia y Polimorfismo

Smalltalk es un lenguaje que soporta herencia simple. Esta caracterstica del lenguaje permite a una clase, tener el mismo comportamiento que otra clase, para luego cambiar ese comportamiento para ofrecer una extensin del mismo. La herencia es especialmente importante ya que dota al lenguaje de las caractersticas de reusabilidad y extensibilidad. A continuacin exponemos un ejemplo de cmo se declara una clase que hereda de otra en Pharo: EJEMPLO 1: Definicin de clase

3.2.1 Conceptos bsicos - Las clases que heredan su comportamiento de otras clases son llamadas subclases (subclass). - Las clases que delegan su comportamiento a otras son llamadas superclases (superclass) La herencia permite que el usuario extienda el programa existente para que realice las funciones que necesite. La jerarqua de herencias es ilimitada. Esto significa que las subclases pueden tener subclases que tambin tienen subclases. El siguiente diagrama muestra un ejemplo de herencia: EJEMPLO 2: Clases

Pgina 14

Smalltalk En este ejemplo la clase Persona posee los atributos nombre, direccin, telfono y soporta los mensajes nombre:, direccion:, telefono:. Las subclases Cliente y Vendedor soportaran estos mensajes y tendrn los mismos atributos ms los definidos por estas clases. 3.2.2 Jerarqua de clases en Smalltalk

EJEMPLO 3: Jerarqua

3.2.3 Herencia de mtodos

La herencia de mtodos es til para permitir a una clase modificar su comportamiento respecto de su superclase. Esto puede ser realizado agregando nuevos mtodos o redefiniendo los heredados. Hay que decir que en Smalltalk todos los mtodos son virtuales, esto significa que no es necesario anteponer ninguna palabra reservada como virtual (C++) para poder ser redefinido en una subclase.

Agregando mtodos Como dijimos anteriormente, se puede agregar mtodos de manera muy simple, incorporndolos, ya sean de instancia o de clase, en la definicin de la clase. Todo objeto de la subclase soporta los mtodos de su superclase, ms los nuevos mtodos. En el ejemplo anterior, la definicin de la clase Cliente podra querer gestionar los pedidos de los clientes. Entonces, la definicin de la clase deber agregar:
Pgina 15

Smalltalk pedidosCliente y agregarPedidoCliente. As la clase cliente soportar todos los mtodos de Persona ms los nuevos.

EJEMPLO 4: Agregacin de mtodos

Redefinicin de mtodos La redefinicin de un mtodo heredado es otra herramienta que los usuarios tienen para proveer de un comportamiento nico a una clase. Si un objeto recibe un mensaje que existe en la definicin de la clase, el objeto busca en la jerarqua hasta que encuentra el mtodo con ese nombre. Los mtodos heredados no pueden eliminarse. EJEMPLO 5: Mecanismo de redefinicin de mtodos

Pgina 16

Smalltalk

3.2.4 Herencia de variables

La jerarqua del lenguaje Smalltalk, ha sido diseada para que las subclases hereden de las variables de sus superclases. Las subclases tambin pueden poseer variables propias.

Variables de instancia Las variables de instancia se agregan a la clase colocndolas en la definicin de la clase. Los datos de la instancia se mantienen en un rea de datos creada por Smalltalk. En nuestro ejemplo todas las instancias de Cliente tienen las variables de instancia: nombre, direccion, telefono y pedidosCliente. EJEMPLO 6: Variables de instancia

Pgina 17

Smalltalk Variables de Clase Una variable de clase es una variable que es compartida por todos los objetos de la clase. Slo existe una copia de la variable de clase en la jerarqua local de clases. Todos los objetos de la clase referencian a esta nica copia de la variable. Las variables de clase tambin permiten compartir la informacin a travs de todas las subclases de la clase en que fueron declaradas. Tienen las mismas convenciones de nombramiento de las variables de clase, pero slo los mtodos de instancia pueden referirse a las variables de instancia. Relacin entre mtodos y variables de clase Los mtodos de instancia y los mtodos de clase pueden referirse a las variables de clase, pero slo los mtodos de instancia pueden referirse a las variables de instancia. A continuacin vemos un diagrama de esto: EJEMPLO 7: Diagrama de relacin

Variables de instancia de clase Este tipo de variables son como las variables de clase, excepto que cada subclase tiene su propia copia. Dado que es una variable privada, deben comenzar con minscula. Soportan el comportamiento de herencia, teniendo cada clase su propio estado de la variable. 3.2.5 Clases abstractas

Las clases abstractas proveen de un comportamiento comn a sus subclases, pero nunca tendrn sus propias instancias. Por ejemplo, si tengo la clase Persona como superclase de Cliente y Vendedor, la clase persona no tendr instancia en ningn momento pero delega su comportamiento. Otro ejemplo de
Pgina 18

Smalltalk una clase abstracta sera la clase Object. Si una clase posee un mtodo abstracto la clase ser abstracta. La declaracin de mtodo abstracto se realiza de la siguiente manera: EJEMPLO 9: Mtodo abstracto

Super y self El uso de super provoca que la bsqueda de un mtodo comience en la superclase del objeto receptor. Esta es la nica forma de que la clase pueda agregar comportamiento a los mtodos sin tener que reemplazarlos. A continuacin vemos un ejemplo donde para crear un objeto de una clase se llama al constructor de la superclase.: EJEMPLO 8: Super

Self hace que la bsqueda del mtodo comience en el mismo objeto receptor. Un ejemplo de este mensaje es cuando un objeto quiere enviarse a s mismo un mensaje.

Pgina 19

Smalltalk EJEMPLO 9: Self

3.2.6 Polimorfismo

El polimorfismo se da cuando objetos de distintas clases de una misma familia entienden los mismos mensajes . Los mtodos poseen el mismo significado pero las implementaciones son diferentes. Un mismo mensaje puede provocar la invocacin de mtodos distintos. Smalltalk utiliza el concepto de vinculacin tarda, es decir que se retarda la decisin sobre el mtodo a llamar hasta el momento en que vaya a ser utilizado. Un ejemplo de polimorfismo es el siguiente: EJEMPLO 10: Polimorfismo

Pgina 20

Smalltalk

3.3 . Clases y Metaclases

Smalltalk todo es un objeto, y cada objeto es instancia de alguna clase. Las clases no son ninguna excepcin: las clases son objetos, y dichos objetos son instancias de otras clases. Este modelo captura la esencia de la programacin orientada a objetos: Es ligero, sencillo, elegante y uniforme. Sin embargo, las consecuencias de esta uniformidad pueden llegar a confundir. 3.3.1 Problema Huevo o la Gallina? Pensando en el modelo de objetos de Smalltalk (todo es un objeto) podemos realizar las siguientes afirmaciones: Todo es un objeto Todo objeto tiene una clase Una clase es un objeto Una clase tiene una clase

Entonces.. Quin es la clase de una clase?

Esta pregunta la responderemos en las siguientes secciones.

3.3.2. Reglas para clases y metaclases Regla 1. Todo es un objeto. Regla 2. Todo objeto es instancia de una clase. Regla 3. Toda clase tiene una superclase. Regla 4. Todo ocurre mediante el envo de mensajes. Regla 5. La bsqueda de mtodos sigue la cadena de herencia. Una consecuencia de la Regla 1 es que las clases tambin son objetos, de modo que la Regla 2 nos dice que las clases deben ser tambin instancias de otras clases. Llamaremos metaclase a la clase de una clase. Una metaclase se crea automticamente cuando se crea una clase. La mayora de las veces no
Pgina 21

Smalltalk hace falta preocuparse de las metaclases. Una clase y su metaclase son dos clases distintas, aunque la primera sea una instancia de la segunda. Para poder explicar las clases y las metaclases adecuadamente, necesitamos extender las reglas con las siguientes: Regla 6. Toda clase es instancia de una metaclase. Regla 7. La jerarqua de metaclases tiene la misma estructura que la jerarqua de clases. Regla 8. Toda metaclase hereda de Class y de Behavior. Regla 9. Toda metaclase es instancia de Metaclass. Regla 10. La metaclase de Metaclass es instancia de Metaclass. Estas 10 reglas definen el modelo de objetos de Smalltalk. A continuacin haremos referencia a algunas de las reglas ms importantes mencionadas anteriormente. 3.3.3. Regla 6: Toda clase es instancia de una metaclase

Las metaclases son implcitas. Las metaclases se crean automticamente cuando se define una clase. Decimos que son implcitas, ya que el programador nunca tiene por qu preocuparse por ellas. Una metaclase implcita es creada por cada clase que se crea, de modo que cada metaclase tiene una sola instancia. Mientras que los nombres de las clases normales son variables globales, las metaclases son annimas. Sin embargo siempre podemos referirnos a las metaclases usando las clases que son sus instancias. La clase de Color, por ejemplo, es Color class, y la clase de Object es Object class: Color class ! Color class Object class ! Object class

3.3.4. Regla 7: La jerarqua de metaclases tiene la misma estructura que la jerarqua de clases La Regla 7 nos dice que la superclase de una metaclase no puede ser una clase arbitraria. Est constreida por la metaclase de la superclase de la nica instancia de la metaclase. TranslucentColor class superclass ! Color class TranslucentColor superclass class ! Color class Esto es lo que queremos decir cuando decimos que la jerarqua de metaclases tiene la misma estructura que la jerarqua de clases. TranslucentColor class ! TranslucentColor class
Pgina 22

Smalltalk TranslucentColor class superclass ! Color class TranslucentColor class superclass superclass ! Object class Uniformidad entre Clases y Objetos. Es interesante tomarse un momento para ver las cosas con cierta perspectiva: No hay ninguna diferencia entre enviar un mensaje a un objeto y a una clase. En ambos casos la bsqueda del mtodo correspondiente empieza en la clase del receptor, y posteriormente sigue la cadena de herencia. As pues, los mensajes enviados a clases deben seguir la cadena de herencia de las metaclases. 3.3.5 Regla 10: La metaclase de Metaclass es instancia de Metaclass

Cul es la clase de Metaclassclass? La respuesta es sencilla: Es una metaclase, de modo que debe ser una instancia de Metaclass, como el resto de metaclases del sistema.

Los siguientes ejemplos muestran cmo podemos obtener informacin de la jerarqua de clases

Ejemplo: La jerarqua de clases TranslucentColor superclass ! Color Color superclass ! Object Ejemplo: La jerarqua paralela de metaclases TranslucentColor class superclass ! Color class Color class superclass ! Object class
Pgina 23

Smalltalk Object class superclass superclass ! Class "NB: skip ProtoObject class" Class superclass ! ClassDescription ClassDescription superclass ! Behavior Behavior superclass ! Object Ejemplo: Instancias de Metaclass TranslucentColor class class ! Metaclass Color class class ! Metaclass Object class class ! Metaclass Behavior class class ! Metaclass Ejemplo: Metaclass class es una Metaclass Metaclass class class ! Metaclass Metaclass superclass ! ClassDescription 3.3.6 Resumen Toda clase es instancia de una metaclase. Las metaclases son implcitas. Una metaclase se crea automticamente cuando se crea la clase que es su nica instancia. La jerarqua de metaclases tiene la misma estructura que la jerarqua de clases. La bsqueda de mtodos para las clases sigue el mismo procedimiento que sigue en los objetos corrientes, y asciende por la cadena de superclases de la metaclase. Toda metaclase hereda de Class y de Behavior. Toda clase es una Class como las metaclases tambin son clases, deben heredar de Class.Behavior proporciona comportamiento comn a todas las entidades capaces de tener instancias. Toda metaclase es instancia de Metaclass. ClassDescription proporciona todo aquello que es comn a Class y a Metaclass. La metaclase de Metaclass es instancia de Metaclass. La relacin instancia de forma un ciclo, de modo que Metaclass class class ! Metaclass.

Pgina 24

Smalltalk

3.4 . Reflexin
Smalltalk es un lenguaje de programacin con reflexin computacional. En pocas palabras, quiere decir que los programas son capaces de reflexionar sobre su propia ejecucin y estructura. En un sentido ms tcnico, esto significa que los metaobjetos del sistema en tiempo de ejecucin pueden reificarse como objetos ordinarios, a los cuales se puede consultar e inspeccionar. Los metaobjetos en Smalltalk son las clases, metaclases, diccionarios de mtodos, mtodos compilados, la pila al momento de ejecucin, y otros. Esta forma de reflexin tambin se denomina introspeccin, y muchos lenguajes modernos de programacin la permiten.

En el sentido contrario, en Smalltalk resulta posible modificar los metaobjetos reificados y reflejar esos cambios de vuelta al sistema en ejecucin. Esta actividad tambin se denomina intercesin. La intercesin est presente principalmente en los lenguajes de programacin dinmicos mientras que los lenguajes estticos slo la admiten en un grado muy limitado. Un programa que manipula otros programas (o se manipula a s mismo) es un metaprograma. Para que un lenguaje de programacin sea capaz de reflexin computacional debe permitir tanto la introspeccin como la intercesin. La introspeccin es la capacidad de examinar las estructuras de datos que definen el lenguaje, como los objetos, clases, mtodos y la pila de ejecucin. La intercesin es la capacidad de modificar dichas estructuras, o sea, de alterar la semntica del lenguaje y el comportamiento del programa desde el interior del propio programa. La reflexin estructural examina y modifica la estructura del sistema de tiempo de ejecucin y la reflexin de comportamiento modifica la interpretacin de esas estructuras. 3.4.1 Ejemplos

Podemos inspeccionar los detalles de implementacin de una clase.

Pgina 25

Smalltalk 1) Obtener los nombres de variables de instancia definidos por clase

2) Obtener los nombres de los mtodos implementados por la clase

3) Obtener un mtodo con un selector dado

Como respuesta obtenemos el mtodo asociado al mensaje selector #size en el diccionario de mtodos de la clase OrderedCollection. 4) Obtener el cdigo fuente del mtodo con un selector dado

Obtenemos el cdigo fuente del mtodo llamado #size en la clase OrderedCollection Tambin podemos agregar dinmicamente un nuevo mtodo a alguna clase mediante la siguiente sentencia:

Por ejemplo:

Y podemos borrar el mtodo que agregamos anteriormente, ejecutando:

Pgina 26

Smalltalk

Pgina 27

Smalltalk

4. Estructuras de control
A diferencia de la mayora de los lenguajes, Smalltalk implementa todas las estructuras de control de flujo del programa a travs del envo de mensajes a distintos tipos de objetos, dependiendo estos de la estructura. Se ve como claramente el lenguaje plasma su filosofa en este aspecto. 4.1 Selectivas/Alternativas:

En estructuras de este tipo, los mensajes son enviados a objetos de las clases TRUE o FALSE. Es decir que el camino que tome la ejecucin del programa, depender de la clase de la cual es instancia el objeto que representa a la expresin. El mensaje enviado al objeto booleano va acompaado de un bloque sin argumentos. Este bloque ser ejecutado en caso que el objeto sea de la clase correspondiente. Los mensajes para poder realizar una accin de seleccin o de alternativa que se utilizan son ifTrue, ifFalse e ifTrue: ifFalse. Si se utiliza alguno de los dos primeros, llamaremos a la estructura, control condicional simple, y en el caso de usar el tercero, control condicional compuesto. Ejemplos: - ifTrue: (20 > 10) ifTrue: [transcript show: 'Esto es verdadero']. - IfFalse: (13 > 20) ifFalse: [transcript show: 'Esto es falso']. - ifTrue: ifFalse: (20 > 12) ifTrue: [transcript show: 'Esto es verdadero'] ifFalse: [trasncript show: 'Esto es falso'].

4.2 Iteracin/Repeticin

En el caso de estas estructuras, los mensajes pueden ser enviados a tres clases de objetos distintos, Number, BlockContext y Collection. En general si se le enva a un objeto Number, este representa la cantidad de veces que se debe iterar o entre que rango de elementos. En el caso del envo a objetos
Pgina 28

Smalltalk BlockContect, normalmente es para realizar un bucle while, en el cual no hay una cantidad defina de iteraciones. Y en el caso de enviarlos a una Collection, ser para recorrerlas y tratar determinados elementos, u obtener cierta informacin de la misma. Los mensajes para realizar repeticiones e iteraciones ms comunes son to: do, to: by: do, timesRepeat, whileTrue, whileFalse y otros especiales de las colecciones. Ejemplos: - to: do: y to: by: do: |unArreglo| UnArreglo := Array new: 10. 1 to: 10 do: [:j | unArreglo at: j put: 0.0]. 1 to: 10 by: 2 do: [:j | unArreglo at: j put: 3.0]. - timesRepeat |suma| suma := 0 4 timesRepeat: [suma := suma + 5] - whileTrue: |vocales string indice| Vocales := 0. Indice := 0. String := String de prueba. [indice <= string size] WhileTrue: [ (string at: indice) isVowel ifTrue: [vocales := vocales + 1]. Indice := indice +1]. - Mtodos sobre colecciones |string cuenta| String := Cadena de prueba. Cuenta := 0. string DO: [:caracter | caracter isUppercase ifTrue: [ cuenta := cuenta + 1 ] ]. *Por cada carcter de la coleccin realiza un bloque de acciones, en este caso cuenta las mayusculas.
Pgina 29

Smalltalk string COLLECT: [:caracter | caracter asUppercase ]. *Para cada uno de los elementos del receptor se evala el bloque con ese elemento como parmetro, y devuelve una nueva coleccin formada por el resultado de esas evaluaciones. string SELECT: [:caracter | caracter isUppercase ]. *Crea y retorna una subcoleccin de los elementos del receptor, que verifican la expresin booleana final del bloque. Es decir que la expresin debe ser booleana. string REJECT: [:caracter | caracter isUppercase ]. *Crea y retorna una subcoleccin de los elementos del receptor que no verifiquen la expresin booleana final del bloque. Es decir que la expresin debe ser booleana. string DETECT: [:caracter | caracter isUppercase ]. *Devuelve el primer elemento de la lista que verifique la expresin booleana final del bloque.

Pgina 30

Smalltalk

5. Manejo de excepciones
En Smalltalk, si le enviamos un mensaje a un objeto y este no puede responderlo, reacciona envindonos una excepcin. Para esto, la clase Object tiene definido el mtodo error, por lo tanto todos los objetos definidos saben como responder a este mensaje. En cualquier objeto este mtodo puede ser redefinido o definir nuevos mtodos para nuevos tipos de errores, para que su comportamiento se amolde ms al dominio de nuestro problema. Siguiendo los principios del lenguaje, una excepcin tambin es un objeto, el cual es lanzado desde un mtodo. Al ser objetos, se acceden mediante variables que los referencian y tienen estado, comportamiento e identidad, definidos por sus atributos y mtodos. 5.1. Qu hacer con las excepciones? Podemos no hacer nada, y de esta manera, la excepcin ira subiendo las capas del programa hasta llegar a la principal, donde se puede cortar la ejecucin. Atraparla, hacer algo y continuar con el flujo normal de ejecucin. Atraparla, hacer algo y volver a lanzar la misma excepcin. Eso se puede hacer mandando retry al error atrapado en el bloque que maneja el problema, para ver si se soluciono el problema. Atraparla y lanzar otra ms adecuada agregando ms informacin del problema.

A continuacin se muestran dos ejemplos en los cuales hay una excepcin que no es atrapada y corta la ejecucin, y otra que s es atrapada y solucionada para continuar normalmente. 1) excepcin. 2) [ 12/n ] on: Exception do: [:e | n := n + 1. Transcript show: e messageText. e retry.] *Captura de la excepcin y recuperacin del error. N := 0. X := 12/N.

*Aca se corta la ejecucin al no ser atrapada la

Pgina 31

Smalltalk 5.2. Jerarqua de excepciones

5.3. Excepciones propias Smalltalk permite expandir la jerarqua de excepciones para que estas sean acordes al dominio del problema. Esto es una gran ventaja ya que sin esta funcionalidad, solo se podran distinguir las excepciones del kernel y tendramos que adecuar los errores, que puedan surgir durante la ejecucin del programa, a las mismas. Si bien algunas excepciones ya predefinidas son de utilidad, estas no llegan a cubrir todos los tipos de problemas particulares de nuestra aplicacin. Por ejemplo en un programa donde se tenga que ocupar vacantes en un avin de pasajeros sera muy poco representativo hacer lo siguiente:

[pasajero asignarAsiento: vuelo1] on: Exception do: [:error | Transcript show: error messageText ] Cualquier error que surga en el mtodo asignarAsiento nos lanzar una excepcin, pero no sabremos a que tipo de excepcin corresponde, por lo tanto no se pueden tomar distintas medidas en base a la clase de error. La versatilidad del lenguaje en este aspecto nos permite hacer lo siguiente: Definir la excepcin particular, heredando de la clase Exception, o de cualquier otra que herede de la misma Exception subclass: #NoHayVacanteError Redefinir el mtodo error en la clase pasajero o definir otro mtodo que devuelva la excepcin definida Definir en el mtodo correspondiente cuando puede surguir el error

Pgina 32

Smalltalk
Pasajero >> aginarAsiento: unVuelo [unVuelo hayVacantes] IfFalse: [ self error: 'No quedan vacantes en el vuelo'.] UnVuelo ocuparVacante.

Aplicacin
[ pasajero asignarAsiento: vuelo] on: NoHayVacanteError do: [:error | Transcript show: error messageText.]

Pgina 33

Smalltalk

6. Concurrencia
Smalltalk soporta multithreading desde los inicios. Para ello cuenta con una variedad de clases para hacer computacin concurrente de forma sencilla. En este trabajo se aborda principalmente como maneja este aspecto la implementacin Smalltalk-80. Las clases ms importantes para realizarla son Process, semaphore y processorScheduler. Si bien no son los nicas son la base para permitir desarrollar esta funcionalidad. Aqu la maquina virtual cumple un rol importante, ya que es la encargada de llevar a cabo realmente las acciones representadas por los procesos en el sistema. 6.1 Process Un proceso representa una secuencia de acciones que pueden llevarse a cabo de forma independiente de las acciones representadas por otros procesos. Estos procesos que se ejecutan en paralelo, son objetos que poseen una prioridad, la cual puede asignarse en un principio e ir modificndose a lo largo de la ejecucin. Como su nombre lo dice, describe la importancia que tiene ese proceso por sobre los dems. La manera ms comn de crear un proceso es de la siguiente manera: | bloqueAcciones proceso | bloqueAcciones := [Transcript show: 'Proceso']. proceso := bloqueAcciones fork. Para poder manejarlos se tienen distintos mtodos, siendo los mas importantes: Suspend, Resume y Terminate. El primero, al ser recibido por el objeto que representa al proceso, suspende la ejecucin, pudiendo ser retomada en el caso de que el proceso reciba el mensaje Resume, que lo que hace es justamente lo contrario a Suspend. En el caso de que un proceso reciba el mensaje Terminate, este proceso se cancela definitivamente.

6. 2 Semaphore El semforo es el objeto que acta como mediador entre un proceso y el entorno del mismo en el problema ya que proporcionan una forma simple de comunicacin sincrnica. A su vez, este objeto es parte de otro proceso independiente. Normalmente llegados ciertos momentos, un proceso puede necesitar la realizacin de alguna actividad para continuar su ejecucin. Ejemplos de estas pueden ser: Ingresar datos por teclado o hacer un click. En este escenario la tarea del semforo es recibir el aviso de un objeto, perteneciente a un proceso, de que necesita que se realice determinada
Pgina 34

Smalltalk actividad para continuar. Mientras el este proceso se suspende momentneamente, el semforo espera que del entorno se le enve una seal para dar por confirmada la realizacin de la actividad, para finalmente enviarle el mensaje de Resume al proceso para que se reanude. A continuacin se muestra un esquema del funcionamiento de este sistema.

Los mensajes ms importantes que reciben los semaforos son: Wait y Signal. El primero es el que llega del objeto que necesita cierto requerimiento para continuar y el segundo llega desde el entorno para avisar que ya se cumpli con ese requerimiento.

6.3 ProcessorScheduler El processorScheduler tambin es parte de otro proceso independiente, y solo hay una instancia de este. Es quien decide que proceso se llevar a cabo en un determinado momento y luego se comunica con la maquina virtual para que esta lleve a cabo efectivamente las tareas representadas por los procesos. Como existen muchos procesos que estn en condiciones de realizase al recibir mensajes, este debe decidir cual es que se realizar en primer lugar. Adems un proceso, normalmente, no puede ejecutar las tareas de manera inmediata. En este escenario processorScheduler debe identificar cuales son los procesos activos en dicho momento, y suspenderlos o terminarlos, en caso de que haga falta, para luego seleccionar un proceso con tareas pendientes.

6.4 Ejemplo concurrencia

| putSemaphore getSemaphore sharedPlace putBlock getBlock supplier1 supplier2 consumer process1 process2 process3 | putSemaphore := Semaphore new signal. getSemaphore := Semaphore new. sharedPlace := nil.

Pgina 35

Smalltalk

putBlock := [:smalltalk | putSemaphore wait. sharedPlace := smalltalk. getSemaphore signal]. getBlock := [| smalltalk | getSemaphore wait. smalltalk := sharedPlace. putSemaphore signal. Smalltalk]. supplier1 := [ [| smalltalk | (Delay forSeconds: 3) wait. smalltalk := 'VisualWorks'. putBlock value: smalltalk. Transcript crtab: 1; show: 'put ' , smalltalk] repeat]. supplier2 := [ [| smalltalk | (Delay forSeconds: 2) wait. smalltalk := 'ObjectWorks'. putBlock value: smalltalk. Transcript crtab: 2; show: 'put ' , smalltalk] repeat]. consumer := [ [| smalltalk | (Delay forSeconds: 1) wait. smalltalk := getBlock value. Transcript crtab: 3; show: 'get ' , smalltalk] repeat]. Transcript cr; show: 'start simulation'. process1 := supplier1 fork. process2 := supplier2 fork. process3 := consumer fork. (Delay forSeconds: 30) wait. process1 terminate. process2 terminate. process3 terminate. Transcript cr; show: 'end simulation'

Pgina 36

Smalltalk

7 Manejo de memoria
7.1 Object Memory

La object memory proporciona el intrprete con una interfaz para los objetos que componen la imagen virtual de Smalltalk-80. Cada objeto est asociado con un identificador nico llamado su object pointer. La memoria del objeto y el intrprete se comunican acerca de los objetos con los object pointer. El tamao de los object pointer determina el nmero mximo de objetos de un sistema de Smalltalk-80 puede contener. Este nmero no es fijo, no tiene que ver con el lenguaje, pero la implementacin que se describe utiliza punteros a objetos de 16 bits, permitiendo que 65.536 objetos sean referenciados. La implementacin del sistema Smalltalk-80, con referencias a objetos ms grandes ser necesario cambiar ciertas partes de la especificacin de la mquina virtual. La object memory asocia cada puntero de objeto con un conjunto de otros punteros a objetos. Cada puntero de objeto est asociado con el puntero del objeto de una clase. Si un objeto tiene variables de instancia, el object pointer tambin est asociado con los object pointer de sus valores. El valor de una variable de instancia se puede cambiar, pero la clase asociada con un objeto no se puede cambiar. La object memory proporciona las cinco funciones fundamentales siguientes para el intrprete: 1. 2. 3. 4. 5. Acceder al valor de la variable de instancia de un objeto. Cambie el valor de la variable de instancia de un objeto. Acceda a la clase de un objeto. Crear un nuevo objeto. Encontrar el nmero de variables de instancia de un objeto que tenga.

No existe una funcin explcita de la object memory de sacar un objeto, ya no se utiliza debido a que estos objetos se recuperan automticamente. Un objeto se reclama cuando no hay punteros a objetos de otros objetos. Esta recuperacin se puede lograr mediante recuento de referencia o la recoleccin de basura. 7.2 Almacenamiento Heap

En una implementacin de la memoria real de Smalltalk, todos los objetos se guardan en un rea llamada heap. Un nuevo objeto es creado mediante la obtencin de espacio para almacenar sus campos en una serie contigua de palabras en el heap. Un objeto se destruye liberando el espacio de almacenamiento dinmico que ocupaba. Los datos reales del objeto son precedidos por un encabezado de dos palabras. El campo de tamao del encabezado indica el nmero de palabras de almacenamiento dinmico que

Pgina 37

Smalltalk ocupa el objeto, incluyendo el encabezado. Se trata de un nmero de 16 bits sin signo, y puede variar desde 2 hasta 65.535. 7.3 Compactacin Supongamos por un momento que un objeto una vez asignado nunca cambia su ubicacin en el heap. Para asignar un nuevo objeto, el espacio entre los objetos existentes debe ser lo suficientemente grande como para contener el nuevo objeto. Despus de un tiempo, la memoria se fragmenta. Es decir, una solicitud de asignacin est obligada a llenar a un espacio ms pequeo que la memoria total disponible, pero ms grande que cualquiera de los pedazos disjuntos. Esto puede ocurrir incluso si hay una gran cantidad de espacio disponible y una peticin de asignacin relativamente pequea. La fragmentacin no se puede tolerar en un sistema interactivo, que se espera para preservar un entorno dinmico para cientos de horas o ms, sin reinicializacin. Por lo tanto cuando la memoria se fragmenta, debe ser compactada. La memoria se compacta moviendo todos los objetos que todava estn en uso hacia un extremo de la pila, exprimiendo todo el espacio libre entre ellos y dejando un bloque no asignado grande en el otro extremo. 7.4 La tabla de objetos

Cuando un objeto se mueve durante la compactacin, todos los indicadores de la memoria heap deben actualizarse. Si muchos otros objetos contienen punteros directamente a la ubicacin antigua, entonces es mucho tiempo en un equipo secuencial para encontrar y actualizar esas referencias para que apunte a la nueva ubicacin. Por lo tanto, para que la actualizacin del puntero no sea costosa, slo se permite un puntero a la memoria heap de un objeto. Ese puntero se almacena en una tabla llamada la tabla de objetos. Todas las referencias a un objeto deben pasar a travs de la tabla de objetos. Por lo tanto, los object pointer que se encuentran en los objetos de Smalltalk son realmente los ndices en la tabla de objetos.

7.5 Object Pointer

La forma que utiliza Smalltalk para diferenciar un object pointer de un smallinteger es que en puntero de 16 bits, si el bit de orden de inferior es un 0, los 15 bits siguientes son un ndice en la tabla de objetos (lo cual nos dice que podemos direccionar 2^15 objetos en este caso); en cambio si ese mismo bit es un 1, los primeros 15 bits inmediatos son un entero con signo, sin agregar espacio adicional en tabla de objetos o en el heap. La ventaja de darle este trato a los smallintegeres que se usan con mucha frecuencia en operaciones aritmticas y muchas otras operaciones. La desventaja del mismo es el costo que tiene el intrprete de Smalltalk a la hora de testear si es un puntero o un entero.
Pgina 38

Smalltalk

8. Recoleccin de basura
En Smalltalk no es necesario desalocar objetos explcitamente, por lo tanto no proporciona mecanismos para ello. Las implementaciones utilizan tcnicas de recoleccin de basura para detectar y reclamar espacio en memoria asociado con objetos que ya no se utilizarn ms en el sistema. En Smalltalk la recoleccin de basura es integrada configurable. La forma de ejecucin del recolector de basura es en background, es decir, como un proceso de baja prioridad no interactivo, aunque en algunas implementaciones es posible ejecutarlo a demanda, siendo posible definir configuraciones de memoria especiales para cada sistema mediante polticas (por ejemplo en VisualWorks). La frecuencia y caractersticas de la recoleccin dependen de la tcnica utilizada por la implementacin. Hay dos enfoques tradicionales para la identificacin de objetos inaccesibles: Mark-and-Sweep y Reference Counting. El primero lo que hace justamente es marcar todas los objetos que son accesibles, despus busca todos los objetos que no estn marcados, por lo tanto son inaccesibles y desalocarlos, liberando el espacio ocupado. El problema de este, cuando la memoria se agota este debe ser realizado, entonces, la ejecucin del programa est sujeta a un nmero relativamente largas interrupciones que pueden ser muy molestos en un sistema interactivo. El segundo mantiene un recuento de cuntas referencias hay a cada objeto de otros objetos. Cuando el recuento de referencias a algn objeto llega a cero, ese objeto se sabe que es inaccesible, y el espacio que ocupa puede ser reclamado. Desventajas del mismo es que no soporta estructuras cclicas (objetos referenciados a si mismo directamente o indirectamente).

Pgina 39

Smalltalk

9. Implementaciones
A continuacin se enumeran algunas implementaciones del lenguaje Smalltalk: Pharo Squeak Dolphin GNU Smalltalk Visual Works Pocket Smalltalk

10. Bibliografa
http://smalltalk.org/main/ Smalltalk-80, Adele Goldberg and David Robson The Released Laboratory - http://released.info.ucl.ac.be/ http://en.wikipedia.org/wiki/Smalltalk Sobre Reflexin http://released.info.ucl.ac.be/courses/r+cop/material/04-TReflection%20in%20Smalltalk.pdf Pharo By Example - http://pharobyexample.org/es/PBE1-sp.pdf Google

Pgina 40