# Smalltalk

Smalltalk es un lenguaje reflexivo de programación, orientado a objetos y con tipado dinámico. Por sus características, Smalltalk puede ser considerado también como un entorno de objetos, donde incluso el propio sistema es un objeto. Metafóricamente, se puede considerar que un Smalltalk es un mundo virtual donde viven objetos que se comunican entre sí, mediante el envío de mensajes.
Un sistema Smalltalk está compuesto por:
* Una Máquina virtual
* Un archivo llamado «imagen», que contiene a todos los objetos del sistema.
* Un lenguaje de programación (también conocido como Smalltalk).
* Una enorme biblioteca de «objetos reusables».
* Y generalmente, un entorno de desarrollo que además puede funcionar como un sistema en tiempo de ejecución.
Smalltalk obtuvo el segundo lugar para «lenguaje de programación más querido» en las encuestas para desarrolladores de Stack Overflow en 2017.

## Historia

Los orígenes de Smalltalk se encuentran en las investigaciones realizadas por Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg y otros durante los años setenta en el Palo Alto Research Center de Xerox (conocido como Xerox PARC), para la creación de un sistema informático orientado a la educación. El objetivo era crear un sistema que permitiese expandir la creatividad de sus usuarios, proporcionando un entorno para la experimentación, creación e investigación.

## Terminología

Un programa Smalltalk consiste en objetos que se envían mensajes. En Smalltalk, todo objeto es instancia de una clase, y la clase es también un objeto. Tanto un número entero (por ejemplo el 4) como las operaciones matemáticas (como la suma de enteros) son objetos. Cada objeto representa un concepto, ya sea concreto de la realidad (por ejemplo una persona), o de cierta forma abstracto (por ejemplo, un servidor web).
Los objetos en Smalltalk presentan características comunes:
* Tienen colaboradores (referencias a otros objetos, por medio de variables o índices).
* Reciben mensajes, lo cual implica ejecutar un método, y devolver un objeto como respuesta. Un mensaje tiene selector (que es su nombre), y puede tener o no parámetros.
* Durante la ejecución de un mensaje, el objeto puede enviar mensajes (ya sea a sí mismo o a otros objetos).
Las clases tienen las siguientes características:
* Tienen un nombre, en formato Camel Case
* Declaran nombres de variables, que cada instancia podrá leer y escribir desde sus métodos, y que le sirven para mantener una referencia a otros objetos (sus colaboradores).
* Toda clase tiene un conjunto de métodos, también llamados el protocolo de esa clase. Un método define la ejecución para responder a un mensaje.
* Toda clase tiene superclase, de la cual hereda métodos y variables, y agrega los propios. En el caso de agregar un método con un selector de mensaje que ya existía en su superclase, este último será el ejecutado al momento de recibir el mensaje con ese selector.
* Se denomina method lookup al mecanismo que determina qué método corresponde ejecutar para un selector recibido por un objeto. Ese método lookup se realiza al momento de recibir el mensaje, lo cual se llama late binding.
* En caso de no existir un método para responder al mensaje recibido, se ejecutará el método doesNotUnderstand:.
Los objetos son creados como instancias de clases durante la ejecución de un programa y son barridos automáticamente cuando otros objetos de memoria no los referencian por el recolector de basura (Garbage Collector).

## Características

Smalltalk es considerado el primero de los lenguajes orientados a objetos, aunque en realidad el primero en implementar programación orientada a objetos fue Simula. En Smalltalk todo es un objeto, incluidos los números reales o el propio entorno Smalltalk.
Como lenguaje tiene las siguientes características:
* Orientación a Objetos
* Tipado dinámico
* Interacción entre objetos mediante envío de mensajes
* Herencia simple y con raíz común
* Reflexión computacional completa
* Recolección de basura
* Compilación en tiempo de ejecución o Interpretado (dependiendo de la distribución o del proveedor)
* Múltiples Implementaciones
Smalltalk ha tenido gran influencia sobre otros lenguajes como Java o Ruby, y de su entorno han surgido muchas de las prácticas y herramientas de desarrollo promulgadas actualmente por las metodologías ágiles (refactorización, desarrollo incremental, desarrollo dirigido por tests, etc.).

## El entorno Smalltalk

Las implementaciones de Smalltalk de mayor peso (VisualWorks, Squeak, VisualSmalltalk, VisualAge, Dolphin, Pharo Smalltalk, Smalltalk X) poseen un entorno de interacción muy diferente al entorno de desarrollo típico de otras tecnologías como Microsoft Visual Studio .Net o Eclipse. El entorno o ambiente Smalltalk es primordialmente gráfico y funciona como un sistema en tiempo de ejecución que integra varias herramientas de programación (Smalltalk), utilidades multimedia, interfaces para ejecutar código no nativo a Smalltalk y servicios del sistema operativo. Estas posibilidades, que han influido en la metodología de trabajo y concepción de la programación, se traducen en la tendencia a considerar a Smalltalk más que un simple lenguaje de programación. La forma de desarrollar software en Smalltalk no consiste en el ciclo típico de las tecnologías tradicionales: Arrancar un editor de texto, compilar y ejecutar y terminar la aplicación. En Smalltalk se manipula el entorno mismo, comúnmente mediante el Navegador del Sistema.

## Sintaxis

Tradicionalmente, Smalltalk no posee una notación explícita para describir un programa entero. Sí se utiliza una sintaxis explícita para definir ciertos elementos de un programa, tales como métodos, pero la manera en que tales elementos están estructurados dentro de un programa entero generalmente es definida por las múltiples implementaciones. El estándar mismo no promueve otra dirección, por lo que define una sintaxis abstracta de programas Smalltalk, que define todos los elementos que constituyen un programa Smalltalk y la manera en que esos elementos están lógicamente compuestos por otros elementos, sin embargo, cada implementación es libre de definir y utilizar las muchas sintaxis posibles que están conformes a la sintaxis abstracta estándar. Un ejemplo de una sintaxis concreta es el Formato de Intercambio Smalltalk (o SIF, de Smalltalk Interchange Format) definida en el mismo estándar.
La sintaxis de Smalltalk-80 tiende a ser minimalista. Esto significa que existen un grupo pequeño de palabras reservadas y declaraciones en comparación con la mayoría de los lenguajes populares. Smalltalk posee un grupo de 6 palabras reservadas: self, super, nil, true , false y thisContext.

## 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 depende de la técnica utilizada por la implementación. Adicionalmente algunas implementaciones de Smalltalk proporcionan soporte para mecanismos de finalización como el uso de Ephemerons.

## Reflexión computacional

Smalltalk-80 provee reflexión computacional y estructural, ya que es un sistema implementado en sí mismo. La reflexión estructural se manifiesta en que las clases y métodos que define el sistema son en sí mismos objetos también y forman parte del sistema mismo. La mayoría de las implementaciones de Smalltalk tienden a exponer el compilador Smalltalk al entorno de programación, permitiendo que dentro del sistema se compile código fuente (textual), transformándose en objetos métodos, que son comúnmente instancias de la clase CompiledMethod. El sistema generalmente incorpora estos métodos en las clases, almacenándolos en el diccionario de métodos de la clase a la cual se quiera agregar el comportamiento que realiza el método. Esto, así como la incorporación de nuevas clases al sistema, es realizado dentro del sistema mismo; aunque la mayor parte de las implementaciones poseen herramientas visuales que ocultan la complejidad de interactuar con la clase que usualmente se encarga de tales tareas, el ClassBuilder.
La reflexión computacional de Smalltalk-80 se manifiesta en la posibilidad de observar el estado computacional del sistema. En los lenguajes derivados del Smalltalk-80 original, durante el envío de mensajes entre objetos, cada objeto receptor de un mensaje consulta su clase para tener acceso a los métodos que define. En caso de encontrarse el método en la clase, se dice que se «activa» el método. Esta activación de un método actualmente en ejecución, es accesible mediante una palabra clave llamada thisContext. Enviando mensajes a thisContext se puede consultar cuestiones tales como «¿quién me envió este mensaje?». Estas facilidades hacen posible implementar corrutinas, continuaciones o back-tracking al estilo Prolog sin necesidad de modificar la máquina virtual. Uno de los usos más interesantes de esta facilidad, se da en el framework de web Seaside de Avi Bryant.

## Ejemplos de Smalltalk

En Smalltalk todo es un objeto, y a un objeto se le envían mensajes. Por ejemplo:
Significa que al objeto «1» le enviamos el mensaje «+» con el colaborador externo, otro objeto, «1». Este ejemplo entonces resulta en el objeto «2».
En el típico Hola mundo, el objeto es Transcript, que recibe el mensaje show con el colaborador externo '¡Hola, Mundo!'.
Para crear una instancia de un objeto, solo hay que mandar un mensaje new a una clase:
Para obtener las vocales de una cadena de texto:

## Bibliografía

* «Smalltalk-80» Goldberg, A.; Robson, D. (1983). Smalltalk-80: the language and its implementation. Addison-Wesley Longman Publishing Co., Inc.
* «A Little Smalltalk». Budd, T. (1987). A little Smalltalk. Addison-Wesley.
* «Discovering Smalltalk» LaLonde, W. (1994). Discovering Smalltalk. Benjamin-Cummings Publishing.
* «The Art and Science of Smalltalk» Lewis, S. (1995). The art and science of Smalltalk. Prentice Hall.
* «Smalltalk Best Practice Patterns» Beck, K. (1997). Smalltalk Best Practice Patterns. Prentice Hall, Englewood Cliffs, NJ.
* «Kent Beck's Guide to Better Smalltalk» Beck, K. (1999). Kent Beck's guide to better Smalltalk: a sorted collection. Cambridge University Press.
* «Advanced Smalltalk». Pletzke, J. (1997). Advanced Smalltalk. Wiley Computer Publishing. John Wiley & Sons.
* «The Design Patterns Smalltalk Companion» Alpert, S. R.; Brown, K.; Woolf, B. (1998). The design patterns Smalltalk companion. Addison-Wesley Longman Publishing.
* «ANSI NCITS 319-1998». ANSI (1998). American National Standard for Information Technology - Programming Languages - Smalltalk. American National Standards Institute, Inc.
* «Smalltalk, Objects, and Design» Liu, C. (2000). Smalltalk, objects, and design. iUniverse.
* «Smalltalk With Style» Klimas, E. J.; Skublics, S.; Thomas, D. A. (2002). Smalltalk with style. Prentice-Hall, Inc.
* «Libro de programación con Smalltalk» de Diego Gómez Deck (en Español) (2006).
* «Mentoring Course Smalltalk» de Andrés Valloud (2008).
* «Hashing Smalltalk Practice» de Andrés Valloud (2008).
* «Fundamentals Smalltalk Programming Techniques» de Andrés Valloud (2009).