informe smalltalk
TRANSCRIPT
75.24 Teoría de la Programación
75.31 Teoría de Lenguajes
Smalltalk
Integrantes:
Ignacio Bayetto
Francisco Di Salvo
Ignacio De Zan
Smalltalk
Página 2
Contenido 1 . Historia ..................................................................................................................................4
2 . Arquitectura...........................................................................................................................7
2.1 . Imagen ...........................................................................................................................7
2.2 . Máquina Virtual .............................................................................................................7
3 . Características......................................................................................................................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 básicos ................................................................................................14
3.2.2 Jerarquía de clases en Smalltalk .........................................................................15
3.2.3 Herencia de métodos ............................................................................................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 jerarquía de metaclases tiene la misma estructura que la
jerarquía de clases ..........................................................................................................22
3.3.5 Regla 10: La metaclase de Metaclass es instancia de Metaclass ..................23
3.3.6 Resumen .................................................................................................................24
3.4 . Reflexión ......................................................................................................................25
3.4.1 Ejemplos .................................................................................................................25
4. Estructuras de control .........................................................................................................28
4.1 Selectivas/Alternativas: ...............................................................................................28
4.2 Iteración/Repetición .....................................................................................................28
5. Manejo de excepciones......................................................................................................31
5.1. ¿Qué hacer con las excepciones? ............................................................................31
5.2. Jerarquía de excepciones ...........................................................................................32
5.3. Excepciones propias ...................................................................................................32
Smalltalk
Página 3
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 Compactación ................................................................................................................38
7.4 La tabla de objetos .......................................................................................................38
7.5 Object Pointer ................................................................................................................38
8. Recolección de basura .......................................................................................................39
9. Implementaciones ...............................................................................................................40
10. Bibliografía .........................................................................................................................40
Smalltalk
Página 4
1 . Historia
La palabra Smalltalk es usualmente utilizada para indicar el lenguaje de
programación Smalltalk-80, la primera versión disponible públicamente y
creada en 1980.
Smalltalk fue el producto de una investigación 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
versión, conocida como Smalltalk-71, fue creada por Ingalls en una apuesta por
lograr que un lenguaje de programación basado en el pasaje de mensajes,
inspirado en Simula, pudiera ocupar sólo “una página de código”. Una versión
posterior y ahora conocida como Smalltalk-72 fue utilizada para investigación e
influenciada por el desarrollo del modelo de actores (“Actor Model”). Su sintaxis
y modelo de ejecución cambiaron mucho en las posteriores versiones de
Smalltalk.
Luego de significativas revisiones, las cuales congelaron algunos aspectos de
la ejecución semántica para ganar performance (adoptando un modelo de
ejecución de clases y herencia parecido al de Simula), se creó Smalltalk-76.
Este sistema tenía un ambiente de desarrollo que ofrecía la mayoría de las
herramientas de desarrollo que hoy conocemos (incluyendo una biblioteca de
clases de navegador de código / 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 versión 1 otorgada a un pequeño número de firmas
(Hewlett-Packard, Apple Computer, Tektronix y DEC) y a universidades (UC
Berkeley) para “revisión por pares” e implementación de sus plataformas.
Luego, en 1983, una implementación pública conocida como Smalltalk-80
Version 2, fue lanzada como una imagen (archivo -plataforma independiente
con definición de objetos) y una especificación de la máquina virtual. ANSI
Smalltalk ha sido la referencia estándar del lenguaje desde 1998.
Dos de las más populares implementaciones de Smalltalk son descendientes
de la imagen original de Smalltalk-80. Squeak es una implementación open
source basada en Smalltalk-80 Version 1 a través de Apple Smalltalk.
VisualWorks es otra implementación basada en Smalltalk-80 versión 2 a través
de Smalltalk-80 2.5 y ObjectWorks (ambos productos de ParcPlace Systemas,
una compañía derivada de Xerox PARC para lanzar Smalltak al mercado).
Smalltalk
Página 5
Cabe destacar que en 2002 Vassili Bykov implementó Hobbes, una máquina
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 compañías: 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
corrían 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
ejecución, 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 penetración en el mercado a las
organizaciones comerciales de tamaño medio y grande, los productos Digitalk
trataron comercializar a un precio más bajo para intentar llegar a una audiencia
más 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 más popular en Europa, ya que IBM priorizó el desarrollo
en sus departamentos de TI antes que el desarrollo de IBM Smalltalk (más
tarde VisualAge). Más 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 razón de su
disolución fue que esta fusión de empresas nunca pudo encontrar una solución
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. Aún es dueña
de VisualSmalltalk, aunque los derechos de la distribución 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 aplicación 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
Smalltalk
Página 6
conjunto de herramientas para el desarrollo de aplicaciones de colaboración de
proyecto Croquet, y la aplicación en el mundo virtual de open Cobalt . GNU
Smalltalk es una implementación de software libre de un derivado de Smalltalk-
80 del proyecto GNU. Por último, pero no menos importante Pharo Smalltalk
(un tenedor de Squeak orientado hacia la investigación y uso en entornos
comerciales) una nueva y limpia MIT licencia de código abierto Smalltalk que
trae ideas frescas y de interés en el mercado de Smalltalk.
Una novedad importante, que se ha extendido en todos los entornos Smalltalk
actuales, es la creciente utilización de dos frameworks web, Seaside y AIDA /
Web, para simplificar la creación de aplicaciones web complejas. Seaside ha
visto un interés considerable mercado con Cincom, Gemastone y Instantiations
incrementando su extensión.
Smalltalk
Página 7
2 . Arquitectura
Podemos decir que Smalltalk es un sistema más allá que un lenguaje de
programación. La arquitectura de un sistema Smalltalk está basada en varios
componentes: una Máquina Virtual, una Imagen y el propio código Smalltalk.
La máquina virtual es quién se encarga de la ejecución de las aplicaciones en
Smalltalk y trabaja con una imagen. Al iniciar una aplicación 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 aplicación en C o JAVA organiza cada componente
de su código en archivos. Esto no pasa en Smalltalk. Cuando un programador
desarrolla una aplicación 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 continuación describiremos brevemente como está compuesta la imagen de
Smalltalk.
Librería de clases en código binario.
Estructura de datos.
Interfaz de usuario.
Herramientas de desarrollo.
Es independiente de la maquina virtual.
Representa el estado actual del sistema como una colección de objetos
siendo creados, destruidos y modificados.
“System browser” permite examinar y modificar las clases contenidas en la
imagen.
2.2 . Máquina Virtual
¿De qué se encarga?
Smalltalk
Página 8
Interprete de programas escritos en lenguaje Smalltalk.
Manejo de memoria (object memory).
Recolección de basura.
Existe un modelo de intérprete, el cual se puede tomar como base
para implementar nuestra propia maquina virtual.
A continuación enumeramos una serie de ejemplos de las distintas Máquinas
Virtuales desarrolladas para Smalltalk:
Tektronix Smalltalk
Berkeley Smalltalk
Squeak
DEX VAX
Smalltalk
Página 9
3 . Características
En esta sección, desarrollaremos las principales características del lenguaje
explicando brevemente cada una y haciendo énfasis en las que consideramos
las “más” importantes del lenguaje.
Smalltalk posee las siguientes características:
Es la representación más pura de los lenguajes orientados a objetos.
TODO es un objeto
No hay tipos primitivos
Las variables son objetos
Los bucles y las clases también son objetos
Tipado dinámico
Esto significa que una misma variable puede tomar valores de distinto tipo en distintos momentos.
Compilación en tiempo de ejecución o interpretado (depende de la
distribución o del proveedor)
Smalltalk es un sistema que usa compilación a bytecode, como también la utilizan por ejemplo Perl, GNU CLISP o las primeras versiones de Java, el código fuente es traducido a un código intermedio llamado bytecode. El bytecode no es el código máquina de ninguna computadora en particular, y puede por tanto ser portable entre diferentes arquitecturas. El bytecode es entonces interpretado, o ejecutado por una máquina virtual.
Aplica Herencia simple
Posee un recolector de basura
Ahondaremos sobre este tema más adelante en este informe.
Existen múltiples implementaciones
A continuación se muestra un listado de implementaciones más conocidas del lenguaje de programación Smalltalk, y una tabla comparativa de algunas características relevantes para cada implementación:
Smalltalk
Página 10
NOMBRE ENTORNO PLATAFORMA
Ambrai Interactivo Mac OS
AmigaTalk Scripting AmigaOS
Digitalk Methods Scripting DOS
Dolphin Interactivo Win32
GNU Smalltalk Interactivo Unix
Little Smalltalk Scripting Unix, Win32
LSW Vision-Smalltalk Interactivo Win32
Parla Scripting Unix, Win32
PDST Scripting Win32
Pocket Smalltalk Scripting Palm OS
Smalltalk Express Interactivo Win32
Smalltalk MT Interactivo Win32
Smalltalk/X Interactivo Unix, Win32
SmallScript Interactivo Win32
Squeak Interactivo Unix, Mac OS, Win32, WinCE, RISC OS
StepTalk Scripting Unix, Win32
Strongtalk Interactivo Win32
VisualAge Interactivo Unix, Win32, OS/2, z/OS, OS/390
VisualSmalltalk Interactivo Win32
Smalltalk
Página 11
NOMBRE ENTORNO PLATAFORMA
VisualWorks Interactivo Unix, Mac OS, Win32, WinCE
Interacción de los objetos mediante el envío de mensajes
Explicaremos cómo se realiza esta interacción en la próxima sección.
Smalltalk
Página 12
3.1 . Mensajes
Como mencionamos anteriormente en Smalltalk los objetos interactúan
mediante el envío 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
más prioridad de ejecución 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 aritméticas, lógicas y de comparación
con cualquiera de los siguientes caracteres especiales:
:+ / \ * ~ < > = @ % | & ? ! ,
Ejemplo:
Smalltalk
Página 13
3.1.3 . PALABRA CLAVE (KEYWORD MESSAGE)
Son equivalentes a la invocación 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 envía el
mensaje, luego el nombre del mensaje (o nombre del método) y por último el
parámetro que se desea pasar.
Ejemplo:
Smalltalk
Página 14
3.2 . Herencia y Polimorfismo
Smalltalk es un lenguaje que soporta herencia simple. Esta característica del
lenguaje permite a una clase, tener el mismo comportamiento que otra clase,
para luego cambiar ese comportamiento para ofrecer una extensión del mismo.
La herencia es especialmente importante ya que dota al lenguaje de las
características de reusabilidad y extensibilidad. A continuación exponemos un
ejemplo de cómo se declara una clase que hereda de otra en Pharo:
EJEMPLO 1: Definición de clase
3.2.1 Conceptos básicos
- 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 jerarquía de herencias es ilimitada. Esto
significa que las subclases pueden tener subclases que también tienen
subclases. El siguiente diagrama muestra un ejemplo de herencia:
EJEMPLO 2: Clases
Smalltalk
Página 15
En este ejemplo la clase Persona posee los atributos nombre, dirección,
teléfono y soporta los mensajes nombre:, direccion:, telefono:. Las subclases
Cliente y Vendedor soportaran estos mensajes y tendrán los mismos atributos
más los definidos por estas clases.
3.2.2 Jerarquía de clases en Smalltalk
EJEMPLO 3: Jerarquía
3.2.3 Herencia de métodos
La herencia de métodos es útil para permitir a una clase modificar su
comportamiento respecto de su superclase. Esto puede ser realizado
agregando nuevos métodos o redefiniendo los heredados.
Hay que decir que en Smalltalk todos los métodos son virtuales, esto significa
que no es necesario anteponer ninguna palabra reservada como virtual (C++)
para poder ser redefinido en una subclase.
Agregando métodos
Como dijimos anteriormente, se puede agregar métodos de manera muy simple, incorporándolos, ya sean de instancia o de clase, en la definición de la clase. Todo objeto de la subclase soporta los métodos de su superclase, más los nuevos métodos. En el ejemplo anterior, la definición de la clase Cliente podría querer gestionar los pedidos de los clientes. Entonces, la definición de la clase deberá agregar:
Smalltalk
Página 16
pedidosCliente y agregarPedidoCliente. Así la clase cliente soportará todos los métodos de Persona más los nuevos. EJEMPLO 4: Agregación de métodos
Redefinición de métodos
La redefinición de un método 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 definición de la clase, el objeto busca en la
jerarquía hasta que encuentra el método con ese nombre. Los métodos
heredados no pueden eliminarse.
EJEMPLO 5: Mecanismo de redefinición de métodos
Smalltalk
Página 17
3.2.4 Herencia de variables
La jerarquía del lenguaje Smalltalk, ha sido diseñada para que las subclases
hereden de las variables de sus superclases. Las subclases también pueden
poseer variables propias.
Variables de instancia
Las variables de instancia se agregan a la clase colocándolas en la definición
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
Smalltalk
Página 18
Variables de Clase
Una variable de clase es una variable que es compartida por todos los objetos
de la clase. Sólo existe una copia de la variable de clase en la jerarquía local
de clases. Todos los objetos de la clase referencian a esta única copia de la
variable. Las variables de clase también permiten compartir la información a
través de todas las subclases de la clase en que fueron declaradas.
Tienen las mismas convenciones de nombramiento de las variables de clase,
pero sólo los métodos de instancia pueden referirse a las variables de
instancia.
Relación entre métodos y variables de clase
Los métodos de instancia y los métodos de clase pueden referirse a las
variables de clase, pero sólo los métodos de instancia pueden referirse a las
variables de instancia. A continuación vemos un diagrama de esto:
EJEMPLO 7: Diagrama de relación
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 minúscula. 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 común a sus subclases,
pero nunca tendrán sus propias instancias. Por ejemplo, si tengo la clase
Persona como superclase de Cliente y Vendedor, la clase persona no tendrá
instancia en ningún momento pero delega su comportamiento. Otro ejemplo de
Smalltalk
Página 19
una clase abstracta sería la clase Object.
Si una clase posee un método abstracto la clase será abstracta. La declaración
de método abstracto se realiza de la siguiente manera:
EJEMPLO 9: Método abstracto
Super y self
El uso de super provoca que la búsqueda de un método comience en la
superclase del objeto receptor. Esta es la única forma de que la clase pueda
agregar comportamiento a los métodos sin tener que reemplazarlos.
A continuación 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 búsqueda del método comience en el mismo objeto receptor.
Un ejemplo de este mensaje es cuando un objeto quiere enviarse a sí mismo
un mensaje.
Smalltalk
Página 20
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 métodos poseen el mismo significado
pero las implementaciones son diferentes.
Un mismo mensaje puede provocar la invocación de métodos distintos.
Smalltalk utiliza el concepto de vinculación tardía, es decir que se retarda la
decisión sobre el método a llamar hasta el momento en que vaya a ser
utilizado.
Un ejemplo de polimorfismo es el siguiente:
EJEMPLO 10: Polimorfismo
Smalltalk
Página 21
3.3 . Clases y Metaclases
Smalltalk todo es un objeto, y cada objeto es instancia de alguna clase. Las clases no son ninguna excepción: las clases son objetos, y dichos objetos son instancias de otras clases. Este modelo captura la esencia de la programación 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..
¿Quién 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 envío de mensajes. Regla 5. La búsqueda de métodos sigue la cadena de herencia. Una consecuencia de la Regla 1 es que las clases también son objetos, de modo que la Regla 2 nos dice que las clases deben ser también instancias de otras clases. Llamaremos metaclase a la clase de una clase. Una metaclase se crea automáticamente cuando se crea una clase. La mayoría de las veces no
Smalltalk
Página 22
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 jerarquía de metaclases tiene la misma estructura que la jerarquía 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 continuación haremos referencia a algunas de las reglas más importantes
mencionadas anteriormente.
3.3.3. Regla 6: Toda clase es instancia de una metaclase
Las metaclases son implícitas. Las metaclases se crean automáticamente cuando se define una clase. Decimos que son implícitas, ya que el programador nunca tiene por qué preocuparse por ellas. Una metaclase implícita 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 anónimas. 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 jerarquía de metaclases tiene la misma estructura que la
jerarquía de clases
La Regla 7 nos dice que la superclase de una metaclase no puede ser una clase arbitraria. Está constreñida 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 jerarquía de metaclases tiene la misma estructura que la jerarquía de clases. TranslucentColor class −! TranslucentColor class
Smalltalk
Página 23
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 búsqueda del método 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
¿Cuál 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 cómo podemos obtener información de la jerarquía de clases Ejemplo: La jerarquía de clases
TranslucentColor superclass −! Color Color superclass −! Object
Ejemplo: La jerarquía paralela de metaclases TranslucentColor class superclass −! Color class Color class superclass −! Object class
Smalltalk
Página 24
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 implícitas. Una metaclase se crea automáticamente cuando se crea la clase que es su única instancia.
La jerarquía de metaclases tiene la misma estructura que la jerarquía de clases. La búsqueda de métodos 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 también son clases, deben heredar de Class.Behavior proporciona comportamiento común a todas las entidades capaces de tener instancias.
Toda metaclase es instancia de Metaclass. ClassDescription proporciona todo aquello que es común a Class y a Metaclass.
La metaclase de Metaclass es instancia de Metaclass. La relación instancia de forma un ciclo, de modo que Metaclass class class −! Metaclass.
Smalltalk
Página 25
3.4 . Reflexión
Smalltalk es un lenguaje de programación con reflexión computacional. En pocas palabras, quiere decir que los programas son capaces de «reflexionar» sobre su propia ejecución y estructura. En un sentido más técnico, esto significa que los metaobjetos del sistema en tiempo de ejecución pueden reificarse como objetos ordinarios, a los cuales se puede consultar e inspeccionar. Los metaobjetos en Smalltalk son las clases, metaclases, diccionarios de métodos, métodos compilados, la pila al momento de ejecución, y otros. Esta forma de reflexión también se denomina introspección, y muchos lenguajes modernos de programación la permiten.
En el sentido contrario, en Smalltalk resulta posible modificar los metaobjetos reificados y reflejar esos cambios de vuelta al sistema en ejecución. Esta actividad también se denomina intercesión. La intercesión está presente principalmente en los lenguajes de programación dinámicos mientras que los lenguajes estáticos sólo 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 programación sea capaz de reflexión computacional debe permitir tanto la introspección como la intercesión. La introspección es la capacidad de examinar las estructuras de datos que definen el lenguaje, como los objetos, clases, métodos y la pila de ejecución. La intercesión es la capacidad de modificar dichas estructuras, o sea, de alterar la semántica del lenguaje y el comportamiento del programa desde el interior del propio programa. La reflexión estructural examina y modifica la estructura del sistema de tiempo de ejecución y la reflexión de comportamiento modifica la interpretación de esas estructuras.
3.4.1 Ejemplos
Podemos inspeccionar los detalles de implementación de una clase.
Smalltalk
Página 26
1) Obtener los nombres de variables de instancia definidos por clase
2) Obtener los nombres de los métodos implementados por la clase
3) Obtener un método con un selector dado
Como respuesta obtenemos el método asociado al mensaje selector #size en
el diccionario de métodos de la clase OrderedCollection.
4) Obtener el código fuente del método con un selector dado
Obtenemos el código fuente del método llamado #size en la clase
OrderedCollection
También podemos agregar dinámicamente un nuevo método a alguna clase mediante la siguiente sentencia:
Por ejemplo:
Y podemos borrar el método que agregamos anteriormente, ejecutando:
Smalltalk
Página 27
Smalltalk
Página 28
4. Estructuras de control
A diferencia de la mayoría de los lenguajes, Smalltalk implementa todas las
estructuras de control de flujo del programa a través del envío de mensajes a
distintos tipos de objetos, dependiendo estos de la estructura. Se ve como
claramente el lenguaje plasma su filosofía 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 ejecución del programa,
dependerá de la clase de la cual es instancia el objeto que representa a la
expresión.
El mensaje enviado al objeto booleano va acompañado 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 acción de selección 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 Iteración/Repetición
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 envía a un objeto Number, este representa la cantidad de veces que se debe
iterar o entre que rango de elementos. En el caso del envío a objetos
Smalltalk
Página 29
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
información de la misma.
Los mensajes para realizar repeticiones e iteraciones más 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].
- Métodos sobre colecciones
|string cuenta| String := “Cadena de prueba”. Cuenta := 0. string DO: [:caracter | caracter isUppercase ifTrue: [ cuenta := cuenta + 1 ] ]. *Por cada carácter de la colección realiza un bloque de acciones, en este caso cuenta las mayusculas.
Smalltalk
Página 30
string COLLECT: [:caracter | caracter asUppercase ]. *Para cada uno de los elementos del receptor se evalúa el bloque con ese elemento como parámetro, y devuelve una nueva colección formada por el resultado de esas evaluaciones. string SELECT: [:caracter | caracter isUppercase ]. *Crea y retorna una subcolección de los elementos del receptor, que verifican la expresión booleana final del bloque. Es decir que la expresión debe ser booleana. string REJECT: [:caracter | caracter isUppercase ]. *Crea y retorna una subcolección de los elementos del receptor que no verifiquen la expresión booleana final del bloque. Es decir que la expresión debe ser booleana. string DETECT: [:caracter | caracter isUppercase ]. *Devuelve el primer elemento de la lista que verifique la expresión booleana final del bloque.
Smalltalk
Página 31
5. Manejo de excepciones En Smalltalk, si le enviamos un mensaje a un objeto y este no puede responderlo, reacciona enviándonos una excepción. Para esto, la clase Object tiene definido el método error, por lo tanto todos los objetos definidos saben como responder a este mensaje. En cualquier objeto este método puede ser redefinido o definir nuevos métodos para nuevos tipos de errores, para que su comportamiento se amolde más al dominio de nuestro problema. Siguiendo los principios del lenguaje, una excepción también es un objeto, el cual es lanzado desde un método. Al ser objetos, se acceden mediante variables que los referencian y tienen estado, comportamiento e identidad, definidos por sus atributos y métodos.
5.1. ¿Qué hacer con las excepciones?
Podemos no hacer nada, y de esta manera, la excepción ira subiendo las
capas del programa hasta llegar a la principal, donde se puede cortar la ejecución.
Atraparla, hacer algo y continuar con el flujo normal de ejecución.
Atraparla, hacer algo y volver a lanzar la misma excepción. 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 más adecuada agregando más información del
problema.
A continuación se muestran dos ejemplos en los cuales hay una excepción que
no es atrapada y corta la ejecución, y otra que sí es atrapada y solucionada
para continuar normalmente.
1) N := 0. X := 12/N. *Aca se corta la ejecución al no ser atrapada la excepción.
2) [ 12/n ] on: Exception do: [:e | n := n + 1. Transcript show: e messageText. e retry.] *Captura de la excepción y recuperación del error.
Smalltalk
Página 32
5.2. Jerarquía de excepciones
5.3. Excepciones propias
Smalltalk permite expandir la jerarquía de excepciones para que estas sean
acordes al dominio del problema. Esto es una gran ventaja ya que sin esta
funcionalidad, solo se podrían distinguir las excepciones del kernel y
tendríamos que adecuar los errores, que puedan surgir durante la ejecución 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 aplicación.
Por ejemplo en un programa donde se tenga que ocupar vacantes en un avión
de pasajeros sería muy poco representativo hacer lo siguiente:
[pasajero asignarAsiento: vuelo1] on: Exception do: [:error | Transcript show: error messageText ] Cualquier error que surga en el método asignarAsiento nos lanzará una excepción, pero no sabremos a que tipo de excepción 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 excepción particular, heredando de la clase Exception, o de
cualquier otra que herede de la misma
Exception subclass: #NoHayVacanteError
Redefinir el método error en la clase pasajero o definir otro método
que devuelva la excepción definida
Definir en el método correspondiente cuando puede surguir el error
Smalltalk
Página 33
Pasajero >> aginarAsiento: unVuelo [unVuelo hayVacantes] IfFalse: [ self error: 'No quedan vacantes en el vuelo'.] UnVuelo ocuparVacante.
Aplicación
[ pasajero asignarAsiento: vuelo] on: NoHayVacanteError do: [:error | Transcript show: error messageText.]
Smalltalk
Página 34
6. Concurrencia
Smalltalk soporta multithreading desde los inicios. Para ello cuenta con una variedad de clases para hacer computación concurrente de forma sencilla. En este trabajo se aborda principalmente como maneja este aspecto la implementación Smalltalk-80. Las clases más 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 modificándose a lo largo de la ejecución. Como su nombre lo dice, describe la importancia que tiene ese proceso por sobre los demás. La manera más común de crear un proceso es de la siguiente manera: | bloqueAcciones proceso | bloqueAcciones := [Transcript show: 'Proceso']. proceso := bloqueAcciones fork. Para poder manejarlos se tienen distintos métodos, siendo los mas importantes: Suspend, Resume y Terminate. El primero, al ser recibido por el objeto que representa al proceso, suspende la ejecución, 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 semáforo es el objeto que actúa como mediador entre un proceso y el entorno del mismo en el problema ya que proporcionan una forma simple de comunicación sincrónica. A su vez, este objeto es parte de otro proceso independiente. Normalmente llegados ciertos momentos, un proceso puede necesitar la realización de alguna actividad para continuar su ejecución. Ejemplos de estas pueden ser: Ingresar datos por teclado o hacer un click. En este escenario la tarea del semáforo es recibir el aviso de un objeto, perteneciente a un proceso, de que necesita que se realice determinada
Smalltalk
Página 35
actividad para continuar. Mientras el este proceso se suspende momentáneamente, el semáforo espera que del entorno se le envíe una señal para dar por confirmada la realización de la actividad, para finalmente enviarle el mensaje de Resume al proceso para que se reanude. A continuación se muestra un esquema del funcionamiento de este sistema.
Los mensajes más 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 también 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 están en condiciones de realizase al recibir mensajes, este debe decidir cual es que se realizará en primer lugar. Además 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.
Smalltalk
Página 36
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'
Smalltalk
Página 37
7 Manejo de memoria
7.1 Object Memory
La object memory proporciona el intérprete 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 intérprete se comunican acerca de los objetos con los object pointer. El tamaño de los object pointer determina el número máximo de objetos de un sistema de Smalltalk-80 puede contener. Este número no es fijo, no tiene que ver con el lenguaje, pero la implementación que se describe utiliza punteros a objetos de 16 bits, permitiendo que 65.536 objetos sean referenciados. La implementación del sistema Smalltalk-80, con referencias a objetos más grandes será necesario cambiar ciertas partes de la especificación de la máquina 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 también 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 intérprete:
1. Acceder al valor de la variable de instancia de un objeto.
2. Cambie el valor de la variable de instancia de un objeto.
3. Acceda a la clase de un objeto.
4. Crear un nuevo objeto.
5. Encontrar el número de variables de instancia de un objeto que tenga.
No existe una función explícita de la object memory de sacar un objeto, ya no se utiliza debido a que estos objetos se recuperan automáticamente. Un objeto se reclama cuando no hay punteros a objetos de otros objetos. Esta recuperación se puede lograr mediante recuento de referencia o la recolección de basura.
7.2 Almacenamiento Heap
En una implementación de la memoria real de Smalltalk, todos los objetos se
guardan en un área llamada heap. Un nuevo objeto es creado mediante la
obtención de espacio para almacenar sus campos en una serie contigua de
palabras en el heap. Un objeto se destruye liberando el espacio de
almacenamiento dinámico que ocupaba. Los datos reales del objeto son
precedidos por un encabezado de dos palabras. El campo de tamaño del
encabezado indica el número de palabras de almacenamiento dinámico que
Smalltalk
Página 38
ocupa el objeto, incluyendo el encabezado. Se trata de un número de 16 bits
sin signo, y puede variar desde 2 hasta 65.535.
7.3 Compactación
Supongamos por un momento que un objeto una vez asignado nunca cambia su ubicación 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. Después de un tiempo, la memoria se fragmenta. Es decir, una solicitud de asignación está obligada a llenar a un espacio más pequeño que la memoria total disponible, pero más grande que cualquiera de los pedazos disjuntos. Esto puede ocurrir incluso si hay una gran cantidad de espacio disponible y una petición de asignación relativamente pequeña. La fragmentación no se puede tolerar en un sistema interactivo, que se espera para preservar un entorno dinámico para cientos de horas o más, sin reinicialización. Por lo tanto cuando la memoria se fragmenta, debe ser compactada. La memoria se compacta moviendo todos los objetos que todavía están 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 compactación, todos los indicadores de la memoria heap deben actualizarse. Si muchos otros objetos contienen punteros directamente a la ubicación antigua, entonces es mucho tiempo en un equipo secuencial para encontrar y actualizar esas referencias para que apunte a la nueva ubicación. Por lo tanto, para que la actualización del puntero no sea costosa, sólo 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 través 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 aritméticas y muchas otras operaciones. La desventaja del mismo es el costo que tiene el intérprete de Smalltalk a la hora de testear si es un puntero o un entero.
Smalltalk
Página 39
8. Recolección de basura En Smalltalk no es necesario desalocar objetos explícitamente, por lo tanto no proporciona mecanismos para ello. Las implementaciones utilizan técnicas de recolección de basura para detectar y reclamar espacio en memoria asociado con objetos que ya no se utilizarán más en el sistema. En Smalltalk la recolección de basura es integrada configurable. La forma de ejecución 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 políticas (por ejemplo en VisualWorks). La frecuencia y características de la recolección dependen de la técnica utilizada por la implementación. Hay dos enfoques tradicionales para la identificación de objetos inaccesibles: Mark-and-Sweep y Reference Counting. El primero lo que hace justamente es marcar todas los objetos que son accesibles, después busca todos los objetos que no están 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 ejecución del programa está sujeta a un número relativamente largas interrupciones que pueden ser muy molestos en un sistema interactivo. El segundo mantiene un recuento de cuántas referencias hay a cada objeto de otros objetos. Cuando el recuento de referencias a algún 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 cíclicas (objetos referenciados a si mismo directamente o indirectamente).
Smalltalk
Página 40
9. Implementaciones
A continuación se enumeran algunas implementaciones del lenguaje Smalltalk:
Pharo
Squeak
Dolphin
GNU – Smalltalk
Visual Works
Pocket Smalltalk
10. Bibliografía
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 Reflexión -
http://released.info.ucl.ac.be/courses/r+cop/material/04-T-
Reflection%20in%20Smalltalk.pdf
Pharo By Example - http://pharobyexample.org/es/PBE1-sp.pdf