Smalltalk es un lenguaje de programación puramente orientado a objetos (POO) que se creó originalmente en la década de 1970 para uso educativo , específicamente para el aprendizaje construccionista , pero que luego encontró uso en los negocios. Fue creado en Xerox PARC por científicos del Learning Research Group (LRG), incluidos Alan Kay , Dan Ingalls , Adele Goldberg , Ted Kaehler , Diana Merry y Scott Wallace.
En Smalltalk, los programas en ejecución se construyen a partir de los llamados objetos opacos y atómicos, que son instancias de código de plantilla almacenado en clases. Estos objetos se intercomunican 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 son susceptibles de redefinición en vivo, y a veces se definen independientemente del entorno de programación de Smalltalk.
Habiendo experimentado un importante desarrollo industrial hacia otros usos, incluidas funciones comerciales y de bases de datos , Smalltalk todavía se utiliza en la actualidad. Cuando se lanzó públicamente por primera vez, Smalltalk-80 presentó ideas innovadoras y fundamentales para el naciente campo de la programación orientada a objetos (OOP).
Desde sus inicios, el lenguaje proporcionó programación interactiva a través de un entorno de desarrollo integrado . Esto requiere reflexión y vinculación tardía en el lenguaje de ejecución del código . El desarrollo posterior ha llevado a al menos una instancia del entorno de ejecución 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. Smalltalk del American National Standards Institute (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 para desarrolladores de Stack Overflow en 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 no calificada Smalltalk se usa a menudo para indicar el lenguaje Smalltalk-80 y la VM compatible, la primera versión que estuvo disponible públicamente y se creó en 1980. Los primeros entornos de hardware que ejecutaron las VM Smalltalk fueron computadoras Xerox Alto .
Smalltalk fue 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 pocas mañanas con la apuesta de que un lenguaje de programación basado en la idea de transmisión de mensajes inspirado en Simula podría implementarse en "una página de código". [4] 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 importantes que congelaron algunos aspectos de la semántica de ejecución para ganar rendimiento (al adoptar un modelo de ejecución de herencia de clases 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 paradigma de "todo es un objeto" (excepto las variables) al asociar 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 disponible fuera de PARC. En 1981 se compartió con Tektronix , Hewlett-Packard , Apple Computer y DEC para revisión y depuración en sus plataformas. [9] [10] La edición de agosto de 1981 de Byte Magazine se dedicó a Smalltalk-80 y llevó sus ideas a una gran audiencia. También se publicaron varios libros sobre Smalltalk-80. Smalltalk-80 se convirtió en la base de todas las futuras versiones comerciales de Smalltalk. [11] El lanzamiento final de Smalltalk-80 Versión 1 fue en noviembre de 1981. [12] 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. [13] Más tarde, en 1983, Xerox lanzó Smalltalk-80 Versión 2. Esta versión estaba generalmente disponible para el público, aunque bajo una licencia restrictiva. Las versiones 1 y 2 eran bastante similares, aunque la versión 2 tenía algunas características adicionales, como un corrector ortográfico. Cada versión constaba de una imagen virtual (archivo independiente de la plataforma con definiciones de objetos) y una especificación de máquina virtual . [13]
ANSI Smalltalk ha sido la referencia del lenguaje estándar desde 1998. [14] Dos variantes de implementación de Smalltalk actualmente populares son descendientes de aquellas 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. [15] ( Dan Ingalls luego transfirió Hobbes a Squeak).
Desde finales de los 80 hasta mediados de los 90, dos organizaciones competidoras vendieron los entornos Smalltalk, incluido el soporte, la capacitación y los complementos: ParcPlace Systems y Digitalk, ambas con sede en California. 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 OS/2 de IBM. Ambas empresas lucharon por llevar Smalltalk a la corriente principal debido a las importantes necesidades de memoria de Smalltalk, su 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 grandes y medianas, los productos Digitalk inicialmente intentaron llegar a una audiencia más amplia con un precio más bajo. IBM inicialmente admitió el producto Digitalk, pero luego ingresó al mercado con un producto Smalltalk en 1995 llamado VisualAge/Smalltalk. Easel introdujo Enfin en ese momento en Windows y OS/2. Enfin se hizo mucho más popular en Europa, cuando IBM lo introdujo en los talleres de TI antes de desarrollar IBM Smalltalk (más tarde VisualAge). Posteriormente, Enfin fue adquirida por Cincom Systems y ahora se vende con 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 cambiaron su nombre en 1997 a ObjectShare, con sede en Irvine, CA. ObjectShare ( NASDAQ : OBJS) cotizó en bolsa hasta 1999, cuando se eliminó de la lista y se disolvió. La empresa fusionada nunca logró encontrar una respuesta efectiva a Java en cuanto a 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 (incluido el equipo de desarrollo original de Smalltalk/V y Visual Smalltalk) y todavía es propietario de VisualSmalltalk, aunque los derechos de distribución mundial del producto Smalltalk permanecieron en manos de ObjectShare, quien luego los vendió a Cincom . [16] VisualWorks se vendió a Cincom y ahora es 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 continúan vendiendo entornos Smalltalk. IBM tiene VisualAge Smalltalk al final de su vida útil y, a finales de la década de 1990, decidió respaldar Java y, a partir de 2005 [actualizar], cuenta con el respaldo de Instantiations, Inc. [17] , quien cambió el nombre del producto VA Smalltalk (Plataforma VAST) y continúa lanzar nuevas versiones anualmente. La implementación abierta de Squeak tiene una comunidad activa de desarrolladores, incluidos muchos miembros de la comunidad Smalltalk original, 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 Open Aplicación del mundo virtual Cobalt . GNU Smalltalk es una implementación de software libre de un derivado de Smalltalk-80 del proyecto GNU . Pharo Smalltalk es un fork de Squeak orientado a la investigación y uso en entornos comerciales.
A partir de 2016, un desarrollo significativo que se ha extendido a todos los entornos de Smalltalk 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 Instantiations incorporándolo y ampliándolo.
Smalltalk fue uno de los muchos lenguajes de programación orientados a objetos basados en Simula . [18] 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 , [19] CLOS , Objective-C , Java , Python , Ruby , [20] 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 . [21] 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 amplio de investigación financiada por la Agencia de Proyectos de Investigación Avanzada (ARPA) que de muchas maneras definió el mundo moderno de la informática. Además de Smalltalk, en la década de 1960 los investigadores de ARPA desarrollaron prototipos funcionales de cosas como hipertexto , GUI, multimedia , ratón, telepresencia e Internet. [22] [23] Alan Kay (uno de los inventores de Smalltalk) también describió una tableta a la que llamó Dynabook y que se parece a las tabletas modernas como el iPad. [4]
Los entornos 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 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 hay varias vistas (por ejemplo, relación entre entidades, flujo de datos, modelo de objetos, etc.) de la misma especificación subyacente. Además, para simulaciones o juegos donde el modelo subyacente puede verse desde varios ángulos y niveles de abstracción. [24]
Además del patrón MVC, el lenguaje y el entorno de 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 UI. . Las poderosas herramientas integradas de depuración e inspección de objetos que vienen con los entornos Smalltalk establecen el estándar para todos los entornos de desarrollo integrados , comenzando con los entornos Lisp Machine , que vinieron después. [25]
Como 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 "modelos" 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 Smalltalk puede hacer exactamente tres cosas:
El estado que mantiene un objeto siempre es privado de ese objeto. Otros objetos pueden consultar o cambiar ese estado sólo enviando solicitudes (mensajes) al objeto para hacerlo. Cualquier mensaje puede enviarse 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 prestada a los objetos, la mensajería es el concepto más importante en Smalltalk: "La gran idea es 'mensajería'; de eso se trata el núcleo de Smalltalk/Squeak (y es algo que nunca se desarrolló del todo). completado en nuestra fase Xerox PARC). " [26]
A diferencia de la mayoría de los otros lenguajes, los objetos de Smalltalk se pueden modificar mientras el sistema está en ejecución. 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 lenguaje de programación "puro" 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 clases correspondientes, y las operaciones sobre ellos se invocan mediante el envío de mensajes. Un programador puede cambiar o ampliar (mediante 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 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.
Como 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 denominada Metaclase. Los bloques de código (la forma en que Smalltalk expresa funciones anónimas ) también son objetos. [27]
La 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 accesibles y modificables 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 utilizar 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 ( ej., todas las instancias de la clase Método en el metamodelo).
Smalltalk-80 es un sistema totalmente reflectante. Smalltalk-80 proporciona reflexión tanto estructural como computacional. Smalltalk es un sistema estructuralmente reflectante cuya estructura está definida por objetos Smalltalk-80. Las clases y métodos que definen el sistema también son objetos y forman parte integral del sistema que ayudan a definir. El compilador Smalltalk compila 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 manera, un sistema Smalltalk-80 es un sistema "vivo", que tiene la capacidad de extenderse en tiempo de ejecución.
Dado que las clases son objetos, se les pueden hacer preguntas como "¿qué métodos implementas?" o "¿qué campos/espacios/variables de instancia define?". Por lo tanto, los objetos se pueden inspeccionar, copiar, (des) serializar , etc. fácilmente con un código genérico que se aplica a cualquier objeto del sistema. [28]
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, 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 thisContextun método de activación podemos hacer preguntas como "quién me envió este mensaje". Estas funciones permiten implementar corrutinas o seguimiento hacia atrás tipo 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 Seaside , que libera al programador de tener que 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 un sitio web. La programación del servidor web utilizando Seaside se puede realizar utilizando un estilo de programación más convencional. [29]
Un ejemplo de cómo Smalltalk puede utilizar 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 doesNotUnderstand:mensaje con una cosificación del mensaje como argumento. El mensaje (otro objeto, una instancia de Message) contiene el selector del mensaje y uno Arrayde sus argumentos. En un sistema interactivo Smalltalk, la implementación predeterminada doesNotUnderstand:es aquella que abre una ventana de error (un Notificador) que informa el error al usuario. A través de esto y de las funciones reflectantes, 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 reflectantes de Smalltalk-80. [30] [31]
Al crear una clase que entienda (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:. Estos casos se denominan proxies transparentes. [32] Estos proxies se pueden utilizar para implementar una serie de funciones, como Smalltalk distribuido, donde se intercambian mensajes entre múltiples sistemas 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ó sistemas como CORBA .
La sintaxis de Smalltalk-80 es bastante minimalista y se basa sólo en un puñado de declaraciones y palabras reservadas. De hecho, en Smalltalk sólo se reservan seis "palabras clave": true, false, nil, self, supery thisContext. Estas se denominan apropiadamente pseudovariables , identificadores que siguen las reglas para los identificadores de variables pero denotan enlaces que un programador no puede cambiar. Las pseudovariables , y son trueinstancias únicas . 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 en la clase del receptor, lo que permite que los métodos de las subclases invoquen métodos del mismo nombre en superclases. se refiere al registro de activación actual. Las únicas construcciones del lenguaje integradas son el envío de mensajes, la asignación, el retorno de métodos y la sintaxis literal para algunos objetos. Desde sus orígenes como 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 a los lenguajes de codificación convencionales. El resto del lenguaje, incluidas las estructuras de control para la evaluación e iteración condicional, se implementa sobre las construcciones integradas mediante la biblioteca de clases estándar Smalltalk. (Por motivos de rendimiento, las implementaciones pueden reconocer y tratar como especiales algunos de esos mensajes; sin embargo, esto es sólo una optimización y no está codificado en la sintaxis del lenguaje).falsenilselfsupersuperthisContext
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 lo relata en prácticamente cada una de las decenas o cientos de conferencias públicas, op. cit., o quizás 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: [33] [34]
ejemploConNúmero: x | y | verdadero y falso no & ( nil esNil ) ifFalse : [ autodetención ] . y := talla propia + talla super . #( $a #a 'a' 1 1.0 ) hacer: [ : cada uno | Mostrar transcripción : ( nombre de cada clase ) ; espectáculo: ' ' ] . ^ x < y 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 - 42 123 . 45 1 . 2345e2 2r10010010 16 rA000Las 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 por qué ser una potencia de dos; por ejemplo 36rSMALLTALK es un número válido igual a 80738163270632 decimal.
Los caracteres se escriben precediéndolos con un signo de dólar:
$ALas 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!".No es necesario utilizar escape para las comillas dobles, ya que las comillas simples delimitan una cadena:
'Dije: "¡Hola, mundo!" a ellos."Dos cadenas iguales (las cadenas son iguales si contienen los mismos caracteres) pueden ser objetos diferentes que residen en lugares diferentes de la memoria. Además de las cadenas, Smalltalk tiene una clase de objetos de secuencia de caracteres denominada Símbolo. Se garantiza que los símbolos serán únicos: no puede haber dos símbolos iguales que sean objetos diferentes. Debido a esto, los símbolos son muy baratos de comparar y a menudo se usan para artefactos del 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 ni caracteres de puntuación, también se puede escribir como:
#fooMatrices:
#( 1 2 3 4 )define una matriz de cuatro números 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, bloques ( literales de funciones anónimas )
[... Algún código de charla trivial . ..]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 que todos admiten.
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:
| índice |declara una variable temporal llamada índice que contiene inicialmente el valor nil.
Se pueden declarar múltiples variables dentro de un conjunto de barras:
| vocales índice |declara dos variables: índice y vocales. Todas las variables se inicializan. Las variables se inicializan a cero, excepto las variables indexadas de Cadenas, que se inicializan al carácter nulo o ByteArrays que se inicializan a 0.
A una variable se le asigna un valor mediante la :=sintaxis ''. Entonces:
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), creado 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 orientada hacia la izquierda ⟨←⟩ (como en la versión de 1963 del código ASCII ). Smalltalk originalmente aceptó esta flecha 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 la sintaxis de guión bajo o dos puntos iguales.
El mensaje es la construcción del lenguaje más fundamental en Smalltalk. Incluso se implementan estructuras de control a medida que se envían mensajes . Smalltalk adopta de forma predeterminada una estrategia de envío dinámico y de envío único (a diferencia del envío múltiple , utilizado por algunos otros lenguajes orientados a objetos).
El siguiente ejemplo envía el mensaje 'factorial' al número 42:
42 factoresEn esta situación, 42 se denomina receptor de mensajes , mientras que 'factorial' es el selector de mensajes . 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:
aRatherBigNumber := 42 factorialEl "factorial" anterior es lo que se llama mensaje unario porque sólo está involucrado un objeto, el receptor. Los mensajes pueden llevar objetos adicionales como argumentos , de la siguiente manera:
2 elevado a: 4En esta expresión intervienen dos objetos: 2 como receptor y 4 como argumento del mensaje. El resultado del mensaje, o en el lenguaje de Smalltalk, se supone que la respuesta es 16. Estos mensajes se denominan mensajes de palabras clave . Un mensaje puede tener más argumentos, utilizando la siguiente sintaxis:
'hola mundo' indexOf: $o comenzando en: 6que responde al índice del carácter 'o' en la cadena del receptor, iniciando la búsqueda desde el índice 6. El selector de este mensaje es "indexOf:startingAt:", que consta de dos piezas, o palabras clave .
Este entrelazado de palabras clave y argumentos tiene como objetivo mejorar la legibilidad del código, ya que los argumentos se explican por las palabras clave anteriores. Por ejemplo, una expresión para crear un rectángulo usando 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:
Ancho del rectángulo : 100 alto: 200El receptor en este caso es "Rectangle", una clase, y la respuesta será una nueva instancia de la clase con el ancho y alto especificados.
Finalmente, la mayoría de los caracteres especiales (no alfabéticos) se pueden utilizar como lo que se denomina mensajes binarios . Estos permiten escribir operadores matemáticos y lógicos en su forma tradicional:
3 + 4que envía el mensaje "+" al receptor 3 con 4 pasado como argumento (cuya respuesta será 7). Similarmente,
3 > 4es el mensaje ">" enviado a 3 con el argumento 4 (cuya respuesta será falsa).
Tenga en cuenta que el lenguaje Smalltalk-80 en sí 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 del operador . Un mensaje ">" también puede ser entendido por otros objetos, permitiendo el uso de expresiones de la forma "a > b" para compararlos.
Una expresión puede incluir varios envíos de mensajes. En este caso, las expresiones se analizan según un simple orden de precedencia. Los mensajes unarios tienen la prioridad más alta, seguidos de los mensajes binarios y de los mensajes de palabras clave. Por ejemplo:
3 factorial + 4 factorial entre: 10 y: 100se evalúa de la siguiente manera:
La respuesta del último mensaje enviado es el resultado de la expresión completa.
Los paréntesis pueden alterar el orden de evaluación cuando sea necesario. Por ejemplo,
( 3 factorial + 4 ) factorial entre: 10 y: 100cambiará el significado para que la expresión primero calcule "3 factorial + 4" dando como resultado 10. Ese 10 luego recibe el segundo mensaje "factorial", dando como resultado 3628800. 3628800 luego recibe "entre: y:", respondiendo falso.
Debido a que el significado de los mensajes binarios no está codificado en la sintaxis de Smalltalk-80, se considera que todos tienen la misma prioridad y se evalúan simplemente de izquierda a derecha. Debido a esto, el significado de las expresiones de Smalltalk que utilizan mensajes binarios puede ser diferente de su interpretación "tradicional":
3 + 4 * 5se evalúa como "(3 + 4) * 5", lo que produce 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 registro factorial factorial que envía "factorial" a 3, luego "factorial" al resultado (6), luego "registro" 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.
| ventana | ventana := Ventana nueva . etiqueta de ventana : 'Hola' . ventana abiertaSi 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:
Nueva etiqueta de ventana : 'Hola' ; abiertoEsta reescritura del ejemplo anterior como una expresión única evita la necesidad de almacenar la nueva ventana en una variable temporal. De acuerdo con las reglas de precedencia habituales, primero se envía el mensaje unario "nuevo" y luego "etiqueta:" y "abierto" al receptor de "nuevo".
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:
[ : parámetros | < 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 | x + 1 ]puede entenderse como:
o expresado en términos lambda como:
y
[ : x | x + 1 ] valor: 3puede ser evaluado como
O en términos lambda como:
El objeto de bloque resultante puede formar un cierre : puede acceder a las variables de sus ámbitos léxicos adjuntos en cualquier momento. Los bloques son objetos de primera clase .
Los bloques se pueden ejecutar enviándoles el mensaje de valor . Existen variaciones compuestas para proporcionar parámetros al bloque, por ejemplo, value:value:y valueWithArguments:.
La representación literal de bloques fue una innovación que, por un lado, permitió que determinados códigos fueran mucho más legibles; permitió codificar algoritmos que implicaban iteración de forma clara y concisa. El código que normalmente se escribiría con bucles en algunos lenguajes se puede escribir de manera concisa en Smalltalk usando bloques, a veces en una sola línea. Pero lo más importante es que los bloques permiten expresar la estructura de control mediante mensajes y polimorfismo , ya que los bloques difieren el cálculo y el polimorfismo se puede utilizar para seleccionar alternativas. Entonces, if-then-else en Smalltalk está escrito e implementado como
expr ifTrue: [ declaraciones para evaluar si expr ] ifFalse: [ declaraciones para evaluar si no expr ]Verdaderos métodos de evaluación.
ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock
^trueAlternativeBlock valor
Falsos métodos de evaluación.
ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock
^valor falseAlternativeBlock
montos positivos := todos los montos seleccione: [ : un monto | una cantidad es positiva ]Esto está relacionado con la programación funcional , en la que los patrones de cálculo (aquí 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 . [35]
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 a ejecutar si y sólo 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 ifTrue: [ 'mayor' ] ifFalse: [ '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:
| Vocales de cuerda | aString := 'Esto es una cadena' . vocales := unaCadena seleccione: [ : unCarácter | un carácter es vocal ] .En la última línea, a la cadena se le envía el mensaje select: con un argumento que es un bloque de código literal. El literal del bloque de código se usará como una función de predicado que debe responder verdadero si y solo si un elemento de la Cadena debe incluirse en la Colección de caracteres que satisfacen la prueba representada por el bloque de código que es el argumento del "select: " mensaje.
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. Cuando se evalúa (al recibir el mensaje "valor: cada uno"), el bloque de selección (referenciado por el parámetro "aBlock", y definido por el literal del bloque "[:aCharacter | aCharacter isVowel]"), responde un booleano, que es luego envió "ifTrue:". Si el booleano es verdadero, el carácter se agrega a una cadena que se devolverá. Debido a que el método "select:" está definido en la clase abstracta Colección, también se puede usar así:
| rectángulos aColisiones de puntos | rectángulos : = OrderedCollection con: ( Rectángulo izquierdo: 0 derecho: 10 arriba: 100 abajo: 200 ) con: ( Rectángulo izquierdo: 10 derecho: 10 arriba: 110 abajo: 210 ) . aPunto := Punto x: 20 y: 20 . colisiones := rectángulos seleccione: [ : aRect | aRect contienePunto: aPunto ] .El mecanismo de manejo de excepciones utiliza bloques como controladores (similar al manejo de excepciones estilo CLOS):
[ alguna operación
] en: Error hacer: [ : ex | controlador - código ex retorno]El argumento "ex" del controlador 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 "ex proceder"). ", "rechazo ex", "reinicio ex" o "retorno ex").
Esta es una definición de clase de acciones: [36]
Subclase de objeto : #MessagePublisher instanciaVariableNames: '' classVariableNames: '' poolDictionaries: '' categoría: 'Ejemplos de Smalltalk'A menudo, la mayor parte de esta definición la completará el medio ambiente. Observe que este es un mensaje para la Objectclase para que cree 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.
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 qué sucederá cuando este objeto reciba el mensaje de 'publicación'.
publicar Transcripción del programa: '¡Hola mundo!'El siguiente método demuestra cómo 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." | mul | múl := i1 * i2 . ^ mul * 4El nombre del método es #quadMultiply:and:. El valor de retorno se especifica con el ^operador.
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.
El siguiente código:
MensajeEditor nuevocrea (y devuelve) una nueva instancia de la clase MessagePublisher. Normalmente se asigna a una variable:
editor := MessagePublisher nuevoSin embargo, también es posible enviar un mensaje a un objeto anónimo temporal:
MessagePublisher nueva publicaciónEl programa Hola mundo se utiliza en prácticamente todos los textos de nuevos lenguajes de programación como el primer programa aprendido a 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, el mensaje "show:" se envía al objeto "Transcript" con el literal de cadena '¡Hola, mundo!' como su argumento. La invocación del método "show:" hace que los caracteres de su argumento (el literal de cadena '¡Hola, mundo!') se muestren en la ventana de transcripción ("terminal").
Programa de transcripción : '¡Hola, mundo!' .Para ver los resultados de este ejemplo, debe estar abierta una ventana de Transcripción.
Los sistemas de programación más populares separan el código de programa estático (en forma de definiciones de clases , funciones o procedimientos) del estado del programa dinámico o de tiempo de ejecución (como objetos u otras formas de datos de programa). Cargan código de 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 sobre documentos cada vez que guarda un archivo, sale 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 el 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 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 Smalltalk puede cargar la imagen para restaurar un sistema similar a Smalltalk a un estado anterior. [37] Esto se inspiró en FLEX, un lenguaje creado por Alan Kay y descrito en su M.Sc. tesis. [38]
Las imágenes de Smalltalk son similares a los volcados de núcleo (reiniciables) y pueden proporcionar la misma funcionalidad que los volcados de núcleo, como la depuración retrasada o remota con acceso completo al estado del programa en el momento del error. [39]
Otros lenguajes que modelan el código de la aplicación como una forma de datos, como Lisp , a menudo también usan persistencia basada en imágenes (consulte EMACS , por ejemplo). Este método de persistencia es poderoso para un desarrollo rápido porque toda la información de desarrollo (por ejemplo, árboles de análisis del programa) se guarda, lo que facilita la depuración.
Sin embargo, también tiene serios inconvenientes [ cita necesaria ] como verdadero mecanismo de persistencia. Por un lado, es posible que los desarrolladores a menudo [ cita necesaria ] quieran 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 cualquiera modifique un programa en tiempo de ejecución inevitablemente [ cita necesaria ] introduce complejidad y errores potenciales que no serían posibles con un sistema compilado que no expone ningún código fuente en el entorno de tiempo de ejecución. Además, si bien 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. [ cita necesaria ] La más obvia es la capacidad de realizar transacciones con múltiples usuarios accediendo a la misma base de datos en paralelo. [ cita necesaria ]
Todo en Smalltalk-80, a menos que esté personalizado para evitar esa posibilidad, está disponible para 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 la recolección de basura también se pueden cambiar sobre la marcha. Incluso la declaración true become: falsees 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 ).
Los programas Smalltalk generalmente se compilan en 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 .
OpenSmalltalk VM (OS VM) es una implementación notable [ cita necesaria ] de la máquina virtual Smalltalk en la que se basan o derivan muchas implementaciones modernas de Smalltalk. [40] [41] El propio OS VM se transpila desde un conjunto de archivos de código fuente de Smalltalk (usando un subconjunto de Smalltalk llamado Slang) al código fuente nativo del lenguaje C (usando un transpilador llamado VMMaker), [42] que a su vez es compilado contra una plataforma y arquitectura específicas del hardware, lo que prácticamente permite 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 OS VM son: [43]
Para satisfacer esta necesidad, ARPA estableció la IPTO en 1962 con el mandato de construir una red informática con capacidad de supervivencia para interconectar las computadoras principales del Departamento de Defensa en el Pentágono, Cheyenne Mountain y la sede de SAC.
