viernes, julio 29, 2005

La magia del Smalltalk: Capítulo 4 - ¿Qué es el compilador? ¡Un objeto!

¿Recuerdan que dijimos, al menos unas 278 veces, que en Smalltalk todo es un objeto?

Eso nos vale para contestar a casi cualquier pregunta: ¿Qué es la paz? ¿Qué es el amor? ¿Qué es Dios? ¿Qué es la nada? ¡Todos son objetos! :-)

No puedo decir nada sobre la paz, el amor, Dios o la nada así que mejor hablo de un tipo de objeto que conozco un poco mejor: Compiler.

El compilador de Smalltalk está escrito en Smalltalk. Además de los clásicos problemas de bootstrapping de los lenguajes escritos en si mismo, esto permite un gran poder dentro del ambiente.

Se pueden hacer desde cosas muy simples como evaluar código Smalltalk y procesar el resultado:

Compiler evaluate: '5 factorial'

A cosas un poco más bonitas como especializar el compilador para determinadas clases del ambiente. Veamos un ejemplo: Supongamos que queremos hacer un Prolog dentro de nuestro Smalltalk. Podríamos escribir un compilador específico para la sintaxis de Prolog y decirle al Smalltalk que determinadas clases (las herencias de una clase en particular) usen otro compilador y no el default.

Para eso simplemente (¿?) tenemos que escribir el compilador de Prolog, y en la clase que servirá de superclase para las cosas en Prolog, especificamos nuestro compilador:

Prolog>>compilerClass
"Answer a compiler class appropriate for source methods of this class."
^ PrologCompiler


Les dejo un paper muy bueno que habla del compilador de Smalltalk (en Squeak y VisualWorks): The Hitch Hiker's Guide to the Smalltalk Compiler

¡A jugar con el compilador!

La magia del Smalltalk: Capítulo 3 - ¿Cuanto? ¿Facto qué?

¿Tienen una idea del pedazo de número que es el factorial de 1000?

Uhhh, perdón... Primero lo primero: ¿Tienen una idea que es el factorial? :-)

Rápidamente les recuerdo que el factorial de un número N

n! = 1 × 2 × 3 × ... × (n-1) × n

El factorial de 0, por convención, es 1. El factorial de 1 es 1, el factorial de 2 es 1x2, el factorial de 3 es 1x2x3, el factorial de 4 es 1x2x3x4, etc.

Ahora pensemos un segundo: ¿Cuanto será el factorial de 1000? Es un número monstruoso de grande. Usemos nuestro Smalltalk para experimentar un poco.

1000 factorial.

El factorial de 1000 es, según mi squeak:

402387260077093773543702433923003985719374864210714632543799910429938
512398629020592044208486969404800479988610197196058631666872994808558
901323829669944590997424504087073759918823627727188732519779505950995
276120874975462497043601418278094646496291056393887437886487337119181
045825783647849977012476632889835955735432513185323958463075557409114
262417474349347553428646576611667797396668820291207379143853719588249
808126867838374559731746136085379534524221586593201928090878297308431
392844403281231558611036976801357304216168747609675871348312025478589
320767169132448426236131412508780208000261683151027341827977704784635
868170164365024153691398281264810213092761244896359928705114964975419
909342221566832572080821333186116811553615836546984046708975602900950
537616475847728421889679646244945160765353408198901385442487984959953
319101723355556602139450399736280750137837615307127761926849034352625
200015888535147331611702103968175921510907788019393178114194545257223
865541461062892187960223838971476088506276862967146674697562911234082
439208160153780889893964518263243671616762179168909779911903754031274
622289988005195444414282012187361745992642956581746628302955570299024
324153181617210465832036786906117260158783520751516284225540265170483
304226143974286933061690897968482590125458327168226458066526769958652
682272807075781391858178889652208164348344825993266043367660176999612
831860788386150279465955131156552036093988180612138558600301435694527
224206344631797460594682573103790084024432438465657245014402821885252
470935190620929023136493273497565513958720559654228749774011413346962
715422845862377387538230483865688976461927383814900140767310446640259
899490222221765904339901886018566526485061799702356193897017860040811
889729918311021171229845901641921068884387121855646124960798722908519
296819372388642614839657382291123125024186649353143970137428531926649
875337218940694281434118520158014123344828015051399694290153483077644
569099073152433278288269864602789864321139083506217095002597389863554
277196742822248757586765752344220207573630569498825087968928162753848
863396909959826280956121450994871701244516461260379029309120889086942
028510640182154399457156805941872748998094254742173582401063677404595
741785160829230135358081840096996372524230560855903700624271243416909
004153690105933983835777939410970027753472000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000000000000
000000000000000

Ufff... voy a tener que confiar en Squeak y creerle que ese número es el resultado. Para validar un poco la respuesta, voy a usar algo del poco conocimiento que me dio la escuela secundaria, y voy a usar la propiedad de los factoriales que dice que:

N! / (N-1)! = N

Entonces evaluamos en Smalltalk:

1000 factorial / 999 factorial.

Y con un poquito de suerte nos debería contestar 1000.

Volviendo al número monstruoso anterior: creo que no hace falta aclarar que ese número no cabe en un entero ni de 16, ni de 32, ni de 64 bits. Para el manejo de enteros tenemos 3 clases:

SmallInteger: para enteros que entren en 31 bits.
LargePositiveInteger: para enteros positivos que no entren en 30 bits.
LargeNegativeInteger: como la anterior, pero para negativos.

Todas tienen como superclase a Integer, que es la clase abstracta para todas las implementaciones de enteros. Justamente en Integer es donde encontramos la implementación de #factorial. Es decir: el algoritmo para calcular factoriales de número chicos, o de número grandes, es el mismo.


Algunos ejercicios más con factoriales:


¿Cuántos dígitos tiene el factorial de 1000?

1000 factorial asString size -> 2568


¿Cuánto tiempo tarda mi Squeak en calcular el factorial de 1000?

Time millisecondsToRun: [1000 factorial] -> 12


Sí, es verdad, el factorial de 1000 tarda en calcular 12 milisegundos en mi máquina... Si no lo creen, prueben ustedes mismos.

¿Cuánto tiempo tarda en calcular el factorial de 1000 el lenguaje de programación que están usando?

Squeak de Small-Land versión 3.8 - Instalador para Windows

Germán Arduino acaba de anunciar, en la lista de correo de Small-Land, la liberación del instalador para el sistema operativo del lado oscuro (es decir, Windows).

Pide ayuda para hacer pruebas de instalación en diferentes entornos.

Pueden ver un screenshot del instalador y bajarlo desde: http://swiki.agro.uba.ar/small_land/7

miércoles, julio 27, 2005

La magia del Smalltalk: Capítulo 2 - ¿IDE? no gracias

Es muy difícil mostrar las diferencias que tiene Smalltalk con los lenguajes de programación “tradicionales”.

Una de las cosas que cuesta trabajo ver es la diferencia que implica el hecho que Smalltalk sea un ambiente. Un ambiente de Smalltalk no es un nuevo tipo de IDE (Integrated Development Environment). En Smalltalk los objetos sobreviven al hecho de salir del Smalltalk. Todos los objetos que tengamos instanciados son grabados, en el estado exacto que están, al disco rígido en el momento de grabar la imagen (se llama imagen porque queda en el disco una imagen de la memoria de la máquina).

Este hecho nos expone a ciertas características que ni soñamos cuando usamos lenguajes con el clásico ciclo de desarrollo: vi/emacs > compilar > ejecutar el código > depurar > vi/emacs. Los nuevos IDEs (como el Eclipse) disimulan ese ciclo, pero no lo mejoran.

La diferencia fundamental es que, en Smalltalk, los objetos están siempre “vivos”, y no mueren cuando uno tiene que escribir código. Este implica, entre otras cosas, que los objetos sobreviven a los cambios en las clases.

Una de las primeras cosas que suelo mostrar cuando explico Smalltalk es lo siguiente:

  • Creo una clase vacía, sin nada.
  • Instancio un objeto de esa clase y lo inspecciono.
  • Con el inspector a la vista, sin cerrarlo, modifico la estructura de la clase (por ejemplo agregando una variable de instancia).
  • Ahora el inspector muestra la instancia actualizada a la nueva forma de la clase.


Este simple ejercicio muestra una característica fundamental de la programación con Smalltalk. Ahora imaginemos que salimos (grabando) del Squeak después del segundo paso, que nos vamos de vacaciones por 15 días, y que abrimos el Squeak y hacemos los otros 2 pasos.... ¿Qué es lo que ocurre? Nada. Sólo ocurrió que nuestro objeto (la única instancia de Customer) se "durmió" una siesta de 15 días esperando hasta que lo despertemos (¡Al mejor estilo de Walt Disney!).

De hecho, en cualquier Squeak actual, hay objetos que llevan casi 30 años instanciados (desde el Smalltalk/76).

PDFs sobre Squeak en Castellano

Con esta complicada búsqueda en google podemos ver todos los PDFs, en Castellano que hablen de Squeak.

Especialmente les recomiendo: http://dewey.uab.es/pmarques/pdigital/simo/adriana.pdf

¿Quién dijo que no hay material sobre Squeak?

¡A leer!

viernes, julio 22, 2005

La magia del Smalltalk: Capítulo 1 - ¡No entiendo nada!

Creo que ya habrá quedado claro (del Capítulo 0) que en Smalltalk todo es un objeto, y que toda la computación se realiza enviando mensajes a los objetos.

Pero, ¿qué sucede cuando le enviamos un mensaje a un objeto?.

Lo que ocurre es que la máquina virtual busca algún método que pueda activar para resolver el mensaje. La búsqueda empieza por la clase del objeto receptor (o la instancia misma, dependiendo del sabor de Smalltalk) y, de no encontrar un método, continua buscando hasta la clase "root" que suele ser Object (o ProtoObject en Smalltalk más modernos).

Hasta ahora no es muy diferente a lo que ocurre en los lenguajes "tradicionales" orientados a objetos (como Java, C++, C#, etc).

¿Qué ocurre cuando no hay un método que sirva para resolver el envío del mensaje? Ocurre que la máquina virtual activa el método #doesNotUnderstand: que, al estar implementado en Object (o en ProtoObject), está siempre disponible para ser evaluado con un objeto de clase Message como parámetro.

En el objeto de clase Message podemos saber el nombre y los parámetros del mensaje original.

El comentario en Object>>doesNotUnderstand: dice:

"Handle the fact that there was an attempt to send the given message to the receiver but the receiver does not understand this message (typically sent from the machine when a message is sent to the receiver and no method is defined for that selector)"

Veamos un ejemplo. Imaginemos un objeto de clase ClaseMágica que tiene implementado el método #doesNotUnderstand: de la siguiente forma:
ClaseMágica>>doesNotUnderstand: aMessage
"The answer is 42"
^ 42

Eso hará que cualquier mensaje enviado a las instancias de ClaseMágica (y subclases) respondan siempre 42 como resultado.

El ejemplo anterior es muy simple y no es demasiado útil (al menos que creamos que la respuesta para todo es 42), pero miremos un ejemplo un poquito más útil:
  • Creamos una clase de nombre Proxy que tenga una variable de instancia llamada target.
  • Creamos un constructor y un método de inicialización para definir cual es el target de nuestro Proxy.
  • Ahora implementamos #doesNotUnderstand: de esta forma:
 Proxy>>doesNotUnderstand: aMessage 
"delegate the message to the receiver's target"
Transcript show: target asString , ' is going to receive the message ' , aMessage asString; cr.
    ^ target
perform: aMessage selector
withArguments: aMessage arguments
  
Lo interesante de este ejemplo es que instancias de clase Proxy pueden hacer de proxy (valga la redundancia) a objetos de cualquier clase. En lenguajes de "early binding" (como el Java, C++, C#, etc) habría que crear una clase de Proxy para cada clase de objeto que queramos envolver y mantenerlas sincronizadas.

Otro ejemplo de uso de DNU (#doesNotUndestand:) lo pueden encontrar en mi paquete de ODBC para Squeak, específicamente en la clase ODBCRow. Este truco permite que las filas de una consulta SQL respondan a mensajes con el nombre de las columnas que genera la consulta, es decir: Si se ejecuta una consulta SQL tipo SELECT firstName, lastName FROM Customer, las filas sabrán responder a los mensajes #firstName y #lastName.

También usé este truco en el paquete rST (Remote Smalltalk) para los proxies que delegan los mensajes desde un Smalltalk a otro.

Si se quedaron con ganas de ver más, miren las clases ObjectTracer y ObjectViewer en sus respectivos Squeak.

miércoles, julio 20, 2005

La magia del Smalltalk: Capítulo 0

Voy a probar suerte con una serie de artículo que cuenten las cosas que me sorprendieron de Smalltalk cuando empecé a aprenderlo. Esto NO pretende ser un curso de Smalltalk ni mucho menos, sólo pretendo divertirme un poco mostrando las cosas "raras", "locas" o "esotéricas" del Smalltalk.

Esta serie de artículos podría bien llamarse: "Pruebe esto en su lenguaje de preferencia".

Como este es el capítulo 0, no esperen gran cosa... es sólo el "concept" ;-)


Al ruedo:

Objeto/Mensaje:

Lo primero, y más importante, es que en Smalltalk todo es un objeto y toda la computación se hace enviando mensajes a los objetos. Cuando digo "todo" no me refiero a ese "todo, pero..." al que estamos acostumbrados los programadores.

Para dejarme de tanto rollo, voy a dar ejemplos concretos de cosas que son Objeto/Mensaje en Smalltalk y que no suelen serlo en los lenguajes llamados "Orientados a Objetos". Las clases, el true, el false, el nil, el compilador, los métodos, el debuger, los contextos de activación de los métodos, los números, los arrays, etc.



El comportamiento (aka el "código") es un Objeto.

Como decía antes, todo es un objeto. Por ejemplo: el comportamiento (mal llamado "código") también es un objeto. Tenemos 2 tipos de comportamiento: Los métodos y los bloques. Los métodos son objetos que la clases tienen (claro, también las clases son objetos). Los bloques son comportamiento creados con un literal que el compilador conoce: los corchetes. Sentencias Smalltalk encerradas entre corchetes se convierten en un objeto de clase BlockContext. ¿Para que sirve eso?, sirve para lo que sirven todos los objetos: para enviarles mensajes. A los objetos Bloque se les puede enviar el mensaje #value que lo activará ejecutando el comportamiento que contenga.



¿Estructuras de control? - No, gracias.

1 > 3 ifTrue: [ Transcript show: 'Verdadero, che!!!!' ]

Pues sí, adivinaste... las llamadas "estructuras de control" de los lenguajes tradicionales, que suelen ocupar apartados especiales en los libros, no son más que mensajes en Smalltalk. Se puede aprender mucho viendo la implementación en las clases Boolean, True y False de los métodos #ifTrue:, #ifFalse:, #ifTrue:ifFalse:, #ifFalse:ifTrue:, etc.


[ unStream atEnd ] whileFalse: [ Transcript show: unStream next asString; cr ]

Para ver un poco estos mensajes, ver la implementación de #whileTrue, #whileFalse, #whileTrue:, #whileFalse:, etc en la clase BlockContext (la clase de los bloques de código).



¿Bucles? - No, gracias.

Una de las razones principales para usar bucles en los lenguajes tradicionales es para procesar colecciones. Distintos lenguajes usan diferentes idioms para iterar colecciones... tenemos desde cosas muy básicas como un FOR desde 1 al tamaño del Array hasta cosas un poco menos primitivas como los Iteradores de Java o de la STL de C++.

¿Cómo se procesa una colección en Smalltalk? Pues sí, adivinaste de nuevo... con un mensaje. En este caso el mensaje es #do:.

unaColeccion do: [:each | Transcript show: each asString; cr ]

La colección recibe el mensaje #do: con un bloque como parámetro y es responsable de evaluar dicho bloque por cada elemento que contenga. Lo más importante en este ejemplo es que nosotros no tenemos ni la más mínima idea de que tipo de colección es unaColeccion, pero no lo necesitamos saber ya que ella sabrá cual es la mejor forma de iterarse a si misma.

El idiom de #do: no termina con las colecciones, sino que cualquier cosa que se pueda recorrer lo podremos hacer con #do:. Por ejemplo: Los Streams, de esa forma reescribimos el ejemplo anterior de unStream:

unStream do: [:each | Transcript show: each asString; cr ]

Como verán, para iterar una colección o un stream usamos el mismo mensaje... es decir que podemos intercambiar, en cualquier momento, una colección por un stream... o una colección por otro tipo de colección... o una colección por cualquier objeto que sepa responder a #do:.


FINAL DEL CAPÍTULO 0.


Les prometo que los próximos artículos serán más entretenidos.

jueves, julio 14, 2005

GPS en Squeak

En los últimos días estuve trabajando en un proyecto de los que más me gusta hacer: Conectar dispositivos a Squeak. Tengo a medio hacer el manejo y programación de robots Lego Mindstorms, y terminé hace un tiempo el soporte para dispositivos de vídeo desde Squeak (como el fabuloso microscopio de Intel).

Pueden ver algo de información, como así también bajarse una versión preliminar, desde el Swiki de Squeak.

Así se ve el GPS morf cuando está conectado:



Y así cuando está desconectado:


Y este es el vocabulario para hacer guiones de eToys usando la información que nos brinda el GPS:



Ahora ya tienen la excusa que necesitaban para comprarse un GPS.

¡Qué lo disfruten!

jueves, julio 07, 2005

¡Basta ya de reggaeton!

¿Existe música más fea que el reggaeton?

Espero que esta moda se pase pronto, y que la próxima moda no sea peor que esta. Por lo pronto, no me siento tan solo... miren cuantas personas en google opinan lo mismo.

lunes, julio 04, 2005

Documental sobre Squeak en Extremadura en Inglés

Mientras subimos la imagen ISO del documental en Español e Inglés, también con subtítulos en Español e Inglés, pueden ir descargando versiones de menor calidad (y menor tamaño).

Los archivos torrent están en:
y los archivos, para descargas directas (¡OJO CON EL TAMAÑO!), en:

Más tutoriales de Squeak

En la página de Squeak del CPR de Mérida, me encontré con unas traducciones hechas por Máximo Prudencio de unos tutoriales de Squeak.

La enseñanza en el siglo XXI

Googleando me encontré con otro blog sobre Squeak en Castellano.

En el post de inauguración, los autores nos dicen:

Este blog será testigo del trabajo de investigación y práctica que hacemos en la enseñanza apuntando a una propuesta coherente con la sociedad contemporánea que vivimos.

No duden en visitarlo en:

viernes, julio 01, 2005

Squeak, también, en Francés

También hemos incluido la traducción al Francés.

Con esta incorporación el Squeak de Small-Land está disponible en 6 idiomas: Catalán, Alemán, Inglés, Español, Francés y Gallego.

Squeak en Catalán y Gallego

Hemos subido las traducciones incompletas[*] al Catalán y al Gallego del Squeak versión 3.8.

[*] Son las traducciones de la versión anterior convertidas a la versión nueva y no incluyen las traducciones de las frases nuevas.

Para actualizar el Squeak hay que seleccionar la opción actualizar desde un servidor desde el menú Configuración.

Herramientas para el siglo XXI

Hemos llegado al siglo XXI.

El tan esperado nuevo milenio esta entre nosotros y algunas de nuestras fantasías y sueños con respecto al cambio de milenio han sido satisfechas. Pero otros tantos sueños quedaron solo en el imaginario colectivo o como parte de alguna novela de ciencia ficción. Sin temor a equivocarme me atrevo a decir que las computadoras representaron como ninguna otra cosa las ideas de un mundo nuevo y distinto.

Lo cierto es que hoy tenemos un gran poder de computo en nuestros escritorios (¡e incluso en nuestros bolsillos!) pero, lamentablemente, ese poder no esta aprovechado tan bien como se podría y como hemos soñado por años.

Durante mucho tiempo estos sueños se veían desvanecidos cuando se intentaban materializar con el equipo con que contábamos. Sin embargo, en los últimos años, la ecuación cambió dramáticamente y el poder del hardware de hoy posibilita nuevas características que el software del siglo XXI (con excepción de los juegos) no sabe/puede aprovechar.

Seguimos utilizando software que fue pensado en épocas donde el hardware tenía una potencia hoy superada por cualquier dispositivo electrónico.

Paradójicamente el hardware de hoy solo se usa pasa correr malas implementaciones de buenas viejas ideas. Los interfases gráficas de usuario son, quizás, el mejor ejemplo. Estas fueron inventadas en los años 70s, cuando el hardware que existía no era capas de ser soporte de esas ideas. Ahora, más de 30 años después, nos encontramos que el hardware podría soportar ideas mucho más revolucionarias que podrían hacer que millones de personas puedan participar de la revolución de la información.

La mayoría de los recursos informáticos con los que contamos hoy en día no son capaces de expandir la capacidad creativa en cada uno de nosotros. Y ya no es culpa del hardware. Hoy el hardware está a la altura de las necesidades, lo que necesitamos es mejor software, que este esté disponible para cualquiera y que pueda ser usado por cualquiera.

El movimiento open-source está resolviendo parte del problema, está haciendo que todos tengan acceso a programas que antes eran simplemente prohibitivos por el precio. Sin embargo hay una parte que no se pudo resolver todavía: Hacer que estas piezas de software sean verdaderas herramientas amplificadoras de la capacidad creativa de cada uno de nosotros para que seamos constructores de nuestro propio conocimiento.

El reto esta vigente y el camino no esta libre de obstáculos. El mercado de la computación ha crecido mucho en los últimos años y no lo ha hecho de una forma en que los beneficios puedan ser accedidos por todos. Este desarrollo ha producido algunos problemas.

Uno de estos problemas es el respeto en exceso (que algunas veces se manifiesta como miedo) que las computadoras generan en la gente. Pareciera que tenemos que estar nosotros al servicio de los caprichos de las máquinas, adaptarnos a sus maneras, esperar por sus tiempos y, sobre todo, reducir nuestras expectativas de lo que puede hacerse con ellas. Las computadoras fueron siempre potestad de gente muy "inteligente" que podía entenderlas y se destinaron habitaciones especiales para alojarlas donde no podía entrar cualquiera.

Esa barrera sigue presente hoy en día pero de una forma mucho menos evidente pero igual o peor de dañina, las computadoras son complejas de usar y se culpa a los usuarios por no entenderlas. Si no entendemos como usar una computadora, nos quieren hacer creer, es porque no somos lo suficientemente inteligente para eso.
  • ¿No será que la gente tan "inteligente" como para usar las computadoras no lo son tanto y que no supieron hacer de estas algo al alcance de todos?
  • ¿No será que alguien gana dinero prometiendo soluciones a los problemas que las computadoras generan hoy en día?
  • ¿No nos venden cada versión nueva del producto diciendo que ahora, por fin, será fácil de usar?
Otro de los problemas con que nos enfrentamos es como el uso comercial de las computadoras ha dominado prácticamente su desarrollo en los últimos años y eso produjo una falsa linea divisoria muy marcada entre diversión y cosas llamadas serias.

Por un lado tenemos la industria de los juegos que producen verdaderos ejemplos de innovación y donde siempre se está en el límite de lo que el hardware puede dar. Por el otro tenemos las aplicaciones "serias que se usan para trabajar.

Ese concepto, lamentablemente muy arraigado, de que el trabajo va por un lado y la diversión por otro nos inundó de grises interfases de usuario y grillas de datos inertes y nos priva de la libertad de ser creativos. Se nos dice que todo es fácil de hacer si usamos alguna herramienta que nos guia paso a paso y se penaliza el querer ser distinto y original.

Usted puede tener el auto en cualquier color siempre que este sea negro -- (Henry Ford)

Por suerte hay gente que si cree que las computadoras deberían estar al servicio del espíritu creativo de cada uno de nosotros y trabaja muy fuerte para conseguirlo. No hay mejor exponente de esta clase de personas que el propio Alan Kay

Alan Kay es el inventor de la mayoría de las cosas útiles relacionadas con la computadora personal, incluyendo su nombre -- (Papert)

Sus ideas y su trabajo sobre ellas tuvieron un gran impacto sobre la forma en que nos relacionamos con la tecnología. Solo como un ejemplo del resultado de su trabajo podemos citar a las interfases gráficas de usuario, el uso del ratón, las ventanas, etc que fue invención suya allá por los años 70s.

Su visión de la Dynabook sigue actual y viva en Squeak.

El Squeak es un entorno/lenguaje/herramienta/ambiente donde conviven todos los medios de expresión conocidos y sirve de soporte para la investigación sobre los nuevos medios. Sus capacidades multimediales y su capacidad de simulación lo convierten en la mejor aproximación a la visión original de la Dynabook.

El Squeak no es para nada algo terminado (¿muerto?) sino que es un lugar donde nuestras ideas se plasman. Como parte de nuestro proceso sin fin de construcción de conocimiento el mismo Squeak va creciendo y cambiando. Gracias a Internet es posible que esas mejoras que producimos en nuestro Squeak sean compartidas para que otras personas con los mismos intereses se beneficien de ellas y, fundamentalmente, aprendan y se diviertan mientras lo hacen.

Tenemos la responsabilidad de trabajar para que la tecnología no siga siendo potestad de unos pocos elegidos sino que sea el motor de la verdadera revolución de la información: Lograr que todas las personas puedan ser actores activos de su propio desarrollo.