Charla

Smalltalk es un lenguaje de programación puramente orientado a objetos (OOP), creado en la década de 1970 para uso educativo, específicamente para el aprendizaje construccionista, en Xerox PARC por científicos del Learning Research Group (LRG), incluido Alan Kay., Dan Ingalls, Adele Goldberg, Ted Kaehler, Diana Merry y Scott Wallace.

En Smalltalk, los programas en ejecución se componen de los llamados objetos opacos, atómicos, que son instancias de código de plantilla almacenados en clases, y estos objetos se comunican mediante el paso de mensajes, a través de un entorno de máquina virtual (VM) intermediario. Un número relativamente pequeño de objetos, llamados primitivos, no se pueden redefinir en vivo, a veces se definen independientemente del entorno de programación de Smalltalk.

Después de haber experimentado un importante desarrollo en la industria hacia otros usos, incluidas las funciones comerciales y de base de datos, Smalltalk todavía se usa en la actualidad. Cuando se lanzó al público por primera vez, Smalltalk-80 presentó ideas innovadoras y fundamentales para el campo de la programación OO (OOP).

Desde su inicio, el lenguaje proporcionó programación interactiva a través de un entorno de desarrollo integrado. Esto requiere reflexión y enlace tardío en la ejecución del lenguaje del código. El desarrollo posterior ha llevado a al menos una instancia del entorno de ejecución de Smalltalk que carece de una interfaz gráfica de usuario o front-end integrada.

Los lenguajes similares a Smalltalk están en desarrollo activo y han reunido comunidades leales de usuarios a su alrededor. ANSI Smalltalk fue ratificado en 1998 y representa la versión estándar de Smalltalk.

Smalltalk ocupó el segundo lugar como "lenguaje de programación más querido" en la Encuesta de desarrolladores de desbordamiento de pila en 2017, pero no estaba entre los 26 lenguajes de programación más queridos de la encuesta de 2018.

Historia

Hay una gran cantidad de variantes de Smalltalk. La palabra no calificada Smalltalk se usa a menudo para indicar el lenguaje Smalltalk-80 y la máquina virtual compatible, la primera versión que se puso a disposición del público y se creó en 1980. Los primeros entornos de hardware que ejecutan las máquinas virtuales Smalltalk fueron Xerox. Computadoras altas.

Smalltalk fue el producto de una investigación dirigida por Alan Kay en el Centro de Investigación Xerox Palo Alto (PARC); Alan Kay diseñó la mayoría de las primeras versiones de Smalltalk, Adele Goldberg escribió la mayor parte de la documentación y Dan Ingalls implementó la mayoría de las primeras versiones. La primera versión, denominada Smalltalk-71, fue creada por Kay en unas pocas mañanas con la apuesta de que un lenguaje de programación basado en la idea de paso de mensajes inspirado en Simula podría implementarse en "una página de código". Una variante posterior utilizada para trabajos de investigación ahora se denomina Smalltalk-72 e influyó en el desarrollo del modelo Actor. Su sintaxis y modelo de ejecución eran muy diferentes de las variantes modernas de Smalltalk.

Después de revisiones significativas que congelaron algunos aspectos de la semántica de ejecución para mejorar el rendimiento (al adoptar un modelo de ejecución de herencia de clase similar a Simula), se creó Smalltalk-76. Este sistema tenía un entorno de desarrollo que presentaba la mayoría de las herramientas ahora familiares, incluido un navegador/editor de código de biblioteca de clases. Smalltalk-80 agregó metaclases, para ayudar a mantener el "todo es un objeto" (excepto variables) asociando propiedades y comportamiento con clases individuales, e incluso primitivas como valores enteros y booleanos (por ejemplo, para admitir diferentes formas de crear instancias).

Smalltalk-80 fue la primera variante de idioma que estuvo disponible fuera de PARC, primero como Smalltalk-80 Versión 1, y se entregó a un pequeño número de empresas (Hewlett-Packard, Apple Computer, Tektronix y Digital Equipment Corporation (DEC)) y universidades (UC Berkeley) para revisión por pares e implementación en sus plataformas. Posteriormente, en 1983, se lanzó una implementación de disponibilidad general, denominada Smalltalk-80 Versión 2, como una imagen (archivo independiente de la plataforma con definiciones de objetos) y una especificación de máquina virtual. ANSI Smalltalk ha sido la referencia del lenguaje estándar desde 1998.

Dos variantes de implementación de Smalltalk actualmente populares son descendientes de esas imágenes originales de Smalltalk-80. Squeak es una implementación de código abierto derivada de Smalltalk-80 Versión 1 a través de Apple Smalltalk. VisualWorks se deriva de Smalltalk-80 versión 2 a través de Smalltalk-80 2.5 y ObjectWorks (ambos productos de ParcPlace Systems, una empresa derivada de Xerox PARC formada para llevar Smalltalk al mercado). Como vínculo interesante entre generaciones, en 2001 Vassili Bykov implementó Hobbes, una máquina virtual que ejecuta Smalltalk-80 dentro de VisualWorks. (Dan Ingalls más tarde llevó a Hobbes a Squeak).

Desde finales de la década de 1980 hasta mediados de la de 1990, dos organizaciones competidoras: ParcPlace Systems y Digitalk, ambas con sede en California, vendían los entornos de Smalltalk, incluidos soporte, capacitación y complementos. ParcPlace Systems tendía a centrarse en el mercado de microsistemas Unix/Sun, mientras que Digitalk se centraba en PC basadas en Intel que ejecutaban Microsoft Windows o el OS/2 de IBM. Ambas firmas lucharon por hacer que Smalltalk se generalice debido a las necesidades sustanciales de memoria de Smalltalk, el rendimiento de tiempo de ejecución limitado y la falta inicial de conectividad compatible con servidores de bases de datos relacionales basados en SQL. Si bien el alto precio de ParcPlace Smalltalk limitó su penetración en el mercado a organizaciones comerciales medianas y grandes, los productos Digitalk inicialmente intentaron llegar a una audiencia más amplia con un precio más bajo. IBM inicialmente apoyó el producto Digitalk, pero luego ingresó al mercado con un producto Smalltalk en 1995 llamado VisualAge/Smalltalk. Easel introdujo Enfin en este momento en Windows y OS/2. Enfin se hizo mucho más popular en Europa, ya que IBM lo introdujo en las tiendas de TI antes de que desarrollaran IBM Smalltalk (más tarde VisualAge). Posteriormente, Enfin fue adquirida por Cincom Systems, y ahora se vende bajo el nombre de ObjectStudio, y es parte del conjunto de productos Cincom Smalltalk.

En 1995, ParcPlace y Digitalk se fusionaron en ParcPlace-Digitalk y luego se renombró en 1997 como ObjectShare, ubicado en Irvine, CA. ObjectShare (NASDAQ: OBJS) se negoció públicamente hasta 1999, cuando se eliminó de la lista y se disolvió. La firma fusionada nunca logró encontrar una respuesta efectiva a Java en cuanto al posicionamiento en el mercado, y en 1997 sus propietarios buscaban vender el negocio. En 1999, Seagull Software adquirió el laboratorio de desarrollo Java de ObjectShare (que incluye el equipo de desarrollo original de Smalltalk/V y Visual Smalltalk) y sigue siendo propietario de VisualSmalltalk, aunque los derechos de distribución mundial del producto Smalltalk permanecieron en ObjectShare, que luego los vendió a Cincom. VisualWorks se vendió a Cincom y ahora forma parte de Cincom Smalltalk. Cincom ha respaldado fuertemente Smalltalk, lanzando múltiples versiones nuevas de VisualWorks y ObjectStudio cada año desde 1999.

Cincom, GemTalk e Instanciations continúan vendiendo entornos Smalltalk. IBM tiene el 'fin de su vida útil' de VisualAge Smalltalk, ya que a fines de la década de 1990 decidió respaldar Java en su lugar y, a partir de 2005, cuenta con el respaldo de Instantiations, Inc., quien renombró el producto VA Smalltalk (Plataforma VAST) y continuar lanzando nuevas versiones cada año. La implementación abierta de Squeak tiene una comunidad activa de desarrolladores, incluidos muchos de la comunidad original de Smalltalk, y se ha utilizado recientemente para proporcionar el entorno Etoys en el proyecto OLPC, un conjunto de herramientas para desarrollar aplicaciones colaborativas Croquet Project y la aplicación de mundo virtual Open Cobalt.. GNU Smalltalk es una implementación de software libre de un derivado de Smalltalk-80 del proyecto GNU. Pharo Smalltalk es una bifurcación de Squeak orientada a la investigación y uso en entornos comerciales.

Un avance significativo, que se ha extendido a todos los entornos de Smalltalk a partir de 2016, es el uso cada vez mayor de dos marcos web, Seaside y AIDA/Web, para simplificar la creación de aplicaciones web complejas. Seaside ha visto un considerable interés en el mercado con Cincom, Gemstone e Instanciations incorporándolo y ampliándolo.

Influencias

Smalltalk fue uno de los muchos lenguajes de programación orientados a objetos basados en Simula. Smalltalk es también uno de los lenguajes de programación más influyentes. Prácticamente todos los lenguajes orientados a objetos que vinieron después (Flavors, CLOS, Objective-C, Java, Python, Ruby y muchos otros) fueron influenciados por Smalltalk. Smalltalk también fue uno de los lenguajes más populares para métodos ágiles de desarrollo de software, desarrollo rápido de aplicaciones (RAD) o creación de prototipos y patrones de diseño de software. El entorno altamente productivo proporcionado por las plataformas Smalltalk las hizo ideales para un desarrollo rápido e iterativo.

Smalltalk surgió de un programa más grande de investigación financiada por la Agencia de Proyectos de Investigación Avanzada (ARPA) que, en muchos sentidos, definió el mundo moderno de la informática. Además de Smalltalk, los investigadores de ARPA desarrollaron en la década de 1960 prototipos funcionales de cosas como hipertexto, GUI, multimedia, el mouse, la telepresencia e Internet. Alan Kay (uno de los inventores de Smalltalk) también describió una tableta a la que llamó Dynabook, que se parece a las tabletas modernas como el iPad.

Los entornos de Smalltalk fueron a menudo los primeros en desarrollar lo que ahora son patrones comunes de diseño de software orientado a objetos. Uno de los más populares es el patrón modelo-vista-controlador (MVC) para el diseño de la interfaz de usuario. El patrón MVC permite a los desarrolladores tener varias vistas coherentes de los mismos datos subyacentes. Es ideal para entornos de desarrollo de software, donde hay varias vistas (por ejemplo, entidad-relación, flujo de datos, modelo de objetos, etc.) de la misma especificación subyacente. Además, para simulaciones o juegos donde el modelo subyacente se puede ver desde varios ángulos y niveles de abstracción.

Además del patrón MVC, el lenguaje y el entorno Smalltalk fueron muy influyentes en la historia de la interfaz gráfica de usuario (GUI) y la interfaz de usuario lo que ves es lo que obtienes (WYSIWYG)., editores de fuentes y metáforas de escritorio para el diseño de la interfaz de usuario. Las potentes herramientas integradas de depuración e inspección de objetos que venían con los entornos de Smalltalk establecieron el estándar para todos los entornos de desarrollo integrado, comenzando con los entornos de Lisp Machine, que vinieron después.

Programación orientada a objetos

Smalltalk-80: The Language and its Implementation, a.k.a. el "Libro azul", un libro original sobre el idioma

Como en otros lenguajes orientados a objetos, el concepto central en Smalltalk-80 (pero no en Smalltalk-72) es el de un objeto. Un objeto es siempre una instancia de una clase. Las clases son "planos" que describen las propiedades y el comportamiento de sus instancias. Por ejemplo, la clase de ventana de una GUI podría declarar que las ventanas tienen propiedades como la etiqueta, la posición y si la ventana es visible o no. La clase también podría declarar que las instancias admiten operaciones como abrir, cerrar, mover y ocultar. Cada objeto de ventana en particular tendría sus propios valores de esas propiedades, y cada uno de ellos podría realizar operaciones definidas por su clase.

Un objeto de Smalltalk puede hacer exactamente tres cosas:

1. Estado de retención (referencias a otros objetos).
2. Recibir un mensaje de sí mismo u otro objeto.
3. En el curso de procesar un mensaje, envía mensajes a sí mismo u otro objeto.

El estado que tiene un objeto siempre es privado para ese objeto. Otros objetos pueden consultar o cambiar ese estado solo enviando solicitudes (mensajes) al objeto para que lo haga. Cualquier mensaje se puede enviar a cualquier objeto: cuando se recibe un mensaje, el receptor determina si ese mensaje es apropiado. Alan Kay ha comentado que, a pesar de la atención que se presta a los objetos, la mensajería es el concepto más importante en Smalltalk: "La gran idea es la 'mensajería': de eso se trata el núcleo de Smalltalk/Squeak". (y es algo que nunca se completó del todo en nuestra fase Xerox PARC).

A diferencia de la mayoría de los demás lenguajes, los objetos de Smalltalk se pueden modificar mientras el sistema se está ejecutando. La codificación en vivo y la aplicación de correcciones "sobre la marcha" es una metodología de programación dominante para Smalltalk y es una de las principales razones de su eficiencia.

Smalltalk es un "puro" lenguaje de programación orientado a objetos, lo que significa que, a diferencia de C++ y Java, no hay diferencia entre valores que son objetos y valores que son tipos primitivos. En Smalltalk, los valores primitivos como números enteros, booleanos y caracteres también son objetos, en el sentido de que son instancias de las clases correspondientes, y las operaciones sobre ellos se invocan mediante el envío de mensajes. Un programador puede cambiar o ampliar (a través de subclases) las clases que implementan valores primitivos, de modo que se pueda definir un nuevo comportamiento para sus instancias, por ejemplo, para implementar nuevas estructuras de control, o incluso cambiar su comportamiento existente. Este hecho se resume en la frase comúnmente escuchada "En Smalltalk todo es un objeto", que puede expresarse con mayor precisión como "todos los valores son objetos", ya que las variables no lo son.

Dado que todos los valores son objetos, las clases también son objetos. Cada clase es una instancia de la metaclase de esa clase. Las metaclases a su vez también son objetos, y son todas instancias de una clase llamada Metaclase. Los bloques de código, la forma de Smalltalk de expresar funciones anónimas, también son objetos.

Reflexión

Reflexión es un término que los informáticos aplican a los programas de software que tienen la capacidad de inspeccionar su propia estructura, por ejemplo, su árbol de análisis o tipos de datos de parámetros de entrada y salida. La reflexión es una característica de lenguajes dinámicos e interactivos como Smalltalk y Lisp. Los programas interactivos con reflexión (ya sea interpretados o compilados) mantienen el estado de todos los objetos en memoria, incluido el objeto de código en sí, que se generan durante el análisis/compilación y son modificables y accesibles mediante programación.

La reflexión también es una característica de tener un metamodelo como lo hace Smalltalk. El metamodelo es el modelo que describe el lenguaje, y los desarrolladores pueden usar el metamodelo para hacer cosas como recorrer, examinar y modificar el árbol de análisis de un objeto, o encontrar todas las instancias de un determinado tipo de estructura (por ejemplo, todas las instancias de la clase Método en el metamodelo).

Smalltalk-80 es un sistema totalmente reflexivo. Smalltalk-80 proporciona reflexión estructural y computacional. Smalltalk es un sistema estructuralmente reflexivo cuya estructura está definida por objetos Smalltalk-80. Las clases y los métodos que definen el sistema también son objetos y forman parte del sistema que ayudan a definir. El compilador de Smalltalk compila el código fuente textual en objetos de método, normalmente instancias de CompiledMethod. Estos se agregan a las clases almacenándolos en el diccionario de métodos de una clase. La parte de la jerarquía de clases que define las clases puede agregar nuevas clases al sistema. El sistema se amplía ejecutando código Smalltalk-80 que crea o define clases y métodos. De esta forma, un sistema Smalltalk-80 es un sistema "vivo" sistema, con la capacidad de extenderse en tiempo de ejecución.

Dado que las clases son objetos, se les pueden hacer preguntas como "¿qué métodos implementa?" o "¿qué campos/ranuras/variables de instancia define?". Por lo tanto, los objetos se pueden inspeccionar, copiar, (des) serializar fácilmente, etc., con un código genérico que se aplica a cualquier objeto del sistema.

Smalltalk-80 también proporciona reflexión computacional, la capacidad de observar el estado computacional del sistema. En lenguajes derivados del Smalltalk-80 original, se puede acceder a la activación actual de un método como un objeto nombrado a través de una pseudovariable (una de las seis palabras reservadas), thisContext. Al enviar mensajes a thisContext, la activación de un método puede hacer preguntas como "quién me envió este mensaje". Estas instalaciones hacen posible implementar co-rutinas o back-tracking similar a Prolog sin modificar la máquina virtual. El sistema de excepción se implementa utilizando esta función. Uno de los usos más interesantes de esto es en el marco web de Seaside, que alivia al programador de lidiar con la complejidad del botón Atrás de un navegador web al almacenar continuaciones para cada página editada y cambiar entre ellas a medida que el usuario navega por la web. sitio. La programación del servidor web con Seaside se puede realizar con un estilo de programación más convencional.

Un ejemplo de cómo Smalltalk puede usar la reflexión es el mecanismo para manejar errores. Cuando a un objeto se le envía un mensaje que no implementa, la máquina virtual envía al objeto el mensaje doesNotUnderstand: con una cosificación del mensaje como argumento. El mensaje (otro objeto, una instancia de Message) contiene el selector del mensaje y un Array de sus argumentos. En un sistema interactivo de Smalltalk, la implementación predeterminada de doesNotUnderstand: es una que abre una ventana de error (un notificador) que informa el error al usuario. A través de esto y las funciones reflexivas, el usuario puede examinar el contexto en el que ocurrió el error, redefinir el código infractor y continuar, todo dentro del sistema, utilizando las funciones reflexivas de Smalltalk-80.

Al crear una clase que comprenda (implemente) solo doesNotUnderstand:, se puede crear una instancia que pueda interceptar cualquier mensaje que se le envíe a través de su método doesNotUnderstand:. Tales instancias se denominan proxies transparentes. Dichos proxies se pueden usar para implementar una serie de funciones, como Smalltalk distribuido, donde los mensajes se intercambian entre múltiples sistemas de Smalltalk, interfaces de bases de datos donde los objetos se eliminan de forma transparente de una base de datos, promesas, etc. El diseño de Smalltalk distribuido influyó en sistemas tales como CORBA.

Sintaxis

Smalltalk-80 La sintaxis es bastante minimalista, basada en solo un puñado de declaraciones y palabras reservadas. De hecho, solo seis "palabras clave" están reservados en Smalltalk: true, false, nil, self, super, y thisContext. Estos se denominan correctamente pseudo-variables, identificadores que siguen las reglas de los identificadores de variables pero denotan enlaces que un programador no puede cambiar. Las pseudovariables true, false y nil son instancias singleton. self y super se refieren al receptor de un mensaje dentro de un método activado en respuesta a ese mensaje, pero los envíos a super se buscan en el superclase de la clase que define el método en lugar de la clase del receptor, lo que permite que los métodos de las subclases invoquen métodos del mismo nombre en las superclases. thisContext hace referencia al registro de activación actual. Las únicas construcciones de lenguaje integradas son envíos de mensajes, asignación, devolución de métodos y sintaxis literal para algunos objetos. Desde sus orígenes como lenguaje para niños de todas las edades, la sintaxis estándar de Smalltalk usa la puntuación de una manera más parecida al inglés que a los lenguajes de codificación convencionales. El resto del lenguaje, incluidas las estructuras de control para la evaluación condicional y la iteración, se implementa sobre las construcciones integradas mediante la biblioteca de clases estándar de Smalltalk. (Por razones de rendimiento, las implementaciones pueden reconocer y tratar como especiales algunos de esos mensajes; sin embargo, esto es solo una optimización y no está integrado en la sintaxis del lenguaje).

El dicho de que "la sintaxis de Smalltalk cabe en una postal" puede haberse originado en la concepción original del lenguaje de Alan Kay, según lo relatado por él en prácticamente cada una de las decenas o cientos de conferencias públicas, op. cit., o tal vez podría referirse a un fragmento de código de Ralph Johnson, que demuestra todos los elementos sintácticos estándar básicos de los métodos:

ejemplo ConNúmero: x Silencio Sí. Silencio verdadero " falso no " ()Nil isNil) siFalse: [auto Stop]. Sí. := auto tamaño + super tamaño. #$a #a 'a' 1 1.0) hacer: [ :cada uno Silencio Transcripción Mostrar: ()cada uno clase Nombre); Mostrar: ']. ^x . Sí.

Literales

Los siguientes ejemplos ilustran los objetos más comunes que se pueden escribir como valores literales en los métodos Smalltalk-80.

Números. La siguiente lista ilustra algunas de las posibilidades.

42-42123.451.2345e22r1001001016rA000

Las dos últimas entradas son un número binario y hexadecimal, respectivamente. El número antes de la 'r' es la raíz o base. La base no tiene que ser una potencia de dos; por ejemplo 36rSMALLTALK es un número válido igual a 80738163270632 decimal.

Los caracteres se escriben precediéndolos de un signo de dólar:

$A

Las cadenas son secuencias de caracteres entre comillas simples:

¡Hola, mundo! '

Para incluir una comilla en una cadena, escápela usando una segunda comilla:

Les dije: "Hola, mundo". '

Las comillas dobles no necesitan escaparse, ya que las comillas simples delimitan una cadena:

Les dije: "¡Hola, mundo!". '

Dos cadenas iguales (las cadenas son iguales si contienen todos los mismos caracteres) pueden ser objetos diferentes que residen en diferentes lugares de la memoria. Además de las cadenas, Smalltalk tiene una clase de objetos de secuencia de caracteres llamada Símbolo. Se garantiza que los símbolos son únicos: no puede haber dos símbolos iguales que sean objetos diferentes. Por eso, los símbolos son muy baratos para comparar y se usan a menudo para artefactos de lenguaje como selectores de mensajes (ver más abajo).

Los símbolos se escriben como # seguido de una cadena literal. Por ejemplo:

#'foo '

Si la secuencia no incluye espacios en blanco o caracteres de puntuación, esto también se puede escribir como:

#foo

Matrices:

#1 2 3 4)

define una matriz de cuatro enteros.

Muchas implementaciones admiten la siguiente sintaxis literal para ByteArrays:

#[1 2 3 4]

define un ByteArray de cuatro enteros.

Y por último, pero no menos importante, los bloques (literales de función anónimos)

[... Algunos pequeño código...

Los bloques se explican en detalle más adelante en el texto.

Muchos dialectos de Smalltalk implementan sintaxis adicionales para otros objetos, pero los anteriores son los esenciales admitidos por todos.

Declaraciones de variables

Los dos tipos de variables comúnmente utilizadas en Smalltalk son variables de instancia y variables temporales. Otras variables y terminología relacionada dependen de la implementación particular. Por ejemplo, VisualWorks tiene variables compartidas de clase y variables compartidas de espacio de nombres, mientras que Squeak y muchas otras implementaciones tienen variables de clase, variables de grupo y variables globales.

Las declaraciones de variables temporales en Smalltalk son variables declaradas dentro de un método (ver más abajo). Se declaran en la parte superior del método como nombres separados por espacios y encerrados por barras verticales. Por ejemplo:

Silencio índice Silencio

declara una variable temporal llamada index que contiene inicialmente el valor nil.

Se pueden declarar múltiples variables dentro de un conjunto de barras:

Silencio índice de vocales Silencio

declara dos variables: índice y vocales. Todas las variables se inicializan. Las variables se inicializan en cero, excepto las variables indexadas de Strings, que se inicializan en el carácter nulo o ByteArrays que se inicializan en 0.

Tarea

A una variable se le asigna un valor a través de ':=' sintaxis. Asi que:

vocales := 'aeiou '

Asigna la cadena 'aeiou' a la variable de vocales declarada anteriormente. La cadena es un objeto (una secuencia de caracteres entre comillas simples es la sintaxis de las cadenas literales), creada por el compilador en el momento de la compilación.

En la imagen original de Parc Place, el glifo del carácter de subrayado ⟨_⟩ aparecía como una flecha hacia la izquierda ⟨←⟩ (como en la versión de 1963 del código ASCII). Smalltalk originalmente aceptó esta flecha hacia la izquierda como el único operador de asignación. Algunos códigos modernos todavía contienen lo que parecen ser guiones bajos que actúan como asignaciones, recordando este uso original. La mayoría de las implementaciones modernas de Smalltalk aceptan el guión bajo o la sintaxis de dos puntos.

Mensajes

El mensaje es la construcción de lenguaje más fundamental en Smalltalk. Incluso las estructuras de control se implementan como envíos de mensajes. Smalltalk adopta por defecto una estrategia de despacho dinámico y despacho único (a diferencia del despacho múltiple, utilizado por algunos otros lenguajes orientados a objetos).

El siguiente ejemplo envía el mensaje 'factorial' al número 42:

42 factorial

En esta situación 42 se llama el mensaje receptor, mientras que 'factorial' es el mensaje selector. El receptor responde al mensaje devolviendo un valor (presumiblemente en este caso el factorial de 42). Entre otras cosas, el resultado del mensaje se puede asignar a una variable:

a Rather BigNumber := 42 factorial

"factorial" arriba está lo que se llama un mensaje unario porque solo un objeto, el receptor, está involucrado. Los mensajes pueden llevar objetos adicionales como argumentos, de la siguiente manera:

2 para: 4

En esta expresión están involucrados dos objetos: 2 como receptor y 4 como argumento del mensaje. Se supone que el resultado del mensaje, o en lenguaje Smalltalk, la respuesta es 16. Dichos mensajes se denominan mensajes de palabras clave. Un mensaje puede tener más argumentos, usando la siguiente sintaxis:

'hola mundo ' índice De: $o Empieza At: 6

que responde al índice del carácter 'o' en la cadena del receptor, comenzando la búsqueda desde el índice 6. El selector de este mensaje es "indexOf:startingAt:", que consta de dos piezas, o palabras clave.

Tal intercalado de palabras clave y argumentos está destinado a mejorar la legibilidad del código, ya que los argumentos se explican por sus palabras clave precedentes. Por ejemplo, una expresión para crear un rectángulo utilizando una sintaxis similar a C++ o Java podría escribirse como:

nuevo Rectángulo()100, 200);

No está claro qué argumento es cuál. Por el contrario, en Smalltalk, este código se escribiría como:

Rectángulo ancho: 100 altura: 200

El receptor en este caso es "Rectángulo", una clase, y la respuesta será una nueva instancia de la clase con el ancho y el alto especificados.

Finalmente, la mayoría de los caracteres especiales (no alfabéticos) se pueden usar como lo que se llama mensajes binarios. Estos permiten que los operadores matemáticos y lógicos se escriban en su forma tradicional:

3 + 4

que envía el mensaje "+" al receptor 3 con 4 pasado como argumento (cuya respuesta será 7). Similarmente,

3 ■ 4

es el mensaje ">" enviado a 3 con el argumento 4 (cuya respuesta será falsa).

Observe que el lenguaje Smalltalk-80 en sí mismo no implica el significado de esos operadores. El resultado de lo anterior solo se define por cómo el receptor del mensaje (en este caso, una instancia de Número) responde a los mensajes "+" y ">".

Un efecto secundario de este mecanismo es la sobrecarga de operadores. Un mensaje ">" también puede ser entendido por otros objetos, lo que permite el uso de expresiones de la forma "a > b" para compararlos.

Expresiones

Una expresión puede incluir varios envíos de mensajes. En este caso, las expresiones se analizan según un orden de precedencia simple. Los mensajes unarios tienen la prioridad más alta, seguidos de los mensajes binarios, seguidos de los mensajes de palabras clave. Por ejemplo:

3 factorial + 4 factorial entre: 10 y: 100

se evalúa de la siguiente manera:

1. 3 recibe el mensaje "factorial" y respuestas 6
2. 4 recibe el mensaje "factorial" y responde 24
3. 6 recibe el mensaje "+" con 24 como argumento y respuestas 30
4. 30 recibe el mensaje "entre: y:" con 10 y 100 como argumentos y respuestas verdaderas

La respuesta del último mensaje enviado es el resultado de toda la expresión.

Los paréntesis pueden alterar el orden de evaluación cuando sea necesario. Por ejemplo,

()3 factorial + 4) factorial entre: 10 y: 100

cambiará el significado para que la expresión primero calcule "3 factorial + 4" dando 10. Ese 10 luego recibe el segundo "factorial" mensaje, dando como resultado 3628800. 3628800 luego recibe 'entre: y:', respondiendo falso.

Tenga en cuenta que debido a que el significado de los mensajes binarios no está integrado en la sintaxis de Smalltalk-80, se considera que todos ellos tienen la misma precedencia y se evalúan simplemente de izquierda a derecha. Debido a esto, el significado de las expresiones de Smalltalk que usan mensajes binarios puede ser diferente de su significado "tradicional" interpretación:

3 + 4 * 5

se evalúa como "(3 + 4) * 5", produciendo 35. Para obtener la respuesta esperada de 23, se deben usar paréntesis para definir explícitamente el orden de las operaciones:

3 + ()4 * 5)

Los mensajes unarios se pueden encadenar escribiéndolos uno tras otro:

3 factorial factorial log

que envía "factorial" a 3, luego "factorial" al resultado (6), luego "log" al resultado (720), produciendo el resultado 2.85733.

Se puede escribir una serie de expresiones como en el siguiente ejemplo (hipotético), cada una separada por un punto. Este ejemplo primero crea una nueva instancia de la clase Ventana, la almacena en una variable y luego le envía dos mensajes.

 Silencio ventana Silencio ventana := Ventana nuevo. ventana etiqueta: ' Hola. '. ventana abierto

Si se envía una serie de mensajes al mismo receptor como en el ejemplo anterior, también se pueden escribir como una cascada con mensajes individuales separados por punto y coma:

 Ventana nuevo etiqueta: ' Hola. '; abierto

Esta reescritura del ejemplo anterior como una sola expresión evita la necesidad de almacenar la nueva ventana en una variable temporal. De acuerdo con las reglas de precedencia habituales, el mensaje unario "nuevo" se envía primero y luego "etiqueta:" y "abrir" se envían a la respuesta de "nuevo".

Bloques de código

Un bloque de código (una función anónima) se puede expresar como un valor literal (que es un objeto, ya que todos los valores son objetos). Esto se logra con corchetes:

[ :params Silencio .Mensaje-expresiones■ ]

Donde :params es la lista de parámetros que puede tomar el código. Esto significa que el código de Smalltalk:

[:x Silencio x + 1]

puede entenderse como:

f()x)=x+1{displaystyle f(x)=x+1}

o expresado en términos lambda como:

λ λ x.x+1{displaystyle lambda x.x+1}

y

[:x Silencio x + 1] valor: 3

puede evaluarse como

f()3)=3+1{displaystyle f(3)=3+1}

O en términos lambda como:

()λ λ x.x+1)3→ → β β 3+1{displaystyle (lambda x.x+1),3{underset {beta # {derecho}3+1}

El objeto de bloque resultante puede formar un cierre: puede acceder a las variables de sus ámbitos léxicos envolventes en cualquier momento. Los bloques son objetos de primera clase.

Los bloques se pueden ejecutar enviándoles el mensaje valor (existen variaciones compuestas para proporcionar parámetros al bloque, por ejemplo, 'valor:valor:' y ' valorConArgumentos:').

La representación literal de bloques fue una innovación que, por un lado, permitió que cierto código fuera significativamente más legible; permitió que los algoritmos que involucraban iteración se codificaran de una manera clara y concisa. El código que normalmente se escribiría con bucles en algunos idiomas se puede escribir de manera concisa en Smalltalk usando bloques, a veces en una sola línea. Pero lo que es más importante, los bloques permiten que la estructura de control se exprese mediante mensajes y polimorfismo, ya que los bloques aplazan el cálculo y el polimorfismo se puede utilizar para seleccionar alternativas. Entonces, if-then-else en Smalltalk está escrito e implementado como

expreso siTrue: [declaraciones a evaluación si expreso] siFalse: [declaraciones a evaluación si no expreso]

Verdaderos métodos de evaluación

siTrue: verdadera alternativa Bloque siFalse: falseAlternative Bloque
^trueAlternative Valor de bloque

Métodos falsos de evaluación

siTrue: verdadera alternativa Bloque siFalse: falseAlternative Bloque
^false Alternativa Valor de bloque

positivo Cuantía := Total Seleccione: [:Monto Silencio Monto Es posible]

Tenga en cuenta que esto está relacionado con la programación funcional, en la que los patrones de cálculo (aquí, la selección) se abstraen en funciones de orden superior. Por ejemplo, el mensaje select: en una colección es equivalente al filtro de función de orden superior en un funtor apropiado.

Estructuras de control

Las estructuras de control no tienen una sintaxis especial en Smalltalk. En cambio, se implementan como mensajes enviados a objetos. Por ejemplo, la ejecución condicional se implementa enviando el mensaje ifTrue: a un objeto booleano, pasando como argumento el bloque de código que se ejecutará si y solo si el receptor booleano es verdadero. Las dos subclases de Boolean implementan ifTrue:, donde la implementación en la subclase True siempre evalúa el bloque y la implementación en la subclase False nunca evalúa el bloque.

El siguiente código demuestra esto:

resultado := a ■ b siTrue:[ "greater" ' ]
 siFalse:[ 'menos o iguales ' ]

Los bloques también se utilizan para implementar estructuras de control definidas por el usuario, enumeradores, visitantes, manejo de excepciones, comportamiento conectable y muchos otros patrones. Por ejemplo:

Silencio aLas vocales SilencioaString := ' Esto es una cuerda..vocales := aString Seleccione: [:aCharacter Silencio aCharacter Viento].

En la última línea, la cadena recibe el mensaje select: con un argumento que es un bloque de código literal. El bloque de código literal se usará como una función de predicado que debe responder verdadero si y solo si un elemento de String debe incluirse en la colección de caracteres que satisfacen la prueba representada por el bloque de código que es el argumento de "seleccionar:" mensaje.

Un objeto String responde al comando "select:" mensaje iterando a través de sus miembros (enviándose a sí mismo el mensaje "do:"), evaluando el bloque de selección ("aBlock") una vez con cada carácter que contiene como argumento. Cuando se evalúa (enviando el mensaje "value: each"), el bloque de selección (referenciado por el parámetro "aBlock", y definido por el bloque literal "[:aCharacter | aCharacter isVowel]"), responde un booleano, que luego se envía "ifTrue:". Si el booleano es el objeto verdadero, el carácter se agrega a una cadena para devolverlo. Porque el "select:" El método se define en la colección de clases abstractas, también se puede usar así:

Silencio Rectángulos aPoint colisiones Silenciorectángulos := Recolección ordenada con: ()Rectángulo izquierda: 0 Bien. 10 arriba: 100 abajo: 200)
 con: ()Rectángulo izquierda: 10 Bien. 10 arriba: 110 abajo: 210).aPoint := Punto x: 20 Y: 20.colisiones := rectángulos Seleccione: [:aRect Silencio aRect contienePoint: aPoint].

El mecanismo de manejo de excepciones usa bloques como manejadores (similar al manejo de excepciones al estilo CLOS):

[
 algunos operación] sobre:Error hacer:[:ex Silencio handler-código ex retorno]

El controlador de excepciones "ex" proporciona acceso al estado de la operación suspendida (marco de pila, número de línea, receptor y argumentos, etc.), "ex rechazo", "ex reinicio" o "ex devolución").

Clases

Esta es una definición de clase de acciones:

Objeto subclase: #MessagePublisher ejemplo Variable Nombres: ' ' claseVariable Nombres: ' ' billarDiccionarios: ' ' categoría: 'Smalltalk Ejemplos '

A menudo, la mayor parte de esta definición la completará el entorno. Note que este es un mensaje a la clase Object para crear una subclase llamada MessagePublisher. En otras palabras: las clases son objetos de primera clase en Smalltalk que pueden recibir mensajes como cualquier otro objeto y pueden crearse dinámicamente en tiempo de ejecución.

Métodos

Cuando un objeto recibe un mensaje, se invoca un método que coincide con el nombre del mensaje. El siguiente código define un método de publicación y, por lo tanto, define lo que sucederá cuando este objeto reciba el mensaje 'publicar' mensaje.

publicar Transcripción Mostrar: ¡Hola Mundo! '

El siguiente método demuestra recibir múltiples argumentos y devolver un valor:

quadMultiply: i1 y: i2 "Este método multiplica los números dados entre sí y el resultado por 4." Silencio mul Silencio mul := i1 * i2. ^mul * 4

El nombre del método es #quadMultiply:and:. El valor de retorno se especifica con el operador ^.

Tenga en cuenta que los objetos son responsables de determinar dinámicamente en tiempo de ejecución qué método ejecutar en respuesta a un mensaje, mientras que en muchos lenguajes esto puede (a veces, o incluso siempre) determinarse estáticamente en tiempo de compilación.

Instanciación de clases

El siguiente código:

MensajePublisher nuevo

crea (y devuelve) una nueva instancia de la clase MessagePublisher. Esto normalmente se asigna a una variable:

editor := MensajePublisher nuevo

Sin embargo, también es posible enviar un mensaje a un objeto anónimo temporal:

MensajePublisher nuevo publicar

Ejemplo de Hola Mundo

El programa Hello world es utilizado por prácticamente todos los textos para nuevos lenguajes de programación como el primer programa aprendido para mostrar la sintaxis y el entorno más básico del lenguaje. Para Smalltalk, el programa es extremadamente simple de escribir. El siguiente código, el mensaje "mostrar:" se envía al objeto "Transcripción" con el literal de cadena '¡Hola, mundo!' como su argumento. Invocación del "show:" hace que los caracteres de su argumento (el literal de cadena '¡Hola, mundo!') se muestren en la ventana de transcripción ("terminal").

Transcripción Mostrar: ¡Hola, mundo! '.

Tenga en cuenta que se debe abrir una ventana de Transcripción para ver los resultados de este ejemplo.

Persistencia basada en imágenes

Los sistemas de programación más populares separan el código de programa estático (en forma de definiciones de clase, funciones o procedimientos) del estado de programa dinámico o de tiempo de ejecución (como objetos u otras formas de datos de programa). Cargan el código del programa cuando se inicia un programa, y cualquier estado anterior del programa debe recrearse explícitamente a partir de archivos de configuración u otras fuentes de datos. Cualquier configuración que el programa (y el programador) no guarde explícitamente debe configurarse nuevamente para cada reinicio. Un programa tradicional también pierde mucha información útil del documento cada vez que un programa guarda un archivo, se cierra y vuelve a cargar. Esto pierde detalles como el historial de deshacer o la posición del cursor. Los sistemas basados en imágenes no obligan a perder todo eso solo porque una computadora está apagada o se actualiza un sistema operativo.

Muchos sistemas Smalltalk, sin embargo, no diferencian entre datos de programa (objetos) y código (clases). De hecho, las clases son objetos. Por lo tanto, la mayoría de los sistemas de Smalltalk almacenan el estado completo del programa (incluidos los objetos de clase y los que no son de clase) en un archivo de imagen. Luego, la máquina virtual de Smalltalk puede cargar la imagen para restaurar un sistema similar a Smalltalk a un estado anterior. Esto se inspiró en FLEX, un lenguaje creado por Alan Kay y descrito en su M.Sc. tesis.

Las imágenes de Smalltalk son similares a los volcados del núcleo (reiniciables) y pueden proporcionar la misma funcionalidad que los volcados del núcleo, como la depuración retrasada o remota con acceso total al estado del programa en el momento del error.

Otros lenguajes que modelan código de aplicación como una forma de datos, como Lisp, a menudo también usan persistencia basada en imágenes (ver EMACS, por ejemplo). Este método de persistencia es poderoso para un desarrollo rápido porque toda la información de desarrollo (por ejemplo, los árboles de análisis del programa) se guarda, lo que facilita la depuración.

Sin embargo, también tiene serios inconvenientes como verdadero mecanismo de persistencia. Por un lado, los desarrolladores a menudo pueden querer ocultar los detalles de implementación y no ponerlos a disposición en un entorno de tiempo de ejecución. Por razones de legalidad y mantenimiento, permitir que cualquier persona modifique un programa en tiempo de ejecución inevitablemente introduce complejidad y errores potenciales que no serían posibles con un sistema compilado que no expone el código fuente en el entorno de tiempo de ejecución. Además, aunque el mecanismo de persistencia es fácil de usar, carece de las verdaderas capacidades de persistencia necesarias para la mayoría de los sistemas multiusuario. La más obvia es la capacidad de realizar transacciones con múltiples usuarios que acceden a la misma base de datos en paralelo.

Nivel de acceso

Todo en Smalltalk-80, a menos que se personalice para evitar la posibilidad, está disponible para su modificación desde un programa en ejecución. Esto significa que, por ejemplo, el IDE se puede cambiar en un sistema en ejecución sin reiniciarlo. En algunas implementaciones, la sintaxis del lenguaje o la implementación de recolección de basura también se puede cambiar sobre la marcha. Incluso la declaración true se convierte en: false es válida en Smalltalk, aunque no se recomienda ejecutarla excepto con fines de demostración (consulte máquina virtual, persistencia basada en imágenes y copias de seguridad).

Compilación justo a tiempo

Los programas de Smalltalk generalmente se compilan en un código de bytes, que luego es interpretado por una máquina virtual o traducido dinámicamente a código nativo de la máquina.

Lista de implementaciones

Abrir Smalltalk

OpenSmalltalk VM (OS VM) es una implementación notable de la máquina virtual Smalltalk en la que se basan o derivan muchas implementaciones modernas de Smalltalk. OS VM en sí se transpila de un conjunto de archivos de código fuente de Smalltalk (usando un subconjunto de Smalltalk llamado Slang) al código fuente del lenguaje C nativo (usando un transpiler llamado VMMaker), que a su vez se compila contra una plataforma y arquitectura específicas del hardware. prácticamente permitiendo la ejecución multiplataforma de las imágenes de Smalltalk. El código fuente está disponible en GitHub y se distribuye bajo licencia MIT. Las implementaciones conocidas de Smalltalk basadas en el sistema operativo VM son:

• Squeak, la fuente abierta original Smalltalk que el OpenSmalltalk VM fue construido para
• Pharo Smalltalk, un lenguaje multiplataforma de código abierto
• Cuis-Smalltalk, un tenedor pequeño, limpio y compatible con Smalltalk-80 de Squeak
• Haver-Smalltalk una extensión de Cuis con un módulo-System completo
• Croquet VM, a Squeak-related Smalltalk VM for Croquet Project

Otros

• Amber Smalltalk, corre en JavaScript a través de la transpilación
• Delfín Smalltalk de Artes de Objetos
• Etoys, un sistema de programación visual para aprender
• F-Script, aplicación sólo macOS escrita en 2009
• GemStone/S de GemTalk Systems
• GNU Smalltalk, headless (lacks GUI) implementation of Smalltalk
• Pequeño pequeño
• Smalltalk MT Smalltalk para Windows desde Object Connect
• ObjectStudio de Cincom
• Pocket Smalltalk, corre en Palm Pilot
• Rosetta Smalltalk, desarrollada por Scott Warren en 1979 y anunciada como un cartucho para el ordenador Exidy Sorcerer pero nunca liberado
• Arrastre un sistema de programación visual (sólo versiones antes de 2.0 están basados en Smalltalk)
• SmallJ, una fuente abierta Smalltalk basada en Java, derivada de SmallWorld
• Smalltalk/X, desarrollado por Claus Gittinger
• StepTalk, marco de scripting GNUstep utiliza lenguaje Smalltalk en un tiempo de ejecución Objetivo-C
• Strongtalk, an open-source (since 2006) Versión sólo para Windows, ofrece un marcador fuerte opcional; creado inicialmente en Laboratorios Sun Microsystem.
• TruffleSqueak, a Squeak/Smalltalk VM and Polyglot Programming Environment for the GraalVM (más implementaciones basadas en GraalVM Smalltalk se pueden encontrar aquí)
• VAST Platform (VA Smalltalk), desarrollada por Instantiations, Inc
• Visual Age Smalltalk from IBM
• Visual Smalltalk Enterprise, y familia, incluyendo Smalltalk/V
• VisualWorks de Cincom
• Zag, Smalltalk VM escrito en Zig con métodos almacenados como ASTs anotados por tipo

Máquina virtual de JavaScript

• PharoJS un transpilador de código abierto de Smalltalk a Javascript, que extiende el entorno Pharo
• SqueakJS un OpenSmalltalk-compatible VM para la web, también funciona aplicaciones Squeak más antiguas como Etoys o Scratch