Ya llega Smalltalks 2019!!!

No se pierdan la Smalltalks de este año en la Universidad Nacional de Comahue en Neuquén!

La programación como una forma de pensar

Leyendo un poco la web me encontré con un articulo de la scientific american, muy básicamente señala la importancia que tienen los lenguajes de programación modernos y su impacto positivo en el pensar humano.

La programación solía ser solo una traducción: expresar ideas en lenguaje natural, trabajar con ellas en la notación matemática, luego escribir diagramas de flujo y pseudocódigo, y finalmente escribir un programa. La traducción era necesaria porque cada lenguaje ofrece diferentes capacidades. El lenguaje natural es expresivo y legible, el pseudocódigo es más preciso, la notación matemática es concisa y el código es ejecutable.

Pero el precio de la traducción es que estamos limitados al subconjunto de ideas que podemos expresar efectivamente en cada lenguaje. Algunas ideas que son fáciles de expresar computacionalmente son difíciles de escribir en notación matemática, y las manipulaciones simbólicas que hacemos en matemáticas son imposibles en la mayoría de los lenguajes de programación.

El poder de los lenguajes de programación modernos es que son expresivos, legibles, concisos, precisos y ejecutables. Eso significa que podemos eliminar los lenguajes intermedios y usar un lenguaje para explorar, aprender, enseñar y pensar. Esto me hace pensar mucho en smalltalk.

Salvo que habla solo de python, por lo demás esta muy bueno.

Dejo link: https://blogs.scientificamerican.com/guest-blog/programming-as-a-way-of-thinking/

Los Creadores de los Lenguajes de Programación mas famosos

Muy buen vídeo que nos muestra a los padres de los lenguajes de programación:

A mi entender falto Smalltalk, Haskell y Scala. Pero es solo mi opinión. Que opinan ustedes??

Como aprender smalltalk puede hacerte mejor desarrollador

Me encontre con un articulo muy bueno, que asegura que si aprendes smalltalk vas a mejorar como desarrollador. Me gusto esta hipotesis...

Smalltalk es ampliamente percibido como un viejo lenguaje moribundo, una antigüedad de una época pasada. Nada mas lejos de la verdad.

Smalltalk sigue siendo muy relevante. Es un excelente lenguaje para la enseñanza de programación a personas que no tienen antecedentes técnicos. Es un lenguaje de prototipado superlativo para las startups. Es un lenguaje utilizado por las empresas grandes y pequeños en todo el mundo. Hay buenas razones para considerar el uso de Smalltalk moderno hoy en día, ya que ha cambiado mucho en los últimos años.

No es necesario que use Smalltalk en la producción, pero intente codificar algo en Smalltalk y va a ver cómo se siente. Debe sentirse familiar, porque la implementación de Smalltalk del paradigma orientado a objetos (OO) es tan excelente que ha influido en toda una generación de lenguajes OO, como Objective-C, Python, Ruby, CLOS, PHP 5, Perl 6, Erlang , Groovy, Scala, Dart, Swift, y así sucesivamente.

Al aprender Smalltalk, comprenderá cómo todas esas características útiles en los idiomas OO actuales llegaron a ser. Aprender Smalltalk también podría darle una gran ventaja en las habilidades de programación entre sus compañeros, y podría ser una gran herramienta para la enseñanza de la programación para los principiantes.

Que nos ha dejado smalltalk?

• Smalltalk introdujo el mundo en la máquina virtual de lenguaje (o VM), que permite que el software sea independiente de la plataforma. Esta es la misma tecnología que sustenta Java (JVM) y .NET, así como Android (Dalvik).
• Smalltalk también fue pionero en la compilación JIT (just-in-time), una técnica para mejorar drásticamente el rendimiento de software de bytecode como Java.
• Desde Smalltalk surgió el primer IDE moderno (entorno de desarrollo integrado), que incluía un editor de texto, un navegador de sistema o clase, un inspector de objetos o propiedades y un depurador. Esto llevó a los muchos IDE que los desarrolladores favorecen hoy en día, como Visual Studio, Xcode e IntelliJ IDEA. P
• Desde el principio, Smalltalk tenia clausuras, que son funciones de primera clase. En esencia, una clausura es una función que puede ser asignada a una variables. Esto puede ayudarle a escribir código mucho más compacto y legible. Las clausuras están encontrando su camino en muchos lenguajes, como Java, C # y PHP.
• Smalltalk fue el padre de la depuración como la conocemos.
• Smalltalk presentó MVC (Model-View-Controller) al mundo. MVC es un patrón de arquitectura de software para implementar interfaces de usuario. Es popular entre las aplicaciones GUI de escritorio y las aplicaciones web. En estos días, es la arquitectura que la mayoría de los desarrolladores web aprender primero.
• En gran medida, Smalltalk es responsable de darnos el desarrollo basado en pruebas (o TDD) y la programación extrema (o XP), que son ambos muy influyentes en las prácticas ágiles estándar actuales.
• Smalltalk fue pionera en el desarrollo de bases de objetos. El mejor ejemplo de un producto de base de objetos es GemStone / S, que se adapta perfectamente a sistemas distribuidos escalables, de alto rendimiento y multitotal.
• Smalltalk nos dio el primer navegador de refactorización. Por supuesto, refactorización de apoyo se puede encontrar en la mayoría de los IDEs de hoy.
• Smalltalk fue instrumento en el desarrollo de la interfaz gráfica de usuario (GUI) y la interfaz de usuario "lo que ves es lo que obtienes" (WYSIWYG).

Que más decir son varias razones. 

Dejo link: 

https://techbeacon.com/how-learning-smalltalk-can-make-you-better-developer

Dictionary en smalltalk

El Dictionary (Diccionario) es una colección que puede verse desde 2 puntos de vista:

Como un Set de asociaciones clave->valor

Como un contenedor donde los elementos son nombrados desde el exterior, donde el nombre puede ser cualquier objeto que responda al mensaje #=.

Ejemplos:

"instanciar, y llenar, un diccionario"
| diccionario |

diccionario := Dictionary new.

diccionario at: 'hoy' put: Date today.
diccionario at: 'ahora' put: Time now.
diccionario at: false put: 'es false'.

"algunas formas de acceder al diccionario"
diccionario at: 'hoy'.
diccionario at: 'mañana' ifAbsent:[nil].
diccionario at: 'mañana'.
diccionario at: 'mañana' ifAbsentPut:[Date tomorrow].
diccionario at: 'mañana'.

"otras formas de acceso"
diccionario keys.
diccionario values.

"algunas iteraciones"
Transcript clear.
Transcript cr; show: '#do:'; cr.
diccionario do: [:each |
   Transcript show: ' ' , each asString; cr.
].

Transcript cr; show: '#associationsDo:'; cr.
diccionario associationsDo: [:each |
   Transcript show: ' ' , each asString; cr.
].

Transcript cr; show: '#keysAndValuesDo:'; cr.
diccionario keysAndValuesDo:[:eachKey :eachValue |
   Transcript show: ' ' , eachKey asString , ' - ' , eachValue asString; cr.
].

Estudiar Smalltalk

Sin duda lo más importante para aprender Smalltalk es meter mano en un Smalltalk.  No vale de nada leer cientos de libros si no nos metemos de lleno en un ambiente de Smalltalk y comenzamos a hacer cosas.

Pero también es cierto que la experiencia puede ser más fácil si logramos percibir algo de la filosofía del desarrollo con Smalltalk desde algunos libros. Por lo tanto quiero recomendarles:

Libros

• Smalltalk-80 - The Language: En este libro se puede entender, de personas que participaron en el desarrollo de Smalltalk, la filosofía del lenguaje y las motivaciones que lo hicieron posible.
• Smalltalk-80 - Bits of  History, Words of Advice: Este libro me impactó por lo actual de los comentarios hechos por personas que probaron Smalltalk a principios de los años 80.
• Smalltalk Best Practice Patterns: Este libro me enseño que una de las cosas más importantes, para ser un buen programador Smalltalk, es prestar muchísima atención a la claridad del código.
• Smalltalk with Style: Este libro me mostró la mayoría de las convenciones que se utilizan a la hora de escribir código Smalltalk.
• Design Patterns - Elements of Reusable Object Oriented Software: No es posible decir hoy en día que se sabe programar con objetos si no se ha leído este libro. Este libro es el culpable de que hoy esté escribiendo un libro de Smalltalk y no uno de Java o .NET.  Me enteré de la existencia de Smalltalk, y de su impacto sobre la tecnología de objetos, a través de las explicaciones de algunos patrones.  Este es el libro que despertó mi curiosidad por aprender Smalltalk.
• The Dessign Patterns Smalltalk Companion: Este libro me enseñó mucho Smalltalk por comparación con la implementación de los patrones en el libro anterior.

Papers o artículos

• Design Principles Behind Smalltalk: Excelente descripción de las motivaciones que rigen el desarrollo del proyecto Smalltalk.  Parece ciencia ficción si consideramos que la nota fue publicada en la revista Byte de agosto de 1981.
• Personal Dynamic Media: Excelente explicación de las motivaciones detrás del desarrollo de Smalltalk escrita por Alan Kay en el año 1976.
• The Early History of Smalltalk: Esta es una historia de Smalltalk, escrita por Alan Kay, en el año 1993 (antes de que comenzara el proyecto Squeak allá por el 1995) donde cuenta de donde vienen las ideas principales.  Termina con una frase que también me marcó especialmente: “¿Donde están los Dan (Ingalls) y las Adele (Goldberg) de los 80s y los 90s que nos lleven al próximo nivel de desarrollo?”.

Colecciones en smalltalk

Como verán sigo leyendo sobre Smalltalk, ahora nos toca ver las colecciones:

Smalltalk cuenta con un framework de colecciones muy poderoso.  No es de extrañar ya que lleva más de 20 años de depuración.

Contamos con numerosos tipos de colecciones (Bag, Set, OrderedCollection, Dictionary, Array, etc) y, a su vez, con un rico y extenso protocolo de mensajes.

A continuación enumero algunos de los mensajes que se les puede enviar a todas las colecciones.

#add: Agrega un objeto (dado como argumento) a la colección.

#addAll: Agrega todos los elementos de la colección dada como argumento a la colección receptora del mensaje.

#remove: Remueve un determinado objeto de la colección. Genera un error si el elemento no es parte de la colección.

#remove:ifAbsent: Remueve un determinado elemento de la colección. Evalúa el bloque dado si el elemento no es parte de la colección.

#removeAll: Remueve todos los elementos del receptor que están contenidos en la colección dada en el argumento.

#do: Evalúa el bloque dado como argumento por cada elemento contenido en la colección.  Este es el principal mensaje de las colecciones y prácticamente todo el resto de mensajes están implementados usando el #do: de alguna forma.  Es interesante ver la implementación de, por ejemplo, los mensajes #select:, #collect:, #anyOne, #detect:ifNone:, #do:separatedBy:, etc.

#do:separatedBy: Evalúa el primer bloque dado como argumento por cada elemento contenido en la colección y evalúa el segundo bloque entre elementos.

#select: Evalúa el bloque dado por cada elemento del receptor como argumento.  Colecciona los elementos en los cuales el bloque evalúa a true (verdadero) en una colección del tipo del receptor. Responde esa colección nueva como resultado.

#reject: Similar a #select: pero colecciona los elementos para los cuales el bloque evalúa a false.

#collect: Evalúa el bloque dado por cada elemento del receptor como argumento.  Colecciona los resultados en una colección del tipo del receptor. Responde esa colección nueva como resultado.

#size Responde el tamaño de la colección.

#anyOne Responde algún elemento de la colección.

#atRandom Responde uno de los elementos del receptor de forma aleatoria.

#detect: Evalúa el bloque dado con cada elemento del receptor. Devuelve el primer elemento donde el bloque evalúa a true. Genera un error si ningún elemento es encontrado.

#detect:ifNone: Evalúa el bloque dado con cada elemento del receptor. Devuelve el primer elemento donde el bloque evalúa a true. Evalúa el otro bloque dado si ningún elemento es encontrado y devuelve el resultado de esa evaluación.

#isEmpty Responde si el receptor está vacío y no contiene elementos.

#includes: Responde si el objeto dado es un elemento del receptor.

#includesAllOf: Responde si todos los elementos de la colección dada están incluidos en la colección receptora.

#includesAnyOf: Responde si algunos de los elementos de la colección dada está incluido en la colección receptora.

#allSatisfy: Responde true si el bloque dado se evalúa a true por todos los elementos de la colección receptora.

#anySatisfy: Responde true si el bloque dado se evalúa a true por algunos de los elementos de la colección receptora.

#noneSatisfy: Responde true si el bloque dado se evalúa a false por todos los elementos de la colección receptora.

#occurrencesOf: Responde cuantas veces está incluido el objeto dado en la colección receptora.

Veamos los Conjuntos: El Set es un tipo de colección que no mantiene ningún orden sobre sus elementos y que no permite que un objeto esté contenido más de una vez.

Un Set representa el concepto matemático de conjunto, donde no tiene sentido decir que un elemento está más de una vez ni tiene sentido hablar de orden.

Ejemplos:
| set |
set := Set new.
set add: 'un string'.
set add: 'otro string'.
set add: 'un string'.
set add: 'otro string'.
set add: 'un string'.
set explore.

"convertir colecciones de diferente tipo a Set para remover los duplicados"
#(5 4 1 2 2 2 1 2 1 2 3 4 3 2 3 4 5) asSet.
'un string que tiene muchos caracteres' asSet.

"Los 2 sets contienen sólo un elemento"
(Set with: 1) = (Set with:1 with:1).

"El orden no importa"
(Set with: 1 with: 2) = (Set with:2 with:1).

Browser de Clases en Pharo o smalltalk que es casi lo mismo

Como veran sigo leyendo sobre smalltalk. Ahora vamos a analizar Browser de Clases

Esta herramienta nos permite ver y modificar todas las clases que tenemos en nuestro ambiente. Podemos también crear o eliminar categorías de clases, clases, categorías de métodos y métodos.
Como Pharo está escrito en si mismo, esta herramienta nos permite ver absolutamente todo el funcionamiento de Pharo.  Desde el Compilador hasta las Ventanas, desde los Números Enteros hasta los tipos Booleanos, todo visible y todo modificable.

El browser está compuesto principalmente por 4 paneles superiores y un panel inferior. En los paneles superiores encontraremos - de izquierda a derecha - las Categorías de Clases, las Clases, las Categorías de Métodos y los Métodos.

Categorías de Clase y Métodos: Tanto las categorías de clases como las categorías de métodos no tienen una semántica para el Smalltalk en si mismo, sino que sirven para documentar el diseño agrupando clases y métodos por funcionalidad apuntando a mejorar el entendimiento del sistema por las personas.

En Smalltalk se lee mucho más código del que se escribe, así que todo el entorno promueve la escritura de código limpio y documentado y todo el tiempo que usemos en escribir código limpio es recompensado.

Si seleccionamos una de las opciones del panel, en los paneles subsiguientes veremos la información correspondiente a la selección. Por ejemplo, si seleccionamos en el primer panel la categoría de clases 'Kernel-Objects', veremos en el segundo panel las clases dentro de esa categoría (como Boolean, DependentsArray, False, MessageSend, etc).  De la misma forma, si ahora seleccionamos la clase Boolean en el segundo panel, veremos en el tercer panel las categorías de métodos de esa clase; y si seleccionamos una categoría de métodos como 'controlling' veremos en el último panel los métodos.  Por último, si seleccionamos uno de los métodos, veremos en el panel inferior el código de dicho método.

Programar con Smalltalk es enviar mensajes a objetos que viven en un ambiente. Programar, con Smalltalk, no es más que modificar un ambiente de objetos y adaptarlo a nuestra necesidad.

A desarrollar con Smalltalk!! 4

Vamos a hacer más flexible nuestro Saludador, vamos a permitir saludar con cualquier saludo, por lo tanto vamos a agregar un atributo:

Este atributo necesitar métodos para acceder a estos atributos. Por lo tanto hacemos menú contextual en la clase, refactoring->class refactoring->generate accesor. Y con esto nos va a generar los métodos para acceder a la variable de instancia.

Ahora podemos cambiar el método "saludar" para que pueda utilizar el saludo:

saludar
  ^ saludo.

Ahora vamos a probar nuestra nueva clase:

s := Saludador new.
s saludo: 'Hola!!'.
s saludar.

Esto retornara 'Hola!!'

Vamos a hacer un metodo que pida un parámetro y salude al nombre pasado por parámetro : 

saludarA: nombre

  ^ saludo , ' ' , nombre.  

Ahora podemos saludar a Pepe !! 

s := Saludador new. 

s saludo: 'Hola!!'.

s saludarA: 'Pepe'.

Por este post hemos hecho demasiado. 

AWS SDK para Smalltalk

El AWS SDK para Pharo Smalltalk permite a los desarrolladores de Smalltalk trabajar fácilmente con Amazon Web Services y Amazon DynamoDB, S3, Elastic Transcoder. Puede empezar en cuestión de minutos a utilizar Metacello y FileTree.

Dejo link: https://github.com/newapplesho/aws-sdk-smalltalk

A desarrollar con Smalltalk!! 3

Continuamos con nuestro ejemplo. Ahora vamos a crear una instancia de nuestra recién creada clase Saludador.  Para evaluar algo de código, podemos utilizar otra herramienta que un ambiente Smalltalk nos brinda: El Playground.

El Playground (espacio de trabajo) es una ventana que nos permite ordenar el código que vamos evaluando de forma interactiva en nuestro ambiente.

El Playground es una herramienta conveniente, pero es importante resaltar que en Smalltalk se puede evaluar código en cualquier panel de texto y no sólo en los Playground.

Para abrir un Playground usaremos nuevamente el Menú  y dentro la opción 'Playground' :

Luego escribimos un programa que instancie nuestra clase y que llame al método saludar. Y luego podemos presionar el botón de play: 

Y nos saluda!!

A desarrollar con Smalltalk!! 2

Al crear una nueva categoría, esta se selecciona automáticamente y vemos en el panel inferior una plantilla (un template) para crear una clase nueva.  Para crear una nueva clase tenemos que enviarle un mensaje a la superclase, para eso nos podemos valer de la plantilla que el Browser de Clases nos ofrece.  Simplemente reemplazamos donde dice NameOfSubclass por el nombre de la clase que queremos crear.

Vamos a hacer una clase que salude, por lo tanto le vamos a llamar saludador:

Y Ya tenemos nuestra primera clase!!

Como la probamos? lo verán en el próximo post.

A desarrollar con Smalltalk!!

Vamos a introducirnos de lleno en la programación con Smalltalk.  Aprender a programar con Smalltalk es mucho más que aprender una sintaxis y una librería de clases; es mucho más importante conocer como utilizar el ambiente en nuestro beneficio y entender que implica utilizar un ambiente de objetos vivos.

Smalltalk no es sólo un lenguaje de computación,  Smalltalk es un ambiente donde conviven objetos y estos interactúan entre sí enviándose mensajes.  Toda la computación ocurre como el resultado del envío de mensajes a los objetos.  Cuando un usuario interactúa con un ambiente Smalltalk, este ambiente se ve modificado como efecto de esa interacción.

Recordemos que en Smalltalk todo es un objeto. Las clases, los métodos, etc (obviamente) también son objetos y para impactar sobre ellos debemos enviarles mensajes. Esto implica que la tarea de programación no es diferente a cualquier otra cosas que se haga en un ambiente Smalltalk: Objetos que reciben mensajes y que reaccionan como efecto de ese envío de mensajes.

En Smalltalk no existe diferencia entre “desarrollo” y “ejecución”, sino que la programación se hace modificando objetos mientras estos están funcionando.  Para ilustrar mejor esta idea vamos a desarrollar, paso a paso, un ejemplo sencillo.  El ejemplo, también, nos servirá para tomar un primer contacto con las principales herramientas de desarrollo con Smalltalk.

Entonces empecemos descargando Pharo, recuerden el post de recursos sobre Pharo.

Si no tuvieron problema lo pudieron abrir y vieron algo como esto:

Cerramos esta ventana de bienvenida y hacemos click con lo que se abrira un menu en el cual podemos seleccionar System browser y nos abrirá la siguiente ventana:

El browser está compuesto principalmente por 4 paneles superiores y un panel inferior. En los paneles superiores encontraremos - de izquierda a derecha - las Categorías de Clases, las Clases, las Categorías de Métodos y los Métodos.

Podemos hacer un nuevo package si seleccionamos add package.

Luego si hacemos click en el panel de objetos aparecerá el siguiente menú:

Programar con Smalltalk es enviar mensajes a objetos que viven en un ambiente. Programar, con Smalltalk, no es más que modificar un ambiente de objetos y adaptarlo a nuestra necesidad.

Al crear una nueva categoría, esta se selecciona automáticamente y vemos en el panel inferior una plantilla (un template) para crear una clase nueva.  Para crear una nueva clase tenemos que enviarle un mensaje a la superclase, para eso nos podemos valer de la plantilla que el Browser de Clases nos ofrece.  Simplemente reemplazamos donde dice NameOfSubclass por el nombre de la clase que queremos crear. Y de esta forma tenemos una nueva clase.

En un próximo post veremos crear un método.

Librería de Clases y Frameworks en Smalltalk

La imagen de un Smalltalk cuenta con cientos, si no miles, de clases con funcionalidad aprovechable por nuestro desarrollo.

Las clases que vienen en Smalltalk nos brindan, entre otras cosas, la siguiente funcionalidad:

Números: Existen todo tipo de números. Enteros, coma flotante, fracciones, etc.

Colecciones: El framework de colecciones de Smalltalk es uno de los más antiguos y más funcionales que existen en la actualidad. La lista de colecciones incluye Bag, Set, OrderedCollection, SortedCollection, Dictionary, etc.

String: Soporte para cadenas de caracteres de bytes y cadenas que soportan caracteres unicode.

Boolean: Las clases Boolean, True y False se usan, entre otras cosas, para implementar algunas de las 'estructuras de control'.

Cronología: Clases como Date, Time, DateAndTime, Month, Week, Year,

Gráficos: Smalltalk tiene mucho que ver con el desarrollo de las interfaces de usuario gráficas. En los Smalltalk completamente auto-contenidos (como Squeak) todo lo referente al procesamiento gráfico está implementado en Smalltalk y, por ende, es inspeccionable y modificable por el usuario.  Se cuentan con operaciones 2D básicas (como BitBtl) hasta soporte para gráficos 3D con OpenGL.  El Squeak, a la fecha, tiene soporte para colores con el canal alfa (transparencia), anti-aliasing, renderizado de TTF (True Type Fonts), etc.

Stream: Hay veces que es necesario combinar operaciones de acceso a los elementos de una colección con operaciones de inserción de elementos.  Los típicos mensajes de enumeración de las colecciones de Smalltalk no permiten insertar elementos mientras sucede la iteración.  La jerarquía de clases de Stream permite la iteración de colecciones a la vez que la inserción de elementos.  La metafora de los “streams de objetos” funcionó  tan bien en Smalltalk que, a partir de entonces, se usa para acceder a fuentes de datos externas en Smalltalk y en muchos lenguajes orientados a objetos.

Weak References: Se puede hacer un uso avanzado del recolector de basura utilizando referencias débiles a objetos.  Las referencias débiles, al contrario de las referencia normales o fuertes, no evitan que un objeto sea reclamado por el recolector.  Un objeto puede ser reclamado por el recolector cuando no tenga referencias en absoluto, o tenga sólo referencias débiles.  Muy útil para implementar caches, pool de instancias, mecanismos de finalización de objetos, etc.

Multithreading: El Smalltalk soporta multithreading desde los inicios.  Se cuenta con una rica variedad de clases para hacer computación concurrente de forma sencilla.  Las clases Process (Proceso = Thread) y Semaphore (Semáforo) sirven de base para la programación con threads.

Excepciones: Smalltalk cuenta con un moderno esquema de excepciones.  A diferencia de otros lenguajes, toda la implementación de excepciones está escrita en el mismo lenguaje. Entre otras cosas, el mecanismo de excepciones de Smalltalk permite continuar con la ejecución en el punto siguiente donde ocurrió la excepción.

Metaclases: Todo en Smalltalk es un objeto.  Todos los objetos tienen una clase.  Las clases, como todo, son objetos. Las clases tienen su clase, que se llama la Metaclase.  Todo el mecanismo de herencia está modelado con clases y metaclases.

Seaside: El Seaside es un framework para hacer aplicaciones web basado en continuations.  Un framework como Seaside simplifica muchísimo el manejo del flujo de un sitio web.

SUnit: Este es el framework 'padre' de todos los frameworks de unit-testing que existen.

Magma: Base de datos de objetos, multiusuario, que permite una completa transparencia a la hora de persistir objetos.

Seguimos con Smalltalk, parte 3

En Smalltalk el comportamiento (el código) también es un objeto.  Los bloques son una forma de capturar comportamiento (código) en un objeto para utilizarlo a nuestra discreción.  La forma básica de un bloque es una lista de expresiones, separadas por un punto, encerradas entre corchetes ([]).

[ExpresiónSmalltalk1].
[ExpresiónSmalltalk1. ExpresiónSmalltalk2].

La forma de activar un bloque (de ejecutar el código que encierra) es enviándole el mensaje #value. La última expresión del bloque será el valor de retorno.

| bloque |
bloque := [World flash]. "En este punto el mundo NO parpadea"
bloque value. "Ahora que evaluamos el bloque el mundo SI parpadea"

Una cosa muy interesante del lenguaje Smalltalk es que no existen, como parte de la sintaxis, las 'estructuras de control'.  La funcionalidad que los lenguajes tradicionales se da con extensiones en la sintaxis, en Smalltalk se resuelve con mensajes a objetos.

Smalltalk allClasses size > 2000
        ifTrue:[Transcript show: '¡Cuantas clases!'; cr].


Smalltalk allClasses size > 2000
        ifTrue:[Transcript show: '¡Cuantas clases!']
        ifFalse:[Transcript show: '¡No son tantas las clases!'].
Transcript cr.

| número paridad |
número := 11.
(número \\ 2) = 0
    ifTrue:[paridad := 0]
    ifFalse:[paridad := 1].

| número paridad |
número := 11.
paridad := (número \\ 2) = 0 ifTrue:[0] ifFalse:[1].

Veamos una estructura tipo WHILE:
| index |
index := 1.
[index < 10]
    whileTrue:[
        Transcript show: index; cr.
        index := index + 1
    ].

Veamos una estructura tipo FOR:
1 to: 10 do:[:index | Transcript show: index; cr].
1 to: 10 by: 2 do:[:index | Transcript show: index; cr].

25 timesRepeat:[Transcript show: '.'].
Transcript cr.

Es muy interesante ver la implementación del los métodos True>>ifTrue:ifFalse: y False>>ifTrue:ifFalse: para entender como funcionan las 'estructuras de control' con objetos y mensajes.

A los bloque, también, se les puede activar con argumentos.  La sintaxis para definir un bloque que necesita argumentos para evaluarse es la siguiente:

[:argumento1 | Expresiones].
[:argumento1 :argumento2 | Expresiones].

Para activar un bloque que requiere un argumento se usa el mensaje #value:, para activar uno que requiere 2 argumentos se usa el mensaje #value:value:, y así sucesivamente para bloques con 3 o más argumentos.

| productos |
productos := #(2 3 5 7 11 13) collect:[:primo | primo * primo].
Transcript show: productos; cr.


| colección |
colección := SortedCollection sortBlock:[:x :y | x size < y size].
colección add: 'un string más largo'.
colección add: 'un string'.
colección add: #(#un #array #con @simbolos).
Transcript show: colección; cr.

Y, por último, se pueden declarar variables temporales al bloque con la siguiente sintaxis.

[| variableTemporal | Expresiones].
[:argumento1 | | variableTemporal | Expresiones].

Seguimos con Smalltalk, parte 2

Mensajes: Los mensajes representan la interacción entre los componentes de un sistema Smalltalk. Un mensaje es un pedido que un objeto le hace a otro objeto.

Un mensaje está compuesto por el receptor (el objeto al que se le hace el pedido), el selector (el nombre del mensaje) y, si corresponde, por los argumentos.

Desde el punto de vista sintáctico, hay 3 tipos de mensajes: Unary, Binary y Keyword.

Mensajes Unary: Los mensajes Unary son mensajes sin argumentos. Son los más simples y constan de: receptor mensaje.

-1 abs.
2 class.
1000 factorial.
'aeiou' size.
Date today.
Time now.
OrderedCollection new.
#símbolo class.
String category.

Mensajes Binary: Los mensajes Binary están compuestos de la siguiente forma:

receptor unOperador argumento.

Los operadores válidos están compuestos por 1 ó más de los siguientes caracteres:

 - ~ ! @ % & * + = \ | ? / > < ,

3 + 5.
3 > 7.
3 = 5.
2 @ 10.
'Un String ', 'concatenado a otro'.
'Alan Kay' -> Smalltalk.

Mensajes Keyword: Los mensajes Keyword están formados con 1 ó más palabras clave, con sus respectivos argumentos, con la forma:

receptor palabraClave1: argumento1.

O de la forma:

receptor palabraClave1: argumento1 palabraClave2: argumento2.

Y así con 3, 4 ó más palabras claves y sus argumentos.

'Un String' first: 3.
'Un String' allButFirst: 3.
'Un String' copyFrom: 2 to: 5.
5 between: 1 and: 10.
1 to: 5.
Array with: 1 with: nil with: 'string'

Valor de retorno: El lenguaje Smalltalk provee un mecanismo doble de comunicación.  El selector y los argumentos del mensaje permiten que el emisor le envíe información al receptor. Por otro lado el receptor devuelve información con un objeto como resultado del envío de mensajes.

Los métodos, que son la forma que tienen los objetos de responder a los mensajes, pueden especificar el valor de retorno usando el caracter ^.

unMétodoConValorDeRetorno1
    "Este es un ejemplo de método que responde nil como valor de retorno"
    ^ nil


unMétodoConValorDeRetorno2
    "Este es un ejemplo de método que responde al mismo receptor como valor de retorno.
    Si el método no tiene un valor de retorno explícito, el receptor es el resultado"


Cascading messages: A veces es necesario enviarle varios mensajes al mismo receptor.  En el lenguaje Smalltalk hay una forma sintáctica de enviar más de un mensaje al mismo receptor.

La forma es terminar el envío del primer mensaje con el carácter punto y coma (;) y a continuación escribir el siguiente mensaje.

Transcript
    clear;
    show: 'algo en el Transcript'; cr;
    show: 'y algo más'; cr.

Precedencia: Los mensajes se evalúan de izquierda a derecha. Los mensajes Unary tienen precedencia sobre los Binary, y a su vez los Binary tienen precedencia sobre los mensajes Keyword.  Siempre se pueden romper las reglas de precedencia utilizando paréntesis.

'string' at: -2 negated   >>>   'string' at: (-2 negated)

'string' at: 2 + -1 negated   >>>   'string' at: (2 + (-1 negated))

Las simples reglas de precedencia, de la sintaxis Smalltalk, tienen algunas implicaciones desconcertantes para personas acostumbradas a otros lenguajes de programación.  En Smalltalk el compilador NO sabe de, por ejemplo, sumas y multiplicaciones.  Eso quiere decir que el compilador no puede determinar que, cuando operamos con números, la multiplicación tiene precedencia sobre la suma.

Analicemos esta sentencia:

3 + 2 * 4   >>>    20

Según las reglas de precedencia de Smalltalk se envía primero el mensaje + (con el argumento 2) y al resultado (5) se le envía el mensaje * (con el argumento 4).  De esa forma el resultado es 20 y no 11 como hubiese sido en otros lenguajes.

Siempre podemos utilizar paréntesis para forzar la precedencia que deseamos:

3 + (2 * 4)   >>>    11

Variables: La memoria disponible para un objeto se organiza en variables.  Las variables tienen un nombre y cada una hace referencia a un único objeto en cada momento.  El nombre de las variables puede ser usados en expresiones que quieran referir a ese objeto.

métodoDeEjemplo: argumento
    "Este método muestra el uso de diferentes tipos de variables.
    argumento: argumento al método
    variableTemporal: variable temporal al método
    variableDeInstancia: variable de instancia
    Smalltalk: variable global
    each: argumento para el bloque
    "
    | variableTemporal |
    variableTemporal := Smalltalk allClasses.
    variableDeInstancia := variableTemporal select:[:each |
                                                        | variableTemporalAlBloque |
                                                        variableTemporalAlBloque := 1.
                                                        each name beginsWith: argumento
                                                    ].

El nombre de las variables está compuesto por una secuencia de letras y dígitos, empezando con una letra. Las variables temporales y de instancia comienzan con una letra minúscula, las globales comienzan con una letra mayúscula.  Otra convención en lo que respecta al nombre de las variables es que si este está compuesto de varias palabras, cada una (excepto la inicial en algunos casos) debe comenzar por mayúscula.

Los nombres de clases son, también, variables globales

Cuando se crear una clase, el Smalltalk crea una variable global que referencia al objeto clase.  De ahí se desprende que la convención de nombres de clase sea la misma que la convención de nombres de variables globales.

Un literal siempre se refiere a un único objeto pero una variable puede referirse a diferentes objetos en diferentes momentos.

Asignación: El objeto referenciado por una variable cambia cuando una asignación es evaluada.  Las asignaciones, en Smalltalk, tienen la forma:

variable := ExpresiónSmalltalk.

x := 0.
y := 1.
punto := x @ y.
clases := Smalltalk allClasses.

Pseudo-variables: Una pseudo-variable es un identificador que referencia a un objeto. La diferencia con las variables “normales” es que no se pueden asignar y siempre referencian al mismo objeto.

nil. "Referencia a un objeto usado cuando hay que representar el concepto de 'nada' o de 'vacío'. Las variables que no se asignaron nunca, referencian a nil"
true. "Referencia a un objeto que representa el verdadero lógico."
false. "Referencia a un objeto que representa el falso lógico."
self. "Referencia al receptor del mensaje."
super. "Referencia al receptor del mensaje, pero indica que no debe usarse la clase del receptor en la búsqueda del método a evaluar. Se usa, sobre todo, cuando se especializa un método en una subclase y se quiere invocar el método de la superclase."
thisContext. "Referencia al objeto contexto-de-ejecución que tiene toda la información referente a la activación del método."

Seguimos con smalltalk

Prácticamente todo el paradigma de objetos se puede resumir en: Objetos que reciben mensajes.  La sintaxis Smalltalk es una directa consecuencia de eso. La estructura básica de la sintaxis es:

objeto mensaje.

Y listo!! El punto final es para terminar una linea.

Veamos algunos tipos en smalltalk:

Números: Smalltalk cuenta con una rica variedad de objetos numéricos. Enteros (SmallInteger, LargePositiveInteger y LargeNegativeInteger), Coma flotante (Float), Fracciones (Fraction), Decimales (ScaledDecimal), etc.

Veamos ejemplos:

Enteros
1.
-1.
12345678901234567890.
-12345678901234567890.

Coma flotante
1.1.
-1.1.
12345678901234567890.0.
-12345678901234567890.0.


Los caracteres (Character) pueden instanciarse, también, usando literales.

$a.
$b.
$á.
$1.
$$.

Cadenas de Caracteres: Las cadenas (String) son una secuencia de caracteres.

"Cadena de Caracteres"
'!Hola mundo!'.
'Smalltalk'.
'áéíóú'.
'Un string con una comilla simple ('')'


Símbolos: Los símbolos (Symbol) son cadenas de caracteres (String) usadas por el sistema como nombre de clase, métodos, etc.  Nunca habrá, en todo el sistema, 2 símbolos con los mismos caracteres, eso permite comparaciones muy rápidas.

#unSímbolo.
#'un símbolo con espacios'.

Array: Un Array es una estructura de datos simple que permite acceder a los elementos contenidos indicando la posición con un número. Se pueden crear Arrays de literales con un literal.  El literal para crear un array es una secuencia de literales encerradas entre #( y ).

#(1 2 3 4).
#(1 1.0 $a 'un string' #unSímbolo).
#(#(1) #(2)).

Programando con Smalltalk

Comenzar con Smalltalk no es fácil y menos para personas que venimos de otros entornos.  Antes de meternos de lleno con cosas como la sintaxis, estos son algunos consejos y comentarios que pretenden facilitar el acceso a Smalltalk.

La curva de aprendizaje: es alta al comienzo. Smalltalk tiene una visión diferente de como debiera ser la experiencia con los ordenadores, esa diferencia de concepción hace que los inicios con Smalltalk sean un poco desconcertante para personas que ya tengan experiencia en informática.

Shock cultural: La mayoría de los desentendimientos iniciales tienen que ver con una forma diferente de ver y entender la informática. Smalltalk no es difícil, sólo es diferente.

El código: El código escrito es importante, pero mucho más importante es el conocimiento que vamos obteniendo conforme programamos.  Si aprendemos día a día, probablemente el código viejo no sea bueno.  Tirar código no es malo, lo malo es no aprender a diario.

Trabajo incremental: Un ambiente como Smalltalk es ideal para trabajar de forma incremental.  Los vicios que tenemos, producto del ciclo de desarrollo edición/compilación/prueba, no tienen sentido en Smalltalk y, en cierta forma, tenemos que aprender a programar de otra forma.

Por otro lado el costo de los cambios es mucho más bajo en Smalltalk que en otros lenguajes, eso permite relajarse y demorar las decisiones importantes de diseño hasta que sepamos suficiente del dominio.  No es de extrañarse que las metodologías ágiles hayan sido desarrolladas en Smalltalk.

No hay archivos fuentes: En Smalltalk no hay un archivo con los fuentes y todo, incluso el código, está dentro del ambiente de objetos. Esto no quiere decir que no se pueda mover código entre imágenes de Smalltalk y existen distintas opciones para mover código de un Smalltalk a otro.

Historia del Smalltalk

Smalltalk (no se escribe SmallTalk, ni Small-talk, ni Small-Talk) es un proyecto que lleva más de 30 años de desarrollo. Fue inventado por un grupo de investigadores liderados por Alan Kay, en Xerox PARC (Palo Alto Research Center), durante los años 70s.  El proyecto de investigación produjo varios resultados intermedios que fueron conocidos como Smalltalk/71, Smalltalk/72, Smalltalk/76 y Smalltalk/80.

El Smalltalk usado hoy en día es un descendiente directo del Smalltalk/80 y conserva prácticamente todas sus características.

El proyecto ha generado una cantidad muy grande de invenciones que llegaron a nuestros días.

Por razones que desconozco el proyecto Smalltalk no cuenta con la reputación y la fama que se merece.  Es muy frecuente encontrarse con profesionales de la informática que no saben del proyecto ni de sus aportes. Sin embargo utilizamos a diario varias ideas que fueron desarrolladas en el proyecto Smalltalk.

Computadora Personal: La idea de que cada persona pueda disponer de una computadora de uso personal, con una potencia de cálculo suficiente para ser la herramienta de acceso a la información, tiene sus raíces en las ideas de la Dynabook de Alan Kay.

Interfaces gráficas de usuario: Smalltalk, desde sus inicios, contó con una rica interfaz de usuario gráfica manejada por un ratón.  Las ventanas superpuestas, las barras de desplazamiento, el copiar y pegar, los menús de contexto, etc son todos desarrollos del proyecto Smalltalk que años más tarde Apple ayudó a masificar.

Informática: Son innumerables la cantidad de aportes que el Smalltalk ha hecho a la informática.  Empezando con el paradigma de orientación a objetos y terminando con cosas muy técnicas como la operación BitBlt (http://en.wikipedia.org/wiki/Bit_blit). La lista continua con las metodologías ágiles (http://en.wikipedia.org/wiki/Extreme_Programming), los patrones de diseño (http://en.wikipedia.org/wiki/Design_Patterns), el concepto de entorno de desarrollo, etc.

El proyecto Smalltalk también ayudó a afianzar el uso de los lenguajes dinámicos, los recolectores de basura, el uso de máquinas virtuales, etc.

La lista continua: Unit Testing (http://en.wikipedia.org/wiki/Unit_test), Refactoring y Refactoring Browser (http://en.wikipedia.org/wiki/Refactoring), y un gran etc.

Para entender Smalltalk hay que entender la Programación orientada a Objetos

Smalltalk está definido con un conjunto muy pequeño de conceptos pero son un significado muy específico.  Es fácil confundir los conceptos porque estos son usados, en diferentes lenguajes, con definiciones muy diferentes.

Objetos
Todo en Smalltalk es un objeto.  Un objeto es una parte indistinguible del resto del ambiente, con características y responsabilidades bien demarcadas.

Mensajes
Un mensaje es un requerimiento, que se hace a un objeto determinado, para que este lleve a cabo algunas de sus responsabilidades.

Un mensaje especifica que es lo que se espera del receptor (el objeto que recibe el mensaje) pero no fuerza una determinada forma de resolverlo.  El receptor es el responsable de decidir como se lleva a cabo la operación para responder al mensaje.

Interfaz
El juego de mensajes que un determinado objeto puede entender se denomina su interfaz. La única forma de interactuar con un objeto es a través de su interfaz.

Encapsulación
Se llama encapsulación al hecho que ningún objeto puede acceder a la estructura interna de otro objeto.  Sólo el objeto conoce, y puede manipular, su propia estructura interna.

Ese hecho, sumado a que los mensajes sólo especifican que se espera del receptor pero no especifica como se debe realizar la tarea, aseguran que ningún objeto dependa de la estructura interna de otro.

El envío de mensajes sumado a la encapsulación permiten el desarrollo de sistemas muy modulares ya que cualquier parte puede ser reemplazada por otra mientras la nueva parte respete la interfaz de la parte reemplazada.

Polimorfismo
Dos objetos son polimórficos entre sí cuando un determinado emisor no puede distinguir a uno del otro. Dicho de otra forma: si podemos intercambiar un objeto por otro, en un determinado contexto, es porque son polimórficos.

Clases
Una clase describe la implementación de un conjunto de objetos.  Los objetos individuales, descritos por las clases, se llaman instancias.  La clase describe la estructura interna de los objetos y  describe, también, como se responde a los mensajes.

Variables de Instancia
La estructura interna de los objetos está compuesta por variables de instancia. La variables de instancia son nombres que el objeto puede usar para hacer referencia a otros objetos.

Métodos
Los métodos son la forma de especificar como los objetos de una determinada clase responden a los mensajes. Cada método especifica como se lleva a cabo la operación para responder a un determinado mensaje. Un método puede acceder a la estructura interna del objeto como así también enviar mensajes a si mismo o a otros objetos.  Los métodos especifican, también, cual es la respuesta que el emisor (el objeto que envía el mensaje) recibe.

Todos los objetos de Smalltalk son instancia de alguna clase.  La programación en Smalltalk consiste en crear clases, crear instancias de esas clases y especificar la secuencia de envío de mensajes entre esos objetos.

Herencia
Las clases, en Smalltalk, están organizadas jerárquicamente.  Una clase refina el concepto de otra clase más abstracta.  La clase más abstracta es Object.  Todas las clases son herencias de Object (porque todo es un objeto) o herencia de alguna clase que hereda de Object.

La relación que existe entre la clase más abstracta (la superclase) y la clase más concreta (la subclase) permite clasificar el conocimiento que tengamos del dominio modelado.

Programar es simular
Programar con objetos es programar una simulación.

La metáfora en la programación con objetos está basada en personificar a un objeto físico o conceptual del dominio real en objetos simulados del ambiente.  Tratamos de reencarnar los objetos reales en el ambiente dotándolos de las mismas características y funcionalidades que los objetos reales a los que representan.