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ó numerosas ideas 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 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 el lenguaje de referencia 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 puso fin a VisualAge Smalltalk, después de haber decidido a fines de la década de 1990 respaldar Java y, a partir de 2005 [actualizar], cuenta con el respaldo de Instantiations, Inc. [17] Instantiations cambió el nombre del producto VA Smalltalk (Plataforma VAST) y continúa lanzando 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. [ cita necesaria ] 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 influyeron en la historia de la interfaz gráfica de usuario (GUI) y la interfaz de usuario lo que ves es lo que obtienes ( WYSIWYG ), los editores de fuentes y las metáforas de escritorio para el diseño de la interfaz de usuario. 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. 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: genera una excepción que, si no se detecta, abre el depurador del sistema. Alan Kay ha comentado que a pesar de la atención prestada a los objetos, la mensajería es el concepto más importante en Smalltalk: "La gran idea es '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, el código de Smalltalk se puede 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 productividad.
Smalltalk es un lenguaje de programación orientado a objetos "puro", lo que significa que, a diferencia de C++ y Java , no existen tipos primitivos. Todos los valores se representan como objetos y el cálculo en números enteros utiliza el envío de mensajes como cualquier otro objeto. En Smalltalk, tipos 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. Para mayor eficiencia y generalidad, los enteros se implementan mediante cuatro clases, Integer, la superclase abstracta de todos los enteros, SmallInteger, cuyas instancias caben en una palabra de máquina, por ejemplo, con un rango con signo de 61 bits en una implementación de 64 bits, LargePositiveInteger y LargeNegativeInteger. los dos últimos son vectores de bytes. En consecuencia, Smalltalk puede evaluar 52 factoriales para producir 80658175170943878571660636856403766975289505440883277824000000000000. La transición de números 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 ampliar (mediante subclases ) las clases que implementan lo que en otros lenguajes serían valores primitivos, de modo que se pueda definir un nuevo comportamiento para sus instancias (por ejemplo, para implementar nuevas estructuras de control) o incluso para que su comportamiento existente sera cambiado. 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. Las clases contienen diccionarios de métodos que asignan selectores (el equivalente de los nombres de procedimientos de función en otros idiomas) a objetos de método, objetos que se ejecutan para evaluar mensajes. Las clases heredan de otras clases, con Objeto o ProtoObjeto en la raíz de la jerarquía de clases. Enviar un mensaje a un objeto en el modo más abstracto implica buscar la clase del receptor (el objeto al que se envía el mensaje) y buscar el selector del mensaje en el diccionario de métodos de la clase, seguido de la superclase y así sucesivamente hasta que se encuentre el método o DoesNotUnderstand se envía. Las máquinas virtuales Smalltalk utilizan varias técnicas para acelerar la búsqueda de mensajes, de modo que el sistema proporcione un mecanismo de enlace de mensajes simple y consistente y una buena eficiencia. Los bloques de código (la forma en que Smalltalk expresa 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 la Colección.
Reflexión es un término aplicado a programas de software que tienen la capacidad de inspeccionar y/o representar 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 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 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 de Smalltalk, que a su vez está escrito en Smalltalk y existe junto con el resto del código del sistema, compila el código fuente textual en objetos de método, normalmente instancias de CompiledMethod. Estos se 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. 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/espacios/variables de instancia define?". Por lo tanto, los objetos se pueden inspeccionar, copiar, (des) serializar fácilmente , etc., con un código genérico que se aplica a cualquier objeto del sistema. [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), thisContextque corresponde a un marco de pila en implementaciones de lenguajes convencionales, y se llama un "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 primero. De esta manera, la pila es una lista vinculada de objetos de contexto y el depurador es esencialmente un inspector de esta "pila de espagueti". 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] 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 la flexibilidad de una pila de espaguetis sin la mayoría de sus costos. Básicamente, 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 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 true, falsey son instancias ú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).nilselfsupersuperthisContext
El dicho de que "la sintaxis de Smalltalk cabe en una postal " puede haberse originado en la concepción original del lenguaje de Alan Kay, tal como 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.
#(( 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, bloques ( literales de funciones anónimas )
[... Algún código de charla trivial . ..]Lo siguiente toma dos argumentos y compara dos objetos cualesquiera que puedan entender "menos 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 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). Hay tres tipos de envío de mensajes: mensajes unarios que tienen una sola palabra clave, como classy size, mensajes binarios que, por ejemplo, se utilizan para aritmética, como , y mensajes de palabras clave en los que una palabra clave seguida de dos puntos precede a cada argumento del mensaje. , de modo que envía el mensaje a con argumentos y . Los mensajes unarios tienen mayor prioridad que los mensajes binarios, que a su vez tienen mayor prioridad que los mensajes de palabras clave, y la evaluación se realiza 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:
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). El programador es libre de definir nuevos selectores binarios del mismo modo que es libre 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 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.
Smalltalk es un lenguaje basado en expresiones . Cada declaración, incluidas las construcciones de control, tiene un valor, que es algún objeto. 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 (el punto es un separador de declaraciones, no un terminador de declaraciones). 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 abierta Si se envía una serie de mensajes al mismo receptor como en el ejemplo anterior, también se pueden escribir como una cascada con mensajes individuales separados por punto y coma:
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
^falseAlternativeBlock valor
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 lo que 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 | 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 (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ónSmalltalk es uno de los primeros sistemas que se basa en un entorno de desarrollo integrado . Existe 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 han 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 clases dentro de "categorías de sistema", como Kernel-Numbers, Kernel-Objects, Collections-Abstract, Collections-Sequenceableetc, y dentro de las clases los métodos se organizan en categorías con nombre como accessing, arithmetic, instance creation, etc. De aquí se deriva el clásico navegador de cinco paneles, con cuatro paneles en la mitad superior de la ventana contiene de arriba a izquierda la lista de categorías del sistema, que cuando se selecciona una muestra en la segunda ventana la lista de clases en esa categoría, que cuando se selecciona una muestra la lista de categorías de mensajes en la clase seleccionada , que cuando se selecciona uno muestra en el último panel los selectores de los métodos de la categoría seleccionada en la clase seleccionada. Cuando se selecciona uno de los selectores en el cuarto panel, la fuente de ese método se muestra en el quinto panel. Si solo se selecciona una categoría y no un método, el quinto panel muestra una plantilla para definir un nuevo método. Si se selecciona una categoría del sistema pero no una clase, se muestra una plantilla para crear una clase en la categoría. Varios menús emergentes permiten consultar 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 "hazlo" (evalúa la expresión seleccionada), "imprime" (evalúa la expresión seleccionada e inserta la cadena de impresión del resultado inmediatamente después de la selección) e "inspecciona" (abre un inspector en el resultado de la evaluación de la expresión seleccionada, consulte "Inspector" a continuación) son tres acciones utilizadas 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 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 tener resaltada la sintaxis. Al usar bloques para separar diferentes expresiones, se pueden tener varias expresiones resaltadas de sintaxis, cada una con sus propios temporales en un único espacio de trabajo.
La Transcripción es un espacio de trabajo especial asociado con la Transcripción global. Entonces, la evaluación causa 80658175170943878571660636856403766975289505440883277824000000000000 seguido de una nueva línea que aparece en la ventana Transcripción. El Transcript sirve por tanto como un lugar para emitir mensajes de registro, aunque también puede funcionar como un Espacio de Trabajo.Transcript print: 52 factorial; cr; flush
Hay varios inspectores, algunos diseñados para mostrar diferentes 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 en el objeto, que incluirán variables de instancia v 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. Editar y "aceptar" el texto en el panel del espacio de trabajo cuando se selecciona una variable de instancia asignará el resultado de la evaluación a la variable seleccionada. Se puede "profundizar" utilizando el comando "inspeccionar" en el menú de lista que se aplicará a la variable de instancia seleccionada. Los inspectores más sofisticados admiten sistemas en cascada para que la estructura del objeto pueda atravesarse 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", luego 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 de 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 genera la excepción. Al seleccionar un contexto, se actualizan los cuatro paneles inferiores. Los dos paneles inferiores izquierdos son el inspector del receptor, que inspecciona el receptor del mensaje seleccionado. Los dos paneles inferiores derechos son el inspector de contexto que muestra el argumento y los nombres de 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, proporcionando una función de punto de interrupción simple (por lo general, las funciones de punto de interrupción brindan algo más que una simple parada, pero fue la primera función de este tipo). Los espacios de trabajo también proporcionan un evaluador de "depuración" que abre un depurador en la expresión seleccionada ubicada en el primer mensaje enviado dentro de la expresión. Entonces, 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 "entrar", "pasar por encima", etc. Por lo tanto, al elegir "entrar", uno 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, entonces el notificador incluirá un botón "Crear", lo que permitirá al programador elegir en qué parte de la jerarquía del receptor definirá un "borrador inicial" del método que se implementará. Redefinir un método en el depurador hace que el contexto seleccionado se restablezca 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 divertida de programar. Todo lo que hay en el sistema está al alcance de tu mano. Uno tiene todo el poder de los espacios de trabajo para evaluar subexpresiones y el navegador para buscar código de soporte como uno de los programas.
El 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 dinámico o de tiempo de ejecución del programa (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 se personalice para evitar esa posibilidad, está disponible para modificaciones 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 de máquina nativo. Los resultados de las búsquedas de mensajes anteriores se almacenan en caché en código de máquina que se modifica automáticamente, lo que da como resultado envíos de muy alto rendimiento que pueden superar las llamadas a funciones indirectas en las llamadas a métodos virtuales de C++.
OpenSmalltalk VM (OS VM) es una implementación de rendimiento relativamente alto de la máquina virtual Smalltalk en la que se basan varios dialectos Smalltalk modernos de código abierto. [40] [41] El sistema operativo VM deriva del intérprete Squeak original de Regreso al futuro [42] (BTTF) implementado por Dan Ingalls, Ted Khaeler, John Maloney y muchos otros colaboradores. Al igual que con BTTF VM, OS VM se transpila del sistema Smalltalk en el que se desarrolla (utilizando un subconjunto de Smalltalk llamado Slang) al código fuente nativo en lenguaje C , [43] que a su vez se compila contra una plataforma y arquitectura específicas del hardware que prácticamente permite la ejecución multiplataforma de las imágenes de Smalltalk. La VM del sistema operativo se diferencia de la VM BTTF en
Los dialectos notables de Smalltalk basados en OS VM son: [44]
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.
