Charla informal

Smalltalk es un lenguaje de programación puramente orientado a objetos que se creó originalmente en la década de 1970 con fines educativos , específicamente para el aprendizaje constructivista , pero que posteriormente se utilizó en el ámbito empresarial. Fue creado en Xerox PARC por científicos del Learning Research Group (LRG), entre ellos Alan Kay , Dan Ingalls , Adele Goldberg , Ted Kaehler , Diana Merry y Scott Wallace.

En Smalltalk, los programas en ejecución se componen de objetos atómicos y opacos , que son instancias de código plantilla almacenado en clases. Estos objetos se comunican entre sí mediante el intercambio de mensajes a través de un entorno de máquina virtual (VM) intermedio. Un número relativamente pequeño de objetos, denominados primitivos, no se pueden redefinir en tiempo real, y en ocasiones se definen independientemente del entorno de programación de Smalltalk.

Tras haber experimentado un importante desarrollo industrial hacia otros usos, incluyendo funciones empresariales y de bases de datos , Smalltalk sigue utilizándose hoy en día. Cuando se lanzó públicamente por primera vez, Smalltalk-80 presentó numerosas ideas fundamentales para el incipiente campo de la programación orientada a objetos.

Desde sus inicios, 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 código . El desarrollo posterior ha dado lugar a al menos una instancia del entorno de ejecución de Smalltalk que carece de dicha interfaz gráfica de usuario o front-end integrados.

Los lenguajes tipo Smalltalk se encuentran en desarrollo activo y han reunido comunidades de usuarios a su alrededor. El estándar ANSI Smalltalk del Instituto Nacional Estadounidense de Estándares (ANSI) fue ratificado en 1998 y representa la versión estándar de Smalltalk. ^{[ 5 ]}

Smalltalk ocupó el segundo lugar como "lenguaje de programación más querido" en la encuesta de desarrolladores de Stack Overflow de 2017, ^{[ 6 ]} pero no estuvo entre los 26 lenguajes de programación más queridos de la encuesta de 2018. ^{[ 7 ]}

Hay una gran cantidad de variantes de Smalltalk. ^{[ 8 ]} La palabra Smalltalk, sin calificar , 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 ejecutaron las máquinas virtuales de Smalltalk fueron las computadoras Xerox Alto .

Smalltalk fue producto de la 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. Smalltalk-71 fue un diseño de lenguaje no publicado por Kay (alrededor de 1971). ^{[ 9 ]} En septiembre de 1972, Kay apostó a que el núcleo de un lenguaje de programación basado en la idea de paso de mensajes podría implementarse en "una página de código"; para la mañana del octavo día, había surgido un esquema de intérprete funcional, que formó la base de lo que ahora se denomina Smalltalk-72. ^{[ 4 ]} Su sintaxis y modelo de ejecución eran muy diferentes de las variantes modernas de Smalltalk.

El primer intérprete de Smalltalk implementado fue para Smalltalk-72, y fue escrito por Dan Ingalls en aproximadamente 700 líneas de BASIC en octubre de 1972 para Data General Nova . Esta versión fue demostrada en el Laboratorio de IA del MIT por Alan Kay en noviembre de ese año; las publicaciones sobre el modelo Actor citan este período y las ideas de paso de mensajes de Smalltalk-72 como una influencia en el desarrollo del modelo. ^{[ 10 ] [ 4 ]} Las primeras rutinas de dibujo de líneas de mapa de bits fueron implementadas por Ted Kaehler a finales de diciembre de 1972. Smalltalk-72 fue portado a Xerox Alto en abril de 1973, el mismo mes en que las primeras unidades comenzaron a funcionar. ^{[ 11 ]}

Tras importantes revisiones que congelaron algunos aspectos de la semántica de ejecución para mejorar el rendimiento (adoptando un modelo de herencia de clases similar al de Simula ), se creó Smalltalk-76. Este sistema contaba con un entorno de desarrollo que incluía la mayoría de las herramientas que ahora nos resultan familiares, como un explorador/editor de código de biblioteca de clases. Smalltalk-80 añadió metaclases para ayudar a mantener el paradigma de que "todo es un objeto" (excepto las variables), asociando propiedades y comportamientos a clases individuales, e incluso a primitivos como valores enteros y booleanos (por ejemplo, para admitir diferentes formas de crear instancias).

Smalltalk-80 fue la primera variante de lenguaje disponible fuera de PARC. En 1981, se compartió con Tektronix , Hewlett-Packard , Apple Computer y DEC para su revisión y depuración en sus plataformas. ^{[ 12 ] [ 13 ]} El número de agosto de 1981 de la revista Byte se dedicó a Smalltalk-80 y dio a conocer sus ideas a un público amplio. También se publicaron varios libros sobre Smalltalk-80. Smalltalk-80 se convirtió en la base de todas las futuras versiones comerciales de Smalltalk. ^{[ 14 ]} El lanzamiento final de Smalltalk-80 Versión 1 fue en noviembre de 1981. ^{[ 15 ]} Xerox solo distribuyó la Versión 1 a Apple, DEC, HP y Tektronix, pero a estas empresas se les permitió la redistribución sin restricciones a través de cualquier sistema que construyeran. Esto fomentó la amplia difusión de Smalltalk. ^{[ 11 ]} Posteriormente, en 1983, Xerox lanzó Smalltalk-80 Versión 2. Esta versión estuvo generalmente disponible para el público, aunque bajo una licencia restrictiva. Las versiones 1 y 2 eran bastante similares, si bien la versión 2 incluía algunas características adicionales, como un corrector ortográfico. Cada lanzamiento constaba de una imagen virtual (archivo independiente de la plataforma con definiciones de objetos) y una especificación de máquina virtual . ^{[ 11 ]}

ANSI Smalltalk ha sido el lenguaje de referencia estándar desde 1998. ^{[ 16 ]} Dos variantes de implementación de Smalltalk actualmente populares son descendientes de las 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 creada para llevar Smalltalk al mercado). Como un vínculo interesante entre generaciones, en 2001, Vassili Bykov implementó Hobbes, una máquina virtual que ejecuta Smalltalk-80 dentro de VisualWorks. ^{[ 17 ]} ( Dan Ingalls posteriormente adaptó Hobbes a Squeak).

Entre finales de la década de 1980 y mediados de la de 1990, dos organizaciones competidoras, ParcPlace Systems y Digitalk, ambas con sede en California, comercializaban entornos Smalltalk, incluyendo soporte, capacitación y complementos. ParcPlace Systems se centraba en el mercado de microsistemas Unix/Sun, mientras que Digitalk se enfocaba en PCs con procesadores Intel que ejecutaban Microsoft Windows o IBM OS/2. Ambas empresas tuvieron dificultades para popularizar Smalltalk debido a sus elevados requisitos de memoria, su rendimiento limitado y la falta inicial de compatibilidad con servidores de bases de datos relacionales SQL . Si bien el alto precio de ParcPlace Smalltalk limitó su penetración en el mercado a organizaciones comerciales medianas y grandes, los productos de Digitalk intentaron inicialmente llegar a un público más amplio con un precio más bajo. IBM inicialmente brindó soporte al producto de Digitalk, pero luego ingresó al mercado en 1995 con un producto Smalltalk llamado VisualAge/Smalltalk. En ese momento, Easel lanzó Enfin para Windows y OS/2. Enfin se popularizó enormemente en Europa, ya que IBM lo introdujo en los departamentos de informática antes del desarrollo de IBM Smalltalk (posteriormente VisualAge). Más tarde, Cincom Systems adquirió Enfin , que ahora se comercializa 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 cambiaron su nombre en 1997 a ObjectShare, ubicada en Irvine, California . ObjectShare ( NASDAQ : OBJS) cotizó en bolsa hasta 1999, cuando fue excluida de la bolsa y disuelta. La empresa fusionada nunca logró encontrar una respuesta efectiva a Java en cuanto a posicionamiento de mercado, y para 1997 sus propietarios buscaban vender el negocio. En 1999, Seagull Software adquirió el laboratorio de desarrollo Java de ObjectShare (incluido el equipo de desarrollo original de Smalltalk/V y Visual Smalltalk), y aún posee VisualSmalltalk, aunque los derechos de distribución mundial del producto Smalltalk permanecieron en manos de ObjectShare, quien luego los vendió a Cincom . ^{[ 18 ]} VisualWorks fue vendido a Cincom y ahora forma parte de Cincom Smalltalk. Cincom ha respaldado firmemente a Smalltalk, lanzando múltiples versiones nuevas de VisualWorks y ObjectStudio cada año desde 1999.

Cincom, GemTalk e Instantiations siguen vendiendo entornos Smalltalk. IBM puso fin a VisualAge Smalltalk, tras haber decidido a finales de la década de 1990 respaldar Java en su lugar y, a partir de 2005, cuenta con el respaldo de Instantiations, Inc. ^{[ 19 ]} Instantiations renombró el producto VA Smalltalk (VAST Platform) y continúa lanzando nuevas versiones anualmente. La implementación abierta de Squeak tiene una comunidad activa de desarrolladores, incluyendo a muchos de la comunidad original de Smalltalk, y se utilizó para proporcionar el entorno Etoys en el proyecto One Laptop per Child (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 el uso en entornos comerciales.

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

Smalltalk fue uno de los muchos lenguajes de programación orientados a objetos basados ​​en Simula . ^{[ 20 ]} 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 , ^{[ 21 ]} CLOS , Objective-C , Java , Python , Ruby , ^{[ 22 ]} y muchos otros— fueron influenciados por Smalltalk. Smalltalk también fue uno de los lenguajes más populares para métodos de desarrollo de software ágil , desarrollo rápido de aplicaciones (RAD) o prototipado, y patrones de diseño de software . ^{[ 23 ]} El entorno altamente productivo proporcionado por las plataformas Smalltalk las hizo ideales para el desarrollo rápido e iterativo.

Smalltalk surgió de un programa más amplio de investigación financiado 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, investigadores de ARPA desarrollaron prototipos funcionales de tecnologías como el hipertexto , las interfaces gráficas de usuario (GUI), la multimedia , el ratón, la telepresencia e Internet en la década de 1960. ^{[ 24 ] [ 25 ]} Alan Kay (uno de los inventores de Smalltalk) también describió una tableta que denominó Dynabook , similar a las tabletas modernas. ^{[ 4 ]}

Los entornos Smalltalk fueron a menudo los primeros en desarrollar lo que ahora son patrones de diseño de software orientados a objetos comunes. Uno de los más populares es el patrón modelo-vista-controlador (MVC) para el diseño de interfaces de usuario . El patrón MVC permite a los desarrolladores tener múltiples vistas consistentes de los mismos datos subyacentes. Es ideal para entornos de desarrollo de software, donde existen diversas vistas (por ejemplo, entidad-relación, flujo de datos, modelo de objetos, etc.) de la misma especificación subyacente. También es útil para simulaciones o juegos donde el modelo subyacente puede verse desde varios ángulos y niveles de abstracción. ^{[ 26 ]}

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

Smalltalk utiliza varios operadores de filtro de colección que riman con el sufijo "-ect", collect:, select:, inject:into:, etc. Esto se inspiró en una frase del monólogo de Arlo Guthrie de 1967 " Alice's Restaurant Massacree ", en el que Guthrie fue sometido a una serie de "inyecciones, inspecciones, detección, infección, negligencia y selección". ^{[ 28 ]}

Al igual que en otros lenguajes orientados a objetos, el concepto central en Smalltalk-80 (pero no en Smalltalk-72) es el de 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 interfaz gráfica de usuario (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 particular tendría sus propios valores para esas propiedades, y cada uno de ellos podría realizar las operaciones definidas por su clase.

Un objeto Smalltalk puede hacer exactamente tres cosas:

1. Mantener el estado (referencias a otros objetos).
2. Recibir un mensaje de sí mismo o de otro objeto.
3. Durante el procesamiento de un mensaje, envía mensajes a sí mismo o a otro objeto.

El estado que mantiene un objeto siempre es privado para ese objeto. Otros objetos solo pueden consultar o cambiar ese estado enviando solicitudes (mensajes) al objeto para que lo haga. Cualquier mensaje puede enviarse a cualquier objeto: cuando se recibe un mensaje, el receptor determina si ese mensaje es apropiado. Si el objeto no entiende el mensaje, la máquina virtual envía el mensaje `doesNotUnderstand: ` con el mensaje original como argumento. La implementación predeterminada de `doesNotUnderstand:` genera una excepción que, si no se captura, abre el depurador del sistema . Alan Kay ha comentado que, a pesar de la atención prestada 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)». ^{[ 29 ]}

A diferencia de la mayoría de los demás lenguajes, el código de Smalltalk se puede modificar mientras el sistema está en funcionamiento. La codificación en vivo y la aplicación de correcciones "sobre la marcha" es una metodología de programación predominante en Smalltalk y una de las principales razones de su productividad.

Smalltalk es un lenguaje de programación orientado a objetos "puro", lo que significa que, a diferencia de C++ y Java , no existen tipos primitivos. Todos los valores se representan como objetos y el cálculo con enteros utiliza el envío de mensajes, al igual que con cualquier otro objeto. En Smalltalk, tipos como 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. Para mayor eficiencia y generalidad, los enteros se implementan mediante cuatro clases: Integer, la superclase abstracta de todos los enteros; SmallInteger, cuyas instancias caben en una palabra de máquina , por ejemplo, teniendo un rango con signo de 61 bits en una implementación de 64 bits; y LargePositiveInteger y LargeNegativeInteger, que son vectores de bytes. En consecuencia, Smalltalk es capaz de evaluar el factorial de 52 para producir80 658 175 170 943 878 571 660 636 856 403 766 975 289 505 440 883 277 824 000 000 000 000 . La transición de enteros pequeños a grandes es transparente para el programador; las variables no requieren declaraciones de tipo. Esto hace que el sistema sea conciso y flexible. Un programador puede cambiar o extender (a través de subclases ) las clases que implementan lo que en otros lenguajes serían valores primitivos, de modo que se pueda definir un nuevo comportamiento para sus instancias, por ejemplo, para implementar nuevas estructuras de control, o incluso para que se cambie 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 lo son. Cada clase es una instancia de la metaclase de esa clase. Las metaclases, a su vez, también son objetos, y todas son instancias de una clase llamada Metaclass. Las clases contienen diccionarios de métodos que asignan selectores (el equivalente a los nombres de procedimientos de función en otros lenguajes) a objetos de método, objetos que se ejecutan para evaluar mensajes. Las clases heredan de otras clases, con Object o ProtoObject en la raíz de la jerarquía de clases. Enviar un mensaje a un objeto, en el nivel más abstracto, implica obtener la clase del receptor (el objeto al que se envía el mensaje) y buscar el selector del mensaje en el diccionario de métodos de la clase, seguido de la superclase y así sucesivamente hasta que se encuentre el método o se envíe doesNotUnderstand. Las máquinas virtuales de Smalltalk utilizan varias técnicas para acelerar la búsqueda de mensajes, de modo que el sistema proporciona un mecanismo de enlace de mensajes simple y consistente, además de una buena eficiencia. Los bloques de código —la forma en que Smalltalk expresa funciones anónimas— también son objetos. ^{[ 30 ]} Tienen una sintaxis muy ligera y se utilizan en todo el sistema para implementar estructuras de control, especialmente para la jerarquía Collection.

La reflexión es una característica propia de los metamodelos, como los que utiliza Smalltalk. El metamodelo es la parte del sistema que implementa el propio sistema de programación, y los desarrolladores pueden usarlo para realizar tareas como recorrer, examinar y modificar el código en ejecución, o encontrar todas las instancias de un tipo específico de estructura (por ejemplo, todas las instancias de la clase Method en el metamodelo).

Smalltalk-80 es un sistema totalmente reflexivo. Proporciona reflexión tanto estructural como computacional. Smalltalk es un sistema estructuralmente reflexivo cuya estructura se define mediante objetos Smalltalk-80. Las clases y los métodos que definen el sistema también son objetos y forman parte integral del sistema que ayudan a definir. El compilador de Smalltalk, escrito en Smalltalk y que coexiste con el resto del código del sistema, compila el código fuente textual en objetos de método, normalmente instancias de CompiledMethod. Estos se añaden 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 añadir nuevas clases al sistema. El sistema se extiende ejecutando código Smalltalk-80 que crea o define clases y métodos. De esta forma, un sistema Smalltalk-80 es un sistema "vivo", con la capacidad de extenderse en tiempo de ejecución. Incluso se puede extender el compilador en tiempo de ejecución; de hecho, así es como se desarrolla y mantiene el compilador.

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

Smalltalk-80 también proporciona reflexión computacional, la capacidad de observar el estado computacional del sistema. En los lenguajes derivados del Smalltalk-80 original, la activación actual de un método es accesible como un objeto nombrado mediante una pseudovariable (una de las seis palabras reservadas), thisContextque corresponde a un marco de pila en implementaciones de lenguajes convencionales, y se denomina "contexto". El envío de un mensaje se realiza dentro de un contexto, y para evaluar el mensaje se crea otro contexto, siendo el primero el remitente del anterior. De esta forma, la pila es una lista enlazada de objetos de contexto, y el depurador es esencialmente un inspector de esta pila compleja . Al enviar mensajes a thisContextla activación de un método, se pueden hacer preguntas como "¿quién me envió este mensaje?". Estas funcionalidades permiten implementar corrutinas o retroceso al estilo de Prolog sin modificar la máquina virtual. El sistema de excepciones se implementa utilizando esta funcionalidad. Uno de los usos más interesantes de esto se encuentra en el marco web Seaside , que libera al programador de lidiar con la complejidad del botón de retroceso de un navegador web al almacenar continuaciones para cada página editada y alternar entre ellas mientras el usuario navega por un sitio web. La programación del servidor web usando Seaside se puede entonces hacer utilizando un estilo de programación más convencional. ^{[ 32 ]} Al igual que con el envío de mensajes, las máquinas virtuales Smalltalk-80 optimizan internamente el costoso uso de contextos, proporcionando la ilusión y flexibilidad de una pila espagueti sin la mayoría de sus costos. Esencialmente, los objetos de contexto se crean de manera diferida según sea necesario, por ejemplo, cuando se envía un mensaje a la variable thisContext.

Un ejemplo de cómo Smalltalk puede usar la reflexión es el mecanismo para manejar errores. Cuando un objeto recibe un mensaje que no implementa, la máquina virtual le envía el doesNotUnderstand:mensaje con una reificación del mismo como argumento. El mensaje (otro objeto, una instancia de Message) contiene el selector del mensaje y una lista Arrayde sus argumentos. En un sistema Smalltalk interactivo, la implementación predeterminada de doesNotUnderstand:abre una ventana de error (un notificador) que informa del error al usuario. Mediante esto y las funcionalidades de reflexión, el usuario puede examinar el contexto en el que se produjo el error, redefinir el código que lo causó y continuar, todo dentro del sistema, utilizando las funcionalidades de reflexión de Smalltalk-80. ^{[ 33 ] [ 34 ]}

Al crear una clase que entiende (implementa) solo doesNotUnderstand:, se puede crear una instancia que puede interceptar cualquier mensaje que se le envíe a través de su método doesNotUnderstand:. Estas instancias se denominan proxies transparentes. ^{[ 35 ]} Estos proxies se pueden utilizar para implementar una serie de funcionalidades, como Smalltalk distribuido, donde se intercambian mensajes entre múltiples sistemas Smalltalk, interfaces de bases de datos donde los objetos se extraen de forma transparente de una base de datos, promesas , etc. El diseño de Smalltalk distribuido influyó en sistemas como CORBA .

La sintaxis de Smalltalk-80 es bastante minimalista, basada en solo unas pocas declaraciones. De hecho, solo hay cinco "palabras clave" en Smalltalk, nombres de pseudovariables con un significado especial: true, false, nil, self, y super. Estas se denominan propiamente pseudovariables , identificadores que siguen las reglas de los identificadores de variables pero denotan enlaces que un programador no puede cambiar. Las pseudovariables true, false, y son instancias singleton . y se refieren al receptor de un mensaje dentro de un método activado en respuesta a ese mensaje, pero los envíos a se buscan en la superclase de la clase que define el método en lugar de la clase del receptor, lo que permite que los métodos en subclases invoquen métodos del mismo nombre en superclases. Las únicas construcciones de lenguaje integradas son envíos de mensajes, asignación, retorno de método, sintaxis literal para algunos objetos, incluidos literales de bloque (cierres). Desde sus orígenes como un lenguaje para niños de todas las edades, la sintaxis estándar de Smalltalk utiliza la puntuación de una manera más parecida al inglés que los lenguajes de programació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 de la biblioteca de clases estándar de Smalltalk (por motivos de rendimiento, algunas implementaciones pueden reconocer y tratar como especiales ciertos mensajes; sin embargo, esto es solo una optimización y no está codificado en la sintaxis del lenguaje). Es posible que se haya añadido la pseudovariable en algunas implementaciones, pero no se menciona ni en Smalltalk-80 ni en el estándar ANSI. Las pseudovariables generalmente representan argumentos pasados ​​a mensajes o bloques; su contenido es de solo lectura y no se puede modificar.nilselfsupersuperthisContext

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, tal como la relató 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: ^{[ 36 ] [ 37 ]}

exampleWithNumber: x | y | true & false not & ( nil isNil ) ifFalse: [ self halt ] . y := self size + super size . #( $a #a 'a' 1 1.0 ) do: [ : each | Transcript show: ( each class name ) ; show: ' ' ] . ^ x < y

42 - 42 123 . 45 1 . 2345e2 2r10010010 16 rA000

$A

'¡Hola Mundo!'

'Les dije "¡Hola, mundo!".

'Les dije "¡Hola, mundo!".

# 'foo'

#foo

#( 1 2 3 4 )

#(( 1 2 3 4 ) [ 1 2 3 4 ] 'cuatro' 4.0 #cuatro)

# [ 1 2 3 4 ] 

[... Algo de código Smalltalk . ..] 

[ : a : b | a < b ] 

| índice |

| vocales de índice |

vocales := 'aeiou'

42 factorial

unNúmeroBastanteGrande := 42 factorial

2 elevadoA: 4

'hola mundo' índiceDe: $o comenzandoEn: 6

nuevo Rectángulo ( 100 , 200 );

Rectángulo : ancho: 100 , alto: 200

3 + 4

3 > 4

3 factorial + 4 factorial entre: 10 y: 100

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

3 + 4 * 5

3 + ( 4 * 5 ) 

3 factorial factorial log

| ventana | ventana := Ventana nueva . etiqueta de ventana : 'Hola' . ventana abierta

Nueva etiqueta de ventana : 'Hola' ; abrir

[ : parámetros | < expresiones de mensaje > ] 

[ : x | x + 1 ] 

[ : x | x + 1 ] valor: 3

expr ifTrue: [ instrucciones para evaluar if expr ] ifFalse: [ instrucciones para evaluar if not expr ] 

ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock ^trueAlternativeBlock valor     

ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock ^falseAlternativeBlock valor     

positiveAmounts := allAmounts seleccionar: [ : anAmount | anAmount isPositive ] 

En Smalltalk, las estructuras de control no tienen una sintaxis especial. En su lugar, se implementan como mensajes enviados a objetos. Por ejemplo, la ejecución condicional se implementa enviando el mensaje `ifTrue:` a un objeto `Boolean`, pasando como argumento el bloque de código que se ejecutará solo si el receptor `Boolean` es `true`. 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 lo evalúa.

El siguiente código lo demuestra:

resultado := a > b si es verdadero: [ 'mayor' ] si es falso: [ 'menor o igual' ] 

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:

| aString vocales | aString := 'Esta es una cadena' . vocales := aString seleccionar: [ : aCharacter | aCharacter esVocal ] .

En la última línea, se envía a la cadena el mensaje "select:" con un argumento que es un bloque de código literal. Este bloque de código literal se utilizará como una función predicado que debe responder "verdadero" si y solo si un elemento de la cadena está incluido en la colección de caracteres que satisfacen la prueba representada por el bloque de código que es el argumento del mensaje "select:".

Un objeto String responde al mensaje "select:" 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. Al ser evaluado (al recibir el mensaje "value: each"), el bloque de selección (referenciado por el parámetro "aBlock" y definido por el literal de bloque "[:aCharacter | aCharacter isVowel]") responde con un valor booleano, que luego se envía "ifTrue:". Si el valor booleano es verdadero, el carácter se agrega a una cadena que se devolverá. Dado que el método "select:" está definido en la clase abstracta Collection, también se puede usar de esta manera:

| rectángulos colisiones de aPoint | rectángulos := Colección ordenada con: ( Rectángulo izquierda: 0 derecha: 10 arriba: 100 abajo: 200 ) con: ( Rectángulo izquierda: 10 derecha: 10 arriba: 110 abajo: 210 ) . aPoint := Punto x: 20 y: 20 . colisiones := rectángulos seleccionar: [ : aRect | aRect contienePoint: aPoint ] .

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

[ alguna operación ] en: Error hacer: [ : ex | controlador - código ex devolver ] 

El argumento "ex" del manejador de excepciones proporciona acceso al estado de la operación suspendida (marco de pila, número de línea, receptor y argumentos, etc.) y también se utiliza para controlar cómo debe proceder el cálculo (enviando uno de los siguientes mensajes: "ex proceed", "ex reject", "ex restart" o "ex return").

Esta es una definición de clase de acciones: ^{[ 39 ]}

Subclase de objeto : #MessagePublisher instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' category: 'Smalltalk Examples'

A menudo, la mayor parte de esta definición la completará el entorno. Nótese que este es un mensaje a la Objectclase 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.

Publicar transcripción del programa: '¡Hola mundo!'

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

Nuevo editor de mensajes

editor := MessagePublisher nuevo

Nuevo publicador de MessagePublisher

Smalltalk es uno de los primeros sistemas basados ​​en un Entorno de Desarrollo Integrado (IDE ). Ofrece una amplia variedad de herramientas para el desarrollo de código y otras actividades, como gráficos y música. Smalltalk fue el primer sistema en el que se creó el paradigma moderno de escritorio de Ventanas, Iconos, Menús y Punteros ( WIMP ). Si bien los punteros ya se habían inventado, Smalltalk fue el primer sistema en implementar ventanas superpuestas y menús emergentes. Aunque existen varias herramientas de programación, describiremos las siguientes cinco principales. Las imágenes de las herramientas provienen de un sistema Squeak de 2024.

• navegador, la principal herramienta para ver y escribir código
• espacio de trabajo, un editor de texto en el que se pueden evaluar expresiones
• transcripción, una ventana de salida para texto, que en muchos dialectos también es un espacio de trabajo
• inspector
• notificador/depurador, una ventana que se abre en respuesta a una excepción no controlada y que puede transformarse en un depurador completo.

Navegador

Los sistemas derivados de Smalltalk-80 organizan las clases dentro de "categorías del sistema", como Kernel-Numbers, Kernel-Objects, Collections-Abstract, Collections-Sequenceable, etc., y dentro de las clases los métodos se organizan en categorías con nombre como accessing, arithmetic, instance creation, etc. De esto se deriva el clásico navegador de cinco paneles, con cuatro paneles en la mitad superior de la ventana que contienen de arriba a la izquierda la lista de categorías del sistema, que cuando se selecciona una muestra en la segunda ventana la lista de clases en esa categoría, que cuando se selecciona una muestra la lista de categorías de mensajes en la clase seleccionada, que cuando se selecciona una muestra en el último panel los selectores de los métodos en la categoría seleccionada en la clase seleccionada. Cuando se selecciona uno de los selectores en el cuarto panel, el código fuente de ese método se muestra en el quinto panel. Si solo se selecciona una categoría y no un método, el quinto panel muestra una plantilla para definir un nuevo método. Si se selecciona una categoría del sistema pero no una clase, se muestra una plantilla para crear una clase en la categoría. Diversos menús emergentes permiten realizar consultas en la herramienta, como buscar una clase por nombre, encontrar todos los remitentes de un mensaje seleccionado o todos los implementadores del mensaje, entre otras funciones. De esta manera, el navegador funciona tanto como herramienta de lectura de código y exploración del sistema como de creación de código.

Espacio de trabajo

Un espacio de trabajo es un editor de texto sencillo que permite editar una sola cadena. Se puede escribir texto arbitrario en el espacio de trabajo, incluidas expresiones de Smalltalk. En el menú emergente, las acciones más comunes son: "Ejecutar" (evaluar la expresión seleccionada), "Imprimir" (evaluar la expresión seleccionada e insertar la cadena de impresión del resultado inmediatamente después de la selección) e "Inspeccionar" (abrir un inspector sobre el resultado de la evaluación de la expresión seleccionada; véase "Inspector" más abajo). Cabe destacar que el quinto panel del navegador también es un espacio de trabajo, lo que permite evaluar expresiones e insertar sus resultados al editar definiciones de métodos. Es habitual incluir expresiones evaluables, normalmente ejemplos, en los comentarios de un método, ya que prácticamente en cualquier lugar donde se muestre el texto de un método (por ejemplo, en el depurador), el código es ejecutable como en un espacio de trabajo. Tanto los espacios de trabajo como los paneles de texto del navegador suelen tener resaltado de sintaxis. Mediante el uso de bloques para separar diferentes expresiones, se pueden tener varias expresiones con resaltado de sintaxis, cada una con sus propios temporales, en un mismo espacio de trabajo.

Inspector

Existen varios inspectores, algunos diseñados para mostrar distintos tipos de objetos. El inspector más básico tiene dos paneles. A la izquierda se muestra una lista del objeto en sí (con la etiqueta "self"), seguida de las variables de instancia del objeto, que incluyen variables de instancia numeradas en secuencias como cadenas y matrices. A la derecha se encuentra un panel de trabajo. Al seleccionar un nombre en la lista, el contenido del espacio de trabajo se reemplaza con una cadena de texto que muestra la variable seleccionada. Al editar y "aceptar" el texto en el panel de trabajo cuando se selecciona una variable de instancia, se asigna el resultado de la evaluación a dicha variable. Se puede profundizar en la información utilizando el comando "inspeccionar" en el menú de la lista, que se aplicará a la variable de instancia seleccionada. Los inspectores más sofisticados (por ejemplo, los exploradores) admiten un acceso en árbol similar al del Finder, lo que permite recorrer la estructura del objeto sin abrir ventanas adicionales.

Notificador/Depurador

La respuesta predeterminada a una excepción no controlada es abrir un Notificador, que es una ventana que contiene un rastreo de pila de las primeras activaciones y botones como "Depurar", "Continuar", "Cerrar", etc. Si el programador elige "Depurar", se abre el depurador completo. Este tiene seis paneles. En la parte superior está la ventana de pila, que contiene una lista de los contextos en la pila. Al seleccionar un contexto, el panel central muestra el texto del método del contexto y resalta la expresión actual dentro del método. Al seleccionar el contexto superior, se mostrará el método que genera la excepción y se resaltará el mensaje que la genera. Al seleccionar un contexto, se actualizan los cuatro paneles inferiores. Los dos paneles inferiores izquierdos son el inspector del receptor, que inspecciona el receptor del mensaje seleccionado. Los dos paneles inferiores derechos son el inspector de contexto, que muestra los nombres de los argumentos y las variables temporales en el contexto seleccionado y permite visualizar y modificar estas variables.

El envío del mensaje self haltprovoca una excepción que abre un notificador, proporcionando una sencilla función de punto de interrupción (normalmente, las funciones de punto de interrupción ofrecen más que una simple detención, pero esta fue la primera de este tipo). Los espacios de trabajo también proporcionan un evaluador "debug it" que abre un depurador en la expresión seleccionada, situado en el primer mensaje enviado dentro de la expresión. Así, al seleccionar 52 factorialy elegir "debug it" en el menú emergente, se abre un depurador con el "contexto doit" seleccionado y el factorialselector resaltado. El depurador proporciona botones para "entrar", "saltar", etc. Por lo tanto, al elegir "entrar" se puede explorar la evaluación de 52 factorial. De esta forma, el depurador proporciona un inspector de un proceso, lo que permite explorar un cálculo detenido.

Si se produce una excepción al enviar `doesNotUnderstand:` o `subclassResponsibility`, el notificador incluirá un botón "Crear", que permite al programador elegir dónde definir un "borrador inicial" del método en la jerarquía del receptor. Redefinir un método en el depurador hace que el contexto seleccionado se restablezca a la primera instrucción (los argumentos no son modificables en Smalltalk, por lo que esto devuelve el estado de ejecución al inicio del método). De esta forma, el depurador admite la programación en vivo, definiendo métodos a medida que avanza el cálculo. Esta es una forma extremadamente productiva y agradable de programar. Todo en el sistema está al alcance de la mano. Se dispone de todo el poder de los espacios de trabajo para evaluar subexpresiones y del explorador para buscar código de apoyo mientras se programa.

Al hacer clic en el botón Depurar, el Notificador se convierte en un depurador que permite inspeccionar la pila de llamadas, editarla y continuar desde cualquier activación de método. En este caso, el Notificador ha creado una plantilla del método faltante que el programador puede editar, compilar y, a continuación, continuar con el cálculo.

El programa "Hola mundo" se utiliza prácticamente en todos los libros de texto para aprender nuevos lenguajes de programación, ya que es el primer programa que se aprende para mostrar la sintaxis y el entorno más básicos del lenguaje. Para Smalltalk, el programa es extremadamente sencillo de escribir. El siguiente código envía el mensaje "show:" al objeto "Transcript" con la cadena literal "Hello, world!" como argumento. La invocación del método "show:" hace que los caracteres de su argumento (la cadena literal "Hello, world!") se muestren en la ventana de la transcripción ("terminal").

Transcripción del programa: '¡Hola, mundo!' .

Para ver los resultados de este ejemplo, debe tener abierta una ventana de Transcripción.

La mayoría de los sistemas de programación populares separan el código estático del programa (en forma de definiciones de clases , funciones o procedimientos) del estado dinámico o en tiempo de ejecución del programa (como objetos u otros tipos de datos del programa). Cargan el código del programa cuando este se inicia, 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 de nuevo en cada reinicio. Un programa tradicional también pierde mucha información útil del documento cada vez que guarda un archivo, se cierra y se vuelve a cargar. Esto implica la pérdida de detalles como el historial de deshacer o la posición del cursor. Los sistemas basados ​​en imágenes no obligan a perder toda esa información solo porque se apague el ordenador o se actualice el sistema operativo.

Sin embargo, muchos sistemas Smalltalk no distinguen entre datos de programa (objetos) y código (clases). De hecho, las clases son objetos. Por lo tanto, la mayoría de los sistemas Smalltalk almacenan el estado completo del programa (incluidos tanto objetos de clase como objetos que no lo son) en un archivo de imagen . La máquina virtual Smalltalk puede cargar la imagen para restaurar un sistema similar a Smalltalk a un estado anterior. ^{[ 40 ]} Esto se inspiró en FLEX, un lenguaje creado por Alan Kay y descrito en su tesis de maestría. ^{[ 41 ]}

Las imágenes de Smalltalk son similares a los volcados de memoria (reiniciables) y pueden proporcionar la misma funcionalidad que los volcados de memoria, como la depuración diferida o remota con acceso completo al estado del programa en el momento del error. ^{[ 42 ]}

Otros lenguajes que modelan el código de la aplicación como una forma de datos, como Lisp , también suelen utilizar persistencia basada en imágenes (véase EMACS , por ejemplo). Este método de persistencia es muy útil para el desarrollo rápido, ya que se guarda toda la información de desarrollo (por ejemplo, los árboles de análisis sintáctico del programa), lo que facilita la depuración.

Sin embargo, también presenta serios inconvenientes como mecanismo de persistencia propiamente dicho. Por un lado, los desarrolladores suelen querer ocultar los detalles de implementación y no exponerlos en el entorno de ejecución. Por motivos legales y de mantenimiento, permitir que cualquiera modifique un programa en tiempo de ejecución introduce inevitablemente complejidad y posibles errores que no serían posibles con un sistema compilado que no expone el código fuente en el entorno de ejecución. Además, si bien el mecanismo de persistencia es fácil de usar, carece de las capacidades de persistencia necesarias para la mayoría de los sistemas multiusuario. La más evidente es la capacidad de realizar transacciones con múltiples usuarios accediendo a la misma base de datos en paralelo.

En Smalltalk-80, a menos que se personalice para evitarlo, todo se puede modificar desde un programa en ejecución. Esto significa que, por ejemplo, el IDE se puede cambiar en un sistema en funcionamiento sin reiniciarlo. En algunas implementaciones, la sintaxis del lenguaje o la implementación del recolector de basura también se pueden cambiar sobre la marcha. Incluso la instrucción true become: falsees válida en Smalltalk, aunque no se recomienda ejecutarla excepto con fines demostrativos (véase máquina virtual , persistencia basada en imágenes y copias de seguridad ).

Los programas Smalltalk suelen compilarse a bytecode , que luego es interpretado por una máquina virtual o traducido dinámicamente a código máquina nativo. Los resultados de búsquedas de mensajes anteriores se almacenan en caché en código máquina automodificable, lo que da como resultado envíos de muy alto rendimiento que pueden superar a las llamadas a funciones indirectas en las llamadas a métodos virtuales de C++.

• Dardo
• Objetivo-C
• Neolengua
• Rubí
• Ser
• Strongtalk
• GLASS (paquete de software)
• Arquitectura de gestión de datos distribuidos

• Goldberg, Adele (diciembre de 1983). Smalltalk-80: El entorno de programación interactiva . Addison-Wesley. ISBN 0-201-11372-4.
• Goldberg, Adele ; Kay, Alan , eds. (marzo de 1976). Manual de instrucciones de Smalltalk-72 (PDF) . Palo Alto, California: Centro de Investigación Xerox Palo Alto . Recuperado el 11 de noviembre de 2011 .
• Goldberg, Adele ; Robson, David (mayo de 1983). Smalltalk-80: El lenguaje y su implementación . Addison-Wesley. ISBN 0-201-11371-6.
• Goldberg, Adele ; Robson, David (11 de enero de 1989). Smalltalk 80: El lenguaje . Addison-Wesley. ISBN 0-201-13688-0.
• Kay, Alan C. (marzo de 1993). "La historia temprana del Smalltalk" (PDF) . ACM SIGPLAN Notices . 28 (3). ACM : 69–95 . doi : 10.1145/155360.155364 . Archivado del original (PDF) el 3 de mayo de 2023.
• Krasner, Glen, ed. (agosto de 1983). Smalltalk-80: Bits of History, Words of Advice . Addison-Wesley. ISBN 0-201-11669-3.
• Nierstrasz, Oscar; Ducasse, Stéphane; Pollet, Damien; Black, Andrew P. (7 de octubre de 2009). Squeak by Example . Kehrsatz, Suiza: Square Bracket Associates. ISBN 978-3-9523341-0-2.
• Nierstrasz, Oscar; Ducasse, Stéphane; Pollet, Damien; Black, Andrew P. (23 de febrero de 2010). Pharo by Example . Kehrsatz, Suiza: Square Bracket Publishing. ISBN 978-3-9523341-4-0Archivado del original el 21 de octubre de 2009.
• Winston, Patrick Henry (3 de septiembre de 1997). On to Smalltalk . MIT, EE. UU.: Addison Wesley. ISBN 978-0-201-49827-1.
• Brauer, Johannes (2015). Programación en Smalltalk: Orientación a objetos desde el principio . Springer. ISBN 978-3-658-06823-3.
• "Número especial sobre Smalltalk" . Byte . 6 (8). McGraw-Hill. Agosto de 1981. Recuperado el 18 de octubre de 2013 .
  • Goldberg, Adele (agosto de 1981). "Introducción al sistema Smalltalk-80" . Byte . 6 (8). McGraw-Hill . Recuperado el 18 de octubre de 2013 .
  • Ingalls, Dan (agosto de 1981). "Principios de diseño detrás de Smalltalk" . Byte . 6 (8). McGraw-Hill . Recuperado el 11 de noviembre de 2011 .
  • Tesler, Larry (agosto de 1981). "El entorno Smalltalk" . Byte . 6 (8). McGraw-Hill . Recuperado el 2 de mayo de 2016 .

• Una descripción semántica de Smalltalk de 1973 escrita en sí misma
• Libros gratuitos en línea sobre conversaciones informales