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.

Apache Mesos

Recuerdan a Apache Mesos? Se acuerdan lo que escribí hace tiempo que Apache Mesos es un proyecto open source que permite administrar cluster, es decir que es un cluster manager desarrollado por University of California, Berkeley.

Ahhhh reclaro... pero que es un cluster manager? Uno de los retos en el uso de un cluster de ordenadores es el costo de la administración de la misma que a veces puede ser tan alto como el costo de la administración de N máquinas independientes, si el clúster tiene N nodos.

Por esta razón fue creado Apache Mesos. Apache mesos nos aleja de conceptos tales como CPU, memoria, almacenamiento y otros recursos de las máquinas (físicos o virtuales), permitiendo que los sistemas distribuidos de alta disponibilidad sean fácilmente construidos y funcionan con eficacia.

Dejo link: http://mesos.apache.org/

Frege como Haskell pero en la plataforma Java

Siempre me pregunte como no habia un leguaje igual a Haskell pero que corra en la plataforma java y aca esta!! Frege, que si vien no es una copia exacta de Haskell tiene mucha similitud.

Este lenguaje soporta muchas características de haskell, como:

• Typeclasses con polimorfismo
• Pattern matching
• Listas por compresión
• módulos
• Abstracción matemática que nos permite tenes estructuras como functors, monoids, semigroups, y monads.

Veamos un poco de código:

-- file hello.fr
module Hello where  -- moduleName maybe hierarchical as pkgdir.JavaClassname

main args = println $ "Hello world! your arguments are: " ++ show args

En este ejemplo se puede ver un simple hello world. Como ven es mu similar a haskell para tiene una clara influencia de la plataforma java.

Veamos otro ejemplo:

{--
    Este programa muestra la
     hora actual en la salida estándar
     cada dos segundos.
    -}
   
module examples.CommandLineClock where

data Date = native java.util.Date where
    native new :: () -> IO (MutableIO Date)             -- new Date()
    native toString :: Mutable s Date -> ST s String    -- d.toString()

--- 'IO' action to give us the current time as 'String'
current :: IO String
current = do
    d <- Date.new ()  -- reads system timer, hence IO
    d.toString

main args =
    forever do
        current >>= print   -- print formatted date
        print "\r"          -- followed by carriage return
        stdout.flush        -- make sure it's shown
        Thread.sleep 999L   -- wait 0.999 seconds


Este lenguaje fue diseñado por Ingo Wechsung quien nombra este lenguaje Frege por el matemático alemán Gottlob Frege.

Además podemos probarlo de forma online desde esta pagina: http://try.frege-lang.org/

Dejo links:
https://github.com/Frege/frege
https://en.wikipedia.org/wiki/Frege_(programming_language)

Con nosotros Eclipse Che!!

La nube esta de moda y porque no no tener un entorno de desarrollo en la nube y porque no, no tener todo el entorno de desarrollo en la nube. Esto fue lo que penso la gente de eclipse che. Hacer una IDE en la nube.

Esta IDE es totalmente funcional y trae con sigo las ventajas de trabajar en la nube. Desde cualquier browser podemos tirar lineas de código y a la vez el código no esta en una pc o notebook. Por lo tanto tenemos las ventajas de la nube en nuestro desarrollo.

Sin más les presento eclipse che:
http://www.eclipse.org/che/

Prueba Ubuntu desde el browser

Canonical ha puesto en funcionamiento una pagina para probar ubuntu desde browser!! Si bien el objetivo es promocionar el sistema operativo, es una buena oportunidad para acercar a la gente que no lo conoce.

Por lo tanto los que nunca vieron ubuntu funcionando, a probar!!

Dejo link: http://tour.ubuntu.com/en/

LIBROS GRATIS por las próximas 22 horas !!!

Packtpub nos regala una cantidad de libros por las próximas 22 horas!!

Sin más nada que decir, dejo link:
https://www.packtpub.com/packt/offers/free-learning/

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.

Object-Oriented vs. Functional Programming

Java code Geek Regala libros y en este caso regala Object-Oriented vs. Functional Programming un libro por demás interesante.

Dejo link: http://javacodegeeks.us4.list-manage1.com/track/click?u=09cef08fc376e6da2dace7d09&id=478a0dc5c5&e=7224f7969b

http://www.oreilly.com/programming/free/object-oriented-vs-functional-programming.csp

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.

Recursos sobre Pharo, un IDE para programar en Smalltalk

Pharo es una Ide para programar en smalltalk, es muy usada y se puede instalar en linux muy fácilmente.

Para instalarla en linux debes bajarla e instalar unas librerìas 32 bit, si lo se es feo, pero bue. Les dejo el link: http://pharo.org/gnu-linux-installation

Bueno, tambien se puede ejecutar en window o Mac (que nadie es perfecto) http://pharo.org/download

Además pueden obtener muchos recursos de la pagina de Pharo:  http://pharo.org/documentation

Y Aprovecho para dejarles un video de una persona programando en pharo con metodología TDD :

Que es smalltalk? Parte 2

Viene por parte la cosa... Si no leiste la parte 1...

Es muy difícil explicar, a personas que no lo conozcan, que es Smalltalk y porque es tan diferente a otras herramientas más populares.

El origen de ese des-entendimiento viene a razón de que el proyecto Smalltalk estuvo - y sigue estando - regido por una concepción diferente de como debieran usarse las computadoras:

Las computadoras deben ser herramientas que sirvan como amplificadores del espíritu creativo de las personas.

Eso implica, entre otras cosas, que:

• Todo el sistema tiene que ser entendible, y por ende modificable, por una sola persona.
• El sistema tiene que estar construido con un mínimo juego de partes intercambiables.  Cada parte puede ser cambiada sin que el resto del sistema se modifique.
• Todo el sistema tiene que estar construido basado en una metáfora que pueda ser aplicada en todas las partes.
• Cada componente del sistema tiene que poder ser inspeccionado y cambiado.

Smalltalk es un ambiente de objetos. Los objetos interactúan enviándose mensajes entre si.

Smalltalk incluye un lenguaje de programación y este fue desarrollado usando los principios que ya se enumeraron.  Esto quiere decir, por ejemplo, que el lenguaje Smalltalk puede ser cambiado - como cualquier otra parte - y reemplazado por otro; o que pueden convivir diferentes lenguajes de programación en el mismo ambientes, etc.

Un ambiente de Smalltalk típico también incluye muchas herramientas que asisten en la tarea de programación. Pero estas, como todo, también pueden ser modificadas o reemplazadas por otras.

A su vez, un ambiente de Smalltalk, incluye objetos para crear interfaces de usuarios gráficas.  Todo escrito en Smalltalk, todo a la vista y todo modificable.

Centrándonos en el punto de vista de meros programadores mortales, podemos decir que Smalltalk:

• Incluye un lenguaje de programación.
• Incluye una librería de clases
• Incluye un entorno de desarrollo

Tanto el lenguaje, como la librería de clases y el entorno de desarrollo llevan más de 30 años de uso y depuración.  No en vano Smalltalk ha sido la referencia para el desarrollo de lenguajes y entornos de desarrollo.