Smalltalk es un lenguaje de programación orientado a objetos (OOP) que se creó originalmente en la década de 1970 para uso educativo , específicamente para el aprendizaje constructivista , pero que luego encontró uso en el ámbito empresarial. Fue creado en Xerox PARC por científicos del Learning Research Group (LRG), entre los que se encontraban Alan Kay , Dan Ingalls , Adele Goldberg , Ted Kaehler , Diana Merry y Scott Wallace.
En Smalltalk, los programas en ejecución están compuestos por objetos opacos y atómicos, que son instancias de código de plantilla almacenado en clases. Estos objetos se comunican entre sí mediante el paso de mensajes a través de un entorno de máquina virtual (VM) intermediario. Una cantidad relativamente pequeña de objetos, llamados primitivos, no se pueden redefinir en tiempo real y, a veces, se definen independientemente del entorno de programación de Smalltalk.
Tras haber experimentado un importante desarrollo industrial hacia otros usos, incluidas funciones empresariales y de bases de datos , Smalltalk todavía se utiliza en la actualidad. Cuando se lanzó al público por primera vez, Smalltalk-80 presentó numerosas ideas fundamentales para el naciente campo de la programación orientada a objetos (POO).
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 la ejecución del código del lenguaje . El desarrollo posterior ha dado lugar a al menos una instancia del entorno de ejecución de Smalltalk que carece de una interfaz gráfica de usuario integrada o front-end.
Los lenguajes similares a Smalltalk se encuentran en desarrollo activo y han reunido comunidades 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 de 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 se puso a disposición del público y se creó en 1980. Los primeros entornos de hardware que ejecutaron las VM de Smalltalk fueron las computadoras Xerox Alto .
Smalltalk fue el producto de la investigación dirigida por Alan Kay en el Centro de Investigación de Palo Alto (PARC) de Xerox; 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 inspirada por Simula podría implementarse en "una página de código". [4] Una variante posterior utilizada para el trabajo de investigación se denomina ahora 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 importantes revisiones que congelaron algunos aspectos de la semántica de ejecución para ganar rendimiento (al adoptar un modelo de herencia de clases similar al de Simula ), se creó Smalltalk-76. Este sistema tenía un entorno de desarrollo que incluía la mayoría de las herramientas ahora conocidas, incluido un explorador/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 comportamientos con clases individuales e incluso 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. [9] [10] El número de agosto de 1981 de Byte Magazine estuvo dedicado 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ó la versión 2 de Smalltalk-80. Esta versión estaba disponible para el público en general, aunque bajo una licencia restrictiva. Las versiones 1 y 2 eran bastante similares, aunque la versión 2 tenía algunas funciones añadidas, como un corrector ortográfico. Cada versión constaba de una imagen virtual (un archivo independiente de la plataforma con definiciones de objetos) y una especificación de máquina virtual . [13]
ANSI Smalltalk ha sido el lenguaje de referencia estándar desde 1998. [14] Dos variantes de implementación de Smalltalk populares actualmente 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 un 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 más tarde portó Hobbes a Squeak).
Entre finales de los años 1980 y mediados de los años 1990, los entornos Smalltalk, incluidos el soporte, la formación y los complementos, fueron vendidos por dos organizaciones competidoras: 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 los PC basados en Intel que ejecutaban Microsoft Windows o el sistema operativo OS/2 de IBM. Ambas empresas tuvieron dificultades para generalizar Smalltalk debido a las importantes necesidades de memoria de Smalltalk, su limitado rendimiento en tiempo de ejecución 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 de tamaño mediano y grande, los productos Digitalk inicialmente intentaron llegar a un público más amplio con un precio más bajo. IBM inicialmente dio soporte al producto Digitalk, pero luego entró en el mercado con un producto Smalltalk en 1995 llamado VisualAge/Smalltalk. Easel presentó Enfin en ese momento en Windows y OS/2. Enfin se hizo mucho más popular en Europa, cuando IBM lo introdujo en las tiendas de TI antes de desarrollar IBM Smalltalk (más tarde VisualAge). Enfin fue adquirido más tarde por Cincom Systems y ahora se vende bajo el nombre de ObjectStudio y es 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, 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 posee VisualSmalltalk, aunque los derechos de distribución mundial para el producto Smalltalk permanecieron con ObjectShare, que 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 siguen vendiendo entornos Smalltalk. IBM puso fin a VisualAge Smalltalk, tras haber decidido a finales de los 90 respaldar Java en su lugar y, a partir de 2005 [actualizar], cuenta con el apoyo de Instantiations, Inc. [17] Instantiations renombró el producto VA Smalltalk (VAST Platform) y sigue lanzando nuevas versiones anualmente. La implementación abierta de Squeak tiene una comunidad activa de desarrolladores, incluidos muchos de la comunidad original de Smalltalk, y se utilizó para proporcionar el entorno Etoys en el proyecto One Laptop per Child (OLPC), un kit 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.
A partir de 2016, un avance 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 despertado un interés considerable en el mercado, y Cincom, Gemstone e Instantiations lo han incorporado y ampliado.
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. [ cita requerida ] 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 de desarrollo de software ágil , 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 el 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, en muchos sentidos, definió el mundo moderno de la informática. Además de Smalltalk, los investigadores de la ARPA desarrollaron prototipos funcionales de cosas como el hipertexto , las interfaces gráficas de usuario, la multimedia , el ratón, la telepresencia e Internet en la década de 1960. [22] [23] Alan Kay (uno de los inventores de Smalltalk) también describió una computadora tipo tableta a la que llamó Dynabook , que se parece a las computadoras tipo tableta modernas como el iPad. [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 la interfaz 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, entidad-relación, flujo de datos, modelo de objetos, etc.) de la misma especificación subyacente. También 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 Smalltalk influyeron 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 la interfaz 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 vinieron después. [25]
Al igual que 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 window 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 window 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 un objeto tiene siempre es privado para ese objeto. Otros objetos pueden consultar o cambiar ese estado sólo enviando solicitudes (mensajes) al objeto para que lo haga. Cualquier mensaje puede ser enviado a cualquier objeto: cuando se recibe un mensaje, el receptor determina si ese mensaje es apropiado. Si el objeto no entiende el mensaje, entonces la máquina virtual envía el mensaje doesNotUnderstand: con el mensaje original como argumento, y la implementación predeterminada de doesNotUnderstand: lanza una excepción que, si no se detecta, abre el depurador del sistema. Alan Kay ha comentado que a pesar de la atención que se da a los objetos, la mensajería es el concepto más importante en Smalltalk: "La gran idea es 'mensajería', eso es lo que constituye el núcleo de Smalltalk/Squeak (y es algo que nunca se completó del todo en nuestra fase Xerox PARC)". [26]
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 dominante para Smalltalk y es 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 hay tipos primitivos. Todos los valores se representan como objetos y el cálculo de números enteros utiliza el envío de mensajes como cualquier otro objeto. En Smalltalk, los tipos como los números enteros, los booleanos y los caracteres también son objetos, en el sentido de que son instancias de clases correspondientes y las operaciones sobre ellos se invocan enviando mensajes. Para mayor eficiencia y generalidad, los números enteros se implementan mediante cuatro clases: Integer, la superclase abstracta de todos los números 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, LargePositiveInteger y LargeNegativeInteger, siendo las dos últimas vectores de bytes. En consecuencia, Smalltalk puede evaluar 52 factorial para producir 80658175170943878571660636856403766975289505440883277824000000000000. 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 subclasificación ) 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.
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 llamada Metaclase. Las clases contienen diccionarios de métodos que asignan selectores (el equivalente de los nombres de los 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 modo 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 encuentra el método o se envía doesNotUnderstand. Las máquinas virtuales de Smalltalk utilizan varias técnicas para acelerar la búsqueda de mensajes, de modo que el sistema proporcione tanto un mecanismo de enlace de mensajes simple y consistente como una buena eficiencia. Los bloques de código (la forma de Smalltalk de expresar funciones anónimas ) también son objetos. [27] Tienen una sintaxis muy ligera y se utilizan en todo el sistema para implementar estructuras de control, especialmente para la jerarquía de Collection.
Reflexión es un término que se aplica a los programas de software que tienen la capacidad de inspeccionar y/o representar su propia estructura, por ejemplo, su árbol de análisis o los tipos de datos de los parámetros de entrada y salida. La reflexión es una característica de los lenguajes dinámicos e interactivos, como Smalltalk y Lisp. Los programas interactivos con reflexión (ya sea interpretada o compilada) mantienen el estado de todos los objetos en memoria, incluido el propio objeto de código, 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 Smalltalk. El metamodelo es la parte del sistema que implementa el sistema de programación en sí, y los desarrolladores pueden utilizar el metamodelo para hacer cosas como recorrer, examinar y modificar el código en el sistema en ejecución, o encontrar todas las instancias de un determinado tipo de estructura (por ejemplo, todas las instancias de la clase Method 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 métodos que definen el sistema también son objetos y forman parte del sistema que ayudan a definir. El compilador Smalltalk, que está escrito en Smalltalk y existe junto con todo 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 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", que lleva consigo la capacidad de ampliarse a sí mismo en tiempo de ejecución. Incluso se puede ampliar 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?". De este modo, los objetos se pueden inspeccionar, copiar, (des) serializar , etc., fácilmente con 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 lenguajes derivados del Smalltalk-80 original, la activación actual de un método es accesible como un objeto nombrado a través de una pseudovariable (una de las seis palabras reservadas), thisContextque corresponde a un marco de pila en las implementaciones de lenguajes convencionales, y se llama "contexto". El envío de un mensaje se realiza dentro de algún contexto, y para evaluar el mensaje se crea otro contexto, siendo el primero el remitente del anterior. De esta manera, la pila es una lista enlazada de objetos de contexto, y el depurador es esencialmente un inspector de esta "pila espagueti". Al enviar mensajes a thisContextun método, la activación puede hacer preguntas como "quién me envió este mensaje". Estas facilidades hacen posible implementar corrutinas o back-tracking tipo Prolog sin modificar la máquina virtual. El sistema de excepciones se implementa utilizando esta facilidad. Uno de los usos más interesantes de esto es en el marco web Seaside , que libera al programador de la tarea de lidiar con la complejidad del botón de retroceso 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] Al igual que con el envío de mensajes, las máquinas virtuales Smalltalk-80 optimizan el costoso uso de contextos internamente, proporcionando la ilusión y flexibilidad de una pila de espaguetis sin la mayoría de sus costos. Esencialmente, los objetos de contexto se crean de forma diferida según sea necesario, por ejemplo, cuando se envía un mensaje a la variable thisContext.
Un ejemplo de cómo Smalltalk puede utilizar la reflexión es el mecanismo para gestionar errores. Cuando se envía a un objeto un mensaje que no implementa, la máquina virtual envía al objeto el doesNotUnderstand:mensaje con una reificació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 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 de las facilidades reflexivas, el usuario puede examinar el contexto en el que se produjo el error, redefinir el código ofensivo y continuar, todo dentro del sistema, utilizando las facilidades reflexivas de Smalltalk-80. [30] [31]
Al crear una clase que comprende (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. [32] Estos proxies se pueden utilizar para implementar una serie de funciones, como Smalltalk distribuido, donde se intercambian mensajes entre varios sistemas Smalltalk, interfaces de base 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 como CORBA .
La sintaxis de Smalltalk-80 es bastante minimalista, basada en solo un puñado de declaraciones y palabras reservadas. De hecho, solo seis "palabras clave" están reservadas en Smalltalk: true, false, nil, self, supery thisContext. Estas se denominan adecuadamente pseudovariables , identificadores que siguen las reglas para identificadores de variables pero denotan enlaces que un programador no puede cambiar. Las pseudovariables , y son trueinstancias falsesingleton . 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. se refiere al registro de activación actual. Las únicas construcciones de lenguaje incorporadas son envíos de mensajes, asignación, retorno de método y sintaxis literal para algunos objetos. Desde sus orígenes como un 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 de 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á codificado en la sintaxis del lenguaje).nilselfsupersuperthisContext
El adagio de que "la sintaxis de Smalltalk cabe en una postal " puede tener su origen 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 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: [33] [34]
ejemploWithNumber: x | y | true & false not & ( nil isNil ) ifFalse: [ self halt ] . y := self size + super size . #( $a #a 'a' 1 1.0 ) do: [ : each | Transcripción mostrar: ( cada nombre de clase ) ; mostrar: ' ' ] . ^ x < y Los siguientes ejemplos ilustran los objetos más comunes que pueden escribirse 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 un número hexadecimal, respectivamente. El número que precede a la "r" es la 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 precedidos por un signo de dólar:
$UnLas cadenas son secuencias de caracteres entre comillas simples:
'¡Hola Mundo!'Para incluir una comilla en una cadena, escápela utilizando una segunda comilla:
"Les dije: '¡Hola, mundo!'"Las comillas dobles no necesitan escape, 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 lugares diferentes 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 de comparar y se utilizan a menudo para artefactos del lenguaje como selectores de mensajes (ver a continuación).
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 así:
#comidaMatrices:
#( 1 2 3 4 )define una matriz de cuatro números enteros.
#(( 1 2 3 4 ) [ 1 2 3 4 ] 'cuatro' 4.0 #cuatro)define una matriz de siete elementos cuyo primer elemento es una matriz literal, el segundo elemento una matriz de bytes, el tercer elemento la cadena 'cuatro', y así sucesivamente.
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 funciones anónimas ).
[... Algún código de smalltalk ... ]Lo siguiente toma dos argumentos y compara dos objetos cualesquiera que puedan entender "menor que", por ejemplo, números y cadenas.
[ : a : b | a < b ]Los bloques se explican en detalle más adelante en el texto.
Muchos dialectos de Smalltalk implementan sintaxis adicionales para otros objetos, pero las mencionadas anteriormente son las esenciales admitidas por todos.
Los dos tipos de variables que se utilizan habitualmente en Smalltalk son las variables de instancia y las variables temporales. Otras variables y la 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 a continuación). 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 varias variables dentro de un conjunto de barras:
| índice vocales |declara dos variables: índice y vocales. Se inicializan todas las variables. Las variables se inicializan con valor nulo, excepto las variables indexadas de cadenas, que se inicializan con el carácter nulo, o las matrices de bytes, que se inicializan con valor 0.
A una variable se le asigna un valor mediante la :=sintaxis ' '. Por lo tanto:
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 para 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 que apuntaba hacia la izquierda ⟨←⟩ (como en la versión de 1963 del código ASCII ). Smalltalk originalmente aceptaba esta flecha hacia la izquierda como el único operador de asignación. Algunos códigos modernos aún contienen lo que parecen ser guiones bajos que actúan como asignaciones, lo que nos recuerda este uso original. La mayoría de las implementaciones modernas de Smalltalk aceptan la sintaxis de subrayado o de dos puntos y signo de igual.
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 envío dinámico y de envío único (en contraposición al envío múltiple , utilizado por otros lenguajes orientados a objetos). Hay tres tipos de envíos de mensajes, los mensajes unarios que tienen una sola palabra clave, como classy size, los mensajes binarios que se utilizan, por ejemplo, para aritmética, como , , y los mensajes de palabra clave donde una palabra clave seguida de dos puntos precede a cada argumento en el mensaje, de modo que envía el mensaje a con argumentos y . Los mensajes unarios tienen mayor precedencia que los mensajes binarios, que tienen mayor precedencia que los mensajes de palabra clave, y la evaluación es estrictamente de izquierda a derecha. No hay precedencia aritmética. evalúa a 9, no a 7.a < ba ~= ba between: b and: c#between:and:abc1 + 2 * 3
El siguiente ejemplo envía el mensaje 'factorial' al número 42:
factorial 42En esta situación, 42 se denomina receptor del mensaje , mientras que 'factorial' es el selector del mensaje . 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 := factorial 42 El "factorial" anterior es lo que se denomina un mensaje unario porque solo interviene 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, la respuesta , se supone que 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 startingAt: 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 .
Esta intercalación de palabras clave y argumentos tiene como objetivo mejorar la legibilidad del código, ya que los argumentos se explican mediante las palabras clave que los preceden. Por ejemplo, una expresión para crear un rectángulo utilizando una sintaxis similar a la de C++ o Java podría escribirse de la siguiente manera:
nuevo Rectángulo ( 100 , 200 ); No está claro qué argumento es cuál. En cambio, en Smalltalk, este código se escribiría así:
Rectángulo ancho: 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.
Por último, 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). De manera similar,
3 > 4es el mensaje ">" enviado a 3 con el argumento 4 (cuya respuesta será falsa). El programador es libre de definir nuevos selectores binarios, así como de definir nuevos mensajes unarios y de palabras clave.
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 Number) responde a los mensajes "+" y ">".
Un efecto secundario de este mecanismo es la sobrecarga de operadores . Un mensaje ">" también puede ser comprendido por otros objetos, lo que permite el uso de expresiones de la forma "a > b" para compararlos.
Smalltalk es un lenguaje basado en expresiones . Cada declaración, incluidas las construcciones de control, tiene un valor, que es un objeto. 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 precedencia más alta, seguidos de los mensajes binarios y, a continuación, de los mensajes de palabras clave. Por ejemplo:
Factorial 3 + factorial 4 entre: 10 y: 100 Se evalúa de la siguiente manera:
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: 100cambiará el significado de modo que la expresión primero calcule "3 factorial + 4", lo que da como resultado 10. Ese 10 luego recibe el segundo mensaje "factorial", que da como resultado 3628800. 3628800 luego recibe "entre: y:", lo que responde falso.
Debido a que el significado de los mensajes binarios no está codificado 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 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 utilizar 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 logaritmo factorial 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 (el punto es un separador de instrucciones, no un terminador de instrucciones). Este ejemplo primero crea una nueva instancia de la clase Window, la almacena en una variable y luego le envía dos mensajes.
| ventana | ventana := Ventana nueva . etiqueta de ventana : 'Hola' . ventana abierta Si se envía una serie de mensajes al mismo receptor como en el ejemplo anterior, también se pueden escribir en cascada con mensajes individuales separados por punto y coma:
Ventana nueva etiqueta: 'Hola' ; abiertaEsta reescritura del ejemplo anterior como una única 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 "new" se envía primero y luego se envían "label:" y "open" al receptor de "new".
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 | < 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 evaluarse como
O en términos lambda como:
El objeto de bloque resultante puede formar un cierre : puede acceder a las variables de los ámbitos léxicos que lo encierran 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 ciertos códigos fueran significativamente más legibles; permitió que los algoritmos que implicaban iteración se codificaran de manera 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 que la estructura de control se exprese usando mensajes y polimorfismo , ya que los bloques postergan el cálculo y el polimorfismo se puede usar para seleccionar alternativas. Entonces, if-then-else en Smalltalk se escribe e implementa como
expr ifTrue: [ declaraciones para evaluar si expr ] ifFalse: [ declaraciones para evaluar si no expr ]Métodos verdaderos de evaluación
ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock
^trueAlternativeBlock valor
Métodos falsos de evaluación
ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock
^valor falseAlternativeBlock
cantidadesPositivas := todasLasCantidades seleccione: [ : unaCantidad | unaCantidad esPositiva ]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 a la función de orden superior filter en un functor 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 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 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 , comportamientos conectables y muchos otros patrones. Por ejemplo:
| aString vocales | aString := 'Esto es una cadena' . vocales := aString select: [ : aCharacter | aCharacter isVowel ] .En la última línea, se envía a la cadena el mensaje "select:" con un argumento que es un literal de bloque de código. El literal de bloque de código se utilizará 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 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. Cuando se evalúa (enviándole el mensaje "value: each"), el bloque de selección (al que hace referencia el parámetro "aBlock" y que está 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 para el objeto, el carácter se agrega a una cadena que se devolverá. Debido a que el método "select:" está definido en la clase abstracta Collection, también se puede utilizar de esta manera:
| rectángulos colisiones aPoint | rectángulos := OrderedCollection 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 contienePunto: aPunto ] .El mecanismo de manejo de excepciones utiliza bloques como controladores (similar al manejo de excepciones de estilo CLOS):
[ alguna operación
] en: Error hacer: [ : ex | manejador - 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 proceed", "ex reject", "ex restart" o "ex return").
Esta es una definición de clase de stock: [36]
Subclase de objeto : #MessagePublisher instanceVariableNames: '' classVariableNames: '' poolDictionaries: '' categoría: 'Ejemplos de Smalltalk'A menudo, la mayor parte de esta definición la completará el entorno. Observe que se trata de un mensaje a la Objectclase para crear una subclase denominada 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 el momento de la ejecución.
Cuando un objeto recibe un mensaje, se invoca un método que coincide con el nombre del mensaje. El código siguiente define un método de publicación y, por lo tanto, define lo que sucederá cuando este objeto reciba el mensaje de "publicación".
publicar Transcripción mostrar: '¡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 | mul := 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 determinarse (a veces, o incluso siempre) estáticamente en tiempo de compilación.
El siguiente código:
MensajePublisher 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 temporal y anónimo:
MessagePublisher nueva publicaciónSmalltalk es uno de los primeros sistemas que se basa en un entorno de desarrollo integrado . Hay una gran variedad de herramientas para respaldar 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 de escritorio moderno de Windows, iconos, menús y punteros ( WIMP ). Aunque los punteros ya se habían inventado, Smalltalk fue el primer sistema en implementar ventanas superpuestas y menús emergentes. Si bien existen varias herramientas de programación, describiremos las siguientes cinco herramientas principales. Las imágenes de las herramientas son de un sistema Squeak 2024
Los sistemas derivados de Smalltalk-80 organizan las clases dentro de "categorías de 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 desprende 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 de sistema, que cuando se selecciona uno muestra en la segunda ventana la lista de clases en esa categoría, que cuando se selecciona uno muestra la lista de categorías de mensajes en la clase seleccionada, que cuando se selecciona uno 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, la fuente para 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 de sistema pero no una clase, se muestra una plantilla para crear una clase en la categoría. Varios menús emergentes permiten realizar consultas a la herramienta, como buscar una clase por nombre, encontrar todos los remitentes de un mensaje seleccionado o todos los implementadores del mensaje, etc. De esta manera, el navegador es a la vez una herramienta de lectura de código y exploración del sistema y una herramienta de creación de código.
Un espacio de trabajo es un editor de texto simple que edita una sola cadena. Se puede escribir texto arbitrario en el espacio de trabajo, incluidas expresiones de Smalltalk. En el menú emergente, "hacerlo" (evaluar la expresión seleccionada), "imprimirlo" (evaluar la expresión seleccionada e insertar la cadena de impresión del resultado inmediatamente después de la selección) e "inspeccionarlo" (abrir un inspector en el resultado de la evaluación de la expresión seleccionada, consulte "Inspector" a continuación) son tres acciones que se utilizan con frecuencia. Tenga en cuenta que el quinto panel del navegador también es un espacio de trabajo, de modo que se pueden evaluar expresiones e insertar sus resultados mientras se editan definiciones de métodos, y una cosa común es incluir expresiones evaluables, normalmente ejemplos, en los comentarios de un método, porque casi en todas partes donde se muestra 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 estar resaltados por sintaxis. Al utilizar bloques para separar diferentes expresiones, se pueden tener varias expresiones resaltadas de sintaxis, cada una con sus propios valores temporales en un solo espacio de trabajo.
La transcripción es un espacio de trabajo especial asociado con la transcripción global. Por lo tanto, la evaluación hace que aparezca 80658175170943878571660636856403766975289505440883277824000000000000 seguido de una nueva línea en la ventana Transcripción. Por lo tanto, la transcripción sirve como un lugar para emitir mensajes de registro, aunque también puede funcionar como un espacio de trabajo.Transcript print: 52 factorial; cr; flush
Existen varios inspectores, algunos diseñados para mostrar distintos tipos de objetos. El inspector más básico tiene dos paneles. A la izquierda hay una lista del objeto en sí (con la etiqueta "self"), seguida de las variables de instancia del objeto, que incluirán variables de instancia numeradas en secuencias como cadenas y matrices. A la derecha hay un panel de espacio de trabajo. Al seleccionar un nombre en la lista, se reemplaza el contenido del espacio de trabajo con una cadena de impresión de la variable seleccionada. Al editar y "aceptar" el texto en el panel de espacio de trabajo cuando se selecciona una variable de instancia, se asignará el resultado de la evaluación a la variable seleccionada. Se puede "explorar" utilizando el comando "inspeccionar" en el menú de lista, que se aplicará a la variable de instancia seleccionada. Los inspectores más sofisticados admiten it en cascada, de modo que se puede recorrer la estructura del objeto sin abrir ventanas adicionales.
La respuesta predeterminada a una excepción no controlada es abrir un Notificador, que es una ventana que contiene un seguimiento de la 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 la 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 del contexto que muestra los nombres de los argumentos y las variables temporales en el contexto seleccionado y permite la visualización y modificación de estas variables.
El envío del mensaje self haltprovoca una excepción que abre un notificador, lo que proporciona una función de punto de interrupción simple (normalmente, las funciones de punto de interrupción proporcionan más que simplemente detener, pero fue la primera función de este tipo). Los espacios de trabajo también proporcionan un evaluador "depurarlo" que abre un depurador en la expresión seleccionada ubicada en el primer mensaje enviado dentro de la expresión. Por lo tanto, al seleccionar 52 factorialy elegir "depurarlo" en el menú emergente, se abre un depurador con el "contexto doit" seleccionado y el factorialselector resaltado. El depurador proporciona botones para "pasar a la siguiente línea", "pasar a la siguiente línea", etc. Por lo tanto, al elegir "pasar a la siguiente línea" se puede explorar la evaluación de 52 factorial. De esta manera, el depurador proporciona un inspector de un proceso, lo que permite explorar un cálculo detenido.
Si se produce una excepción a partir de un envío de doesNotUnderstand: o subclassResponsibility, el notificador incluirá un botón "Crear", que permite al programador elegir en qué parte de la jerarquía del receptor se definirá un "borrador inicial" del método que se va a implementar. La redefinición de un método en el depurador hace que el contexto seleccionado vuelva a la primera declaración (los argumentos no se pueden modificar en Smalltalk, por lo que esto hace que el estado de ejecución vuelva al inicio de un método). De esta manera, 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á a su alcance. Uno tiene todo el poder de los espacios de trabajo para evaluar subexpresiones y el navegador para buscar código de apoyo mientras se programa.
El programa Hola mundo se utiliza en prácticamente todos los textos de los nuevos lenguajes de programación como el primer programa aprendido 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, el mensaje "show:" se envía al objeto "Transcript" con el literal de cadena '¡Hola, mundo!' como 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").
Transcripción del programa: '¡Hola, mundo!' .Para ver los resultados de este ejemplo, debe estar abierta una ventana de Transcripción.
La mayoría de 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 de programa cuando se inicia un programa, y cualquier estado de programa anterior 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, 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 fuerzan la pérdida de todo eso solo porque se apaga una computadora o se actualiza un sistema operativo.
Sin embargo, muchos sistemas Smalltalk 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 lo son) en un archivo de imagen . La imagen puede ser cargada luego por la máquina virtual Smalltalk 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 tesis de maestría. [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 , también suelen utilizar la persistencia basada en imágenes (véase EMACS , por ejemplo). Este método de persistencia es potente para el desarrollo rápido porque se guarda toda la información de desarrollo (por ejemplo, los árboles de análisis del programa), lo que facilita la depuración.
Sin embargo, también tiene serios inconvenientes [ cita requerida ] como un verdadero mecanismo de persistencia. Por un lado, los desarrolladores pueden [ cita requerida ] querer ocultar detalles de implementación y no hacerlos disponibles 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 requerida ] introduce complejidad y errores potenciales que no serían posibles con un sistema compilado que no expone 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. [ cita requerida ] La más obvia es la capacidad de realizar transacciones con múltiples usuarios que acceden a la misma base de datos en paralelo. [ cita requerida ]
Todo en Smalltalk-80, a menos que se personalice para evitar la posibilidad, está disponible para su modificación desde dentro de 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 pueden cambiar sobre la marcha. Incluso la declaración true become: falsees válida en Smalltalk, aunque no se recomienda ejecutarla excepto para fines de demostración (consulte máquina virtual , persistencia basada en imágenes y copias de seguridad ).
Los programas Smalltalk suelen compilarse en código de bytes , que luego es interpretado por una máquina virtual o traducido dinámicamente a código de máquina nativo. Los resultados de las búsquedas de mensajes anteriores se almacenan en caché en código de máquina automodificable, lo que da como resultado envíos de muy alto rendimiento que pueden superar las llamadas de función indirectas en las llamadas de método virtual de C++.
OpenSmalltalk VM (OS VM) es una implementación de relativamente alto rendimiento de la máquina virtual Smalltalk en la que se basan varios dialectos modernos de código abierto de Smalltalk. [40] [41] La OS VM deriva del intérprete Squeak original de Back-to-the-Future [42] (BTTF) implementado por Dan Ingalls, Ted Khaeler, John Maloney y muchos otros colaboradores. Al igual que con la BTTF VM, la OS VM se transpila desde el sistema Smalltalk en el que se desarrolla (utilizando un subconjunto de Smalltalk llamado Slang) al código fuente nativo del lenguaje C , [43] que a su vez se compila contra la plataforma y la arquitectura específicas del hardware, lo que permite prácticamente la ejecución multiplataforma de las imágenes de Smalltalk. La OS VM se diferencia de la BTTF VM en
Los dialectos Smalltalk notables basados en el sistema operativo VM son: [44]
Para satisfacer esta necesidad, ARPA creó la IPTO en 1962 con el mandato de construir una red informática capaz de sobrevivir para interconectar las principales computadoras del Departamento de Defensa en el Pentágono, Cheyenne Mountain y la sede del SAC.
