Smalltalk tutorial on IRC

Last week at #emacs-es on Freenode I did a very-short-and-introductory-hands-on-workshop on smalltalk. Just in case you know spanish, here's the log, with names removed to protect the guilty.

	<rgrau> holas
	<rgrau> user1: no se si estabas cuando lo comente, que el modo de interaccion guay con smalltalk esta superverde, y aun no da para un tuto, ni nada
	<rgrau> si quereis, lo que podemos hacer es algo intermedio: hacemos el tutorialillo de smalltalk en el entorno smalltalk
	<rgrau> y si os mola, le metemos mano al modo
	<user1> claro, lo que tu veas :)
	<user1> pero cuando?
	<rgrau> cuando querais
	<rgrau> esto si que se puede hacer en un ratito
	<rgrau> en cualquier momento
	<user1> yo suelo tener tiempo, asi que cuando user3 diga :)
	<rgrau> user1: has visto lo ultimo de technomancy? una forma de instalar slime+clojure+lein en un momento
	<rgrau> 2 comandos
	<rgrau> y funcionando
	<rgrau> me gustaria aprender algun fw web de clojure
	<user1> ni idea
	<rgrau> http://technomancy.us/149
	<user1> pero clojure..
	<user1> soy muy reacio
	<rgrau> por?
	<user1> por ir sobre java
	<rgrau> pfff, ya... pero al nivel del programador, tanto se debe notar?
	<rgrau> esque parece el lisp moderno al k se tiende
	<user1> no es que se note,
	<user1> para hacer tus cosas, puede funcionar
	<user1> pero es una dependencia que yo preferiria no asumir
	<user1> te imaginas proyectos tipo GNUPDF sobre algo asi?
	<rgrau> ah, ya
	<user1> no se, es algo que no me deja tranquilo
	<user1> evidentemente, en el curro o algo asi, yo lo usaria antes que java, para eso mola
	<rgrau> yo me referia algo para currar
	<user1> pero no es algo que me molestaria mucho en difundir para ser
	<user1> el nuevo python o algo asi
	<user1> que es lo qe parecen pretender
	<user1> por cierto rgrau
	<user1> hoy envie los papeles de erasmus a irlanda ya
	<rgrau> aha
	<user1> ya cuando respondan sabre seguro si voy o no
	<user1> bueno, yo me animo tambien a cuando querais dar la charla de slime
	<user1> o taller, mejor dicho
	<user3> Ya estoy
	<user3> hola :)
	<user3> Pues eso que surgió la idea de dar unas mini charlas aquí, y decian rgrau y user1 que a lo mejor te interesaba escucharlas, y aportar con todo lo que sabes.
	<user2> bien
	<user3> a ver si ellos te comentan
	<user2> user1: ya me ha comentado alog ..
	<user2> algo
	<user2> aunque no mucho
	<user3> ahh
	<user2> user6: cocinillas ...
	<user3> Y el viaje que tal
	<user2> bien, algo cansado, ahora en uk amanece muy temprano
	<user3> ah, que estas en UK!
	<user2> ahora ya no, he estado esta semana pasada en UK
	<user2> ya estoy en casa
	<user3> ahm
	<user1> nas :)
	<user1> eso, rgrau propone contarnos algo de smalltalk, yo puedo contar algo de slime
	<rgrau> hey, buenas
	<user2> yo quiro smalltalk en el ipad
	<user2> quiero*
	<rgrau> jej
	<rgrau> pues la idea era presentar un modo de smalltalk para emacs, pero el que hay para gnu-emacs esta muy verde, y hay un tipo k esta haciendo uno, que pinta bien, pero hace una semana escasa k lo empezo
	<rgrau> y hemos dicho de presentar smalltalk, asi a la brava
	<rgrau> y ya veremos que hacemos
	<rgrau> smalltalk es interesante cuanto menos
	<user1> claro :) si lo haces en plan taller, dejando tiempo para probar cosas, genial :D
	<user3> Pues ponemos un día que podamos
	<user3> nos dices el software necesario o instalamos sobre la marcha =)
	<user1> yo cuanto antes mejor, que si no me meto en los examenes
	<rgrau> hoy a las 23?
	<rgrau> :D
	<user3> Por mi si. Cualquier dia es bueno. Asi paro un pco =)
	<user1> venga
	<user1> :D
	<rgrau> ouyeah
	<rgrau> ah, los que useis ratpoison, teneis algun otro wm porahi?
	<user2> pharo ?
	<rgrau> pharo (la implementacion que usaremos) no se lleva nada bien con ratpoison
	<rgrau> oui
	<rgrau> http://www.pharo-project.org/home
	<rgrau> ostias, han sacao la 1.2.1
	<user2> jejeje
	<user3> rgrau, de los atilados, durante un tiempo usé wmii, stumpwm, y awesome
	<user1> yo estoy tirando de gnome jaja
	<rgrau> creo que rp es el unico que no se lleva bien. stump ok, musca ok, awesome creo k tb
	<user1> es que como no porgramo ultimamente..
	<user1> rgrau: esta en debian?
	<rgrau> creo que no, pero no hay problema, hay un descargable (one click image)
	<rgrau> que es cosa de unzipear y esta autocontenida
	<rgrau> pues tios, voy a hacerme algo de comida, y luego miramos algo de eso ,aunque sea solo entorno y tal
	<rgrau> va bien chicos?
	<user1> si, yo voy a instalarlo ya
	<user1> asi adelanto
	<user1> hasta luego
	<user1> 23 aqui
	<rgrau> yep
	<rgrau> si veis a alguien k entra, se lo comentais
	<user2> http://astares.blogspot.com/2011/05/squeak-forks.html
	<rgrau> ostia, openqwak
	<rgrau> aun no lo he probao
	<user1> me recuerda a factor el entorno
	<user1> (por las screenshots)
	<user1> rgrau: crees que es dificil implementar smalltalk? algo de juguete quiero decir
	<user1> no hace falta compatibilidad, solo la idea
	<rgrau> bueno, la gracia de smalltalk es el sistema de objetos
	<rgrau> clases metaclases
	<rgrau> y todo esto
	<rgrau> la sintaxis no es dificil, pero el bootstrap no tengo claro como se haria
	<rgrau> el lenguaje en si , es muy sencillo
	<user3> rgrau: Descargando faro, es lo que hace falta¿?
	<rgrau> sips
	<user1> user3: ni instalacion, es standalone
	<rgrau> la one-click imaga
	<rgrau> image es la buena
	<rgrau> (para nosotros)
	<rgrau> bueno, reboto a ubuntu
	<rgrau> hasta ahora
	<user3> Pharo installed :)
	<rgrau> ouyeah
	<rgrau> por mi le damos candela ya mismo
	<rgrau> sino esperamos, no hay problema
	<user3> Esperamos que vuelva user1
	<rgrau> sisi
	<user1> buenas
	<user1> rgrau, user3: estais ya?
	<user3> si
	<user1> cuando veais empezamos
	<rgrau> yep
	<rgrau> user4: y paco?
	<user3> lo he avisado, por si se apunta
	<rgrau> holas user5. user5 emacseros, emacseros user5 :)
	<user3> M-x Bienvenido user5
	<rgrau> bueno, pues vamos palla, no?
	<user3> Pacolinux viene
	<rgrau> aha
	<rgrau> ok. esperamos
	<user5> Buenas rgrau, user3
	<user3> Pues, cuando quieras rgrau
	<rgrau> oks. pues vamos palla
	<rgrau> oks, usaremos pharo
	<rgrau> 1.2.1, que veo que es la ultima
	<rgrau> (paco ya se apuntara)
	<rgrau> os cuento un poquito de historia sobre todo el tema
	<rgrau> smalltalk es el 1r lenguaje oop orientado a clases.
	<user3> Le guardamos log
	<rgrau> antes de st, los mismos del XEROX PARC, crearon self, que es un lenguaje oop con prototipos
	<rgrau> no lo he catado, pero creo que no era oop puro
	<rgrau> entonces smalltalk fue lo que revoluciono la escena
	<rgrau> oops tel
	<rgrau> back
	<user5> wb
	<user3> :)
	<rgrau_> joer
	<rgrau_> me cai
	<user1> :D
	<rgrau_> estoy live?
	<rgrau_> bien
	<rgrau_> pues eso, que esos mamaron de las lisp machines, donde todo esta vivo
	<rgrau_> y smalltalk es un lenguaje + el entorno, que esta hecho en el mismo lenguaje
	<rgrau_> es como elisp y emacs
	<rgrau`> arrancamos pues pharo
	<rgrau_> pharo.sh
	<rgrau`> y se ve un escritorio
	<rgrau`> verdad?
	<user3> si, con una ventana de bienvenida
	<rgrau`> sip. una de las novedades de smalltalk era la gui. fue de los primeros sistemas con ventanas solapables, entorno grafico y uso intensivo del raton
	<rgrau`> (cosas que en este canal, no nos hacen mucha gracia necesariamente, :p )
	<user1> ( cuando preguntas, por defecto digo que si :P os sigo, pero para no interrumpir mucho )
	<rgrau`> (oks)
	<rgrau`> abrimos un workspace
	<rgrau`> clicando en el fondo de pantalla
	<rgrau`> y workspace
	<rgrau`> esto es un buffer donde probar cachitos de codigo, o interactuar con el sistema
	<user1> yep, como un *scratch* :)
	<rgrau`> de hecho, cualquier sitio donde puedas meter texto, sirve para interactuar con el sistema, pero los WS son para ello
	<rgrau`> exacto
	<user3> Un interprete
	<rgrau`> la cosa es que todo el sistema esta interpretando continuamente
	<rgrau`> probamos, por ejemplo de meter 4 + 3
	<rgrau`> seleccionamos con el raton, boton derecho,
	<rgrau`> y vemos varias opciones
	<rgrau`> do it, que ejecutara la operacion, pero no habra feedback, pq no es nada del tipo Window open
	<rgrau`> sino k retornara 7 y punto
	<rgrau`> osea, print it es lo ke tenemos k hacer
	<user1> hm, que pongo entonces exactamente?
	<user1> 4 + 3
	<user1> print it
	<user1> ?
	<rgrau`> seleccionar , boton derecho y darle al print it
	<user3> 4 +3, seleccionar con el ratón
	<user1> ah vale!
	<rgrau`> ahora vamos a mirar algo de lenguaje
	<user1> una pregunta :) en el menu, al lado de cada accion aparece una tecla
	<rgrau`> sips
	<user1> supongo que es para atajo del teclado, como lo invoco?
	<rgrau`> alt-tecla
	<user1> bien :)
	<rgrau`> o control-tecla
	<rgrau`> no me acuerdo bien
	<rgrau`> i alt-p hace el print de la linea
	<user1> ambos parece
	<rgrau`> te ahorras seleccionar
	<rgrau`> ok. en smalltalk, todo lo que veis ahi son objetos
	<rgrau`> todo significa TODO TODO
	<rgrau`> la ventana, el parser el compilador, los pixeles
	<rgrau`> ....
	<rgrau`> y estan vivos, y accessibles
	<rgrau`> las clases tb son objetos
	<rgrau`> y tienen metaclases... que tb son objetos
	<rgrau`> ... etc...
	<rgrau`> vamos a por el lenguaje y luego jugamos mas con las metaclases
	<rgrau`> solo hay objetos, mensajes que se les mandan, y alguna cosita extra (la asignacion no es un mensaje)
	<rgrau`> lo que en java seria obj.meth(attr1,attr2)
	<rgrau`> en smalltalk se hace:
	<rgrau`> obj meth:attr1 and:attr2
	<rgrau`> la cosa es que se intercala el nombre del mensaje entre los parametros
	<rgrau`> solo hay 3 tipos de mensajes distintos. los unarios, que no tienen parametros:
	<rgrau`> 4 factorial
	<rgrau`> los binarios, que, por conveniencia los montaron, son normalmente las operaciones matematicas
	<rgrau`> 4+3
	<rgrau`> los de palabra clave, que son los que tienen varios parametros
	<user1> rgrau`: unario no es 4 parametro?
	<user1> un*
	<rgrau`> nope. los unarios son los que no tienen parametro. digamos que el metodo con un solo objeto ya tiene bastante
	<rgrau`> (el self)
	<user1> ah vale
	<user1> que el self se recibe siempre y no se cuenta
	<rgrau`> sips
	<user1> ok ahora pillo
	<user1> 4 factorial
	<user1> factorial es el mensaje y se envia al objeto 4
	<rgrau`> en st, no existe el metodo que no este en ninguna clase
	<rgrau`> sips
	<user1> y en 4+3
	<rgrau`> self es 4
	<user1> cual es el objeto y cual el parametro?
	<user1> el primero, ok :
	<user1> :)
	<rgrau`> los de palabra clave son los que tienen varios parametros
	<rgrau`> OrderedCollection new add: 'hola'
	<rgrau`> esto lo que hace es:
	<rgrau`> OrderedCollection new
	<rgrau`> que devuelve un nuevo array
	<rgrau`> y se le aplica el metodo add: con el parametro 'hola'
	<user3> Cual es el mensaje en esa sentencia, new y add?
	<rgrau`> hay 2 mensajes distintos
	<rgrau`> new que se manda a la clase OC
	<rgrau`> y add que se manda a la instancia que sale de (OC new)
	<user1> entonces, es mas o menos concatenativo no?
	<user1> en el sentido de que podrias hacer
	<user1> 3 factorial factorial
	<rgrau`> sip, si son unarios, no problem
	<rgrau`> para anidar keyword messages tienes que tirar de parentesis
	<rgrau`> OC new add:'hola' add:'adios'
	<rgrau`> esto, sin parentizar se refiere al mensaje add:add:
	<rgrau`> que puede existir
	<rgrau`> pero si queremos montar nuestro orden de evaluacion,
	<rgrau`> (OC new add:'hola') add:'adios'
	<rgrau`> esto contando que add: devuelva la orderedcollection. si resulta que da alguna otra cosa, nos jodieron (hay formas de salvarlo)
	<user3> seria un mensaje add al add?
	<user3> el ejemplo anterior sin parentesis
	<user1> rgrau`: and: ahi es especial para meter mas argumentos o
	<user1> es una artimaña y realmente es un mensaje tambien? :) solo curiosidad
	<rgrau`> como? no te pillo
	<user1> si, dijiste que
	<user1> obj.meth(attr1, attr2) = obj meth:attr1 and:attr2
	<rgrau`> nope, and era por decir algo
	<user1> ah, entonces, como se le pasas 2 argumentos a un mensaje? :)
	<rgrau`> Dictionary new at:'clave' put: 'valor'
	<user1> ah vale
	<user1> el mensaje en si sabe cuantos parametros recibe
	<rgrau`> sip
	<user1> entonces es
	<rgrau`> por eso, si no parentizas, no sabes cuando empieza uno y acaba otro
	<user1> obj.meth(attr1, attr2) = obj meth attr1:value attr2:value mas bien no?
	<user1>
	<rgrau`> bueno, la palabra meth como tal no existe
	<rgrau`> a := Dictionary new .
	<rgrau`> a at:1 put:'val'
	<rgrau`> los mismos nombres que les das a los parametros tienen que servir para describir que hacen
	<rgrau`> y que hace el metodo en si
	<user1> hm, a ver si me entero, estoy un poco lento :D
	<rgrau`> jej, tranki
	<rgrau`> espera, k montamos algun ejemplillo
	<user1> me estas diciendo entonces que, los metodos no tienen nombres sin oque
	<user1> segun que parametros estas usando y como, se determina cual es?
	<rgrau`> bueno, en cierta manera si, pero no es tan raro. los unarios si que parece que tengan nombre, no?
	<rgrau`> pero es lo mismo
	<user1> por eso :)
	<rgrau`> at:put: es el nombre del metodo
	<rgrau`> y sabes que tiene 2 parametros pq hay 2 ':'
	<rgrau`> y sabes donde van
	<user1> ah, esta chulo. Va la verdad que asi se ve muy claro de donde viene el termino 'mensaje'
	<rgrau`> :)
	<rgrau`> seguimos, y luego quedara claro
	<user1> no doy mas la lata :D a continuar
	<rgrau`> smalltalk tiene solo 6 palabras reservadas
	<rgrau`> eso significa que for,if,..... eres libre de usarlo como quieras
	<rgrau`> y ahi viene el truco
	<rgrau`> if, es un mensaje
	<rgrau`> implementada en la classe Boolean
	<rgrau`> con esto y bloques, que son como lambdas, se monta todo
	<rgrau`> true ifTrue:[print 'ouyeah']
	<rgrau`> estamos? estamos flipando?
	<rgrau`> xD
	<user3> me:2ªopción
	<user1> igual que en postscript, si
	<user3> continuemos :)
	<user1> voy a poner [print 'uyeah'] y a inspeccionarlo :D
	<rgrau`> es un BlockClosure
	<user1> me lo resalta mal
	<user1> el ] final
	<rgrau`> el separador entre sentencias es el punto
	<rgrau`> puede ser que sea por algo k tenias antes en el ws
	<rgrau`> ok, vamos a otra cosa, k es la clave de currar en smalltalk
	<rgrau`> menu -> system browser
	<rgrau`> eso es el browser de codigo. ahi puedes acceder a todo lo que esta corriendo en la imagen
	<rgrau`> aqui no hay archivos
	<rgrau`> todo el codigo esta ahi
	<rgrau`> si buscais en el textbox de arriba Boolean
	<rgrau`> vereis en la segunda ventanita, que Boolean tiene 2 subclases , true y false
	<rgrau`> si?
	<user3> si
	<user3> Pertenece a Kernel-objects
	<rgrau`> exacto
	<user1> un segundo, yo lo lo encuentro
	<user3> La tercera ventana que sería?
	<rgrau`> user1 estas en el system browser?
	<user1> ahora
	<user1> fallo mio :)
	<user3> Muy curioso
	<rgrau`> la tercera son los protocolos
	<rgrau`> ok, pues os cuento, Boolean tiene estas 2 subclases, que ademas son singleton, osea, solo hay un true y un false en todo el sistema
	<rgrau`> (1=1) ifTrue:[algo]
	<rgrau`> en el primer paso de la 'reduccion'
	<rgrau`> hay el mensaje binario
	<rgrau`> 1=1
	<rgrau`> que devuelve true
	<rgrau`> y despues se hace el
	<rgrau`> true ifTrue:[algo]
	<rgrau`> picad en true
	<rgrau`> y en la ultima columna buscad ifTrue
	<rgrau`> y vereis el codigo
	<rgrau`> y piel de gallina
	<rgrau`> es trivial implementar estructuras de control
	<rgrau`> aBlock value evalua aBlock
	<rgrau`> es como meter parentesis en lisp
	<rgrau`> o un eval
	<rgrau`> pillais el asunto?
	<user1> si claro
	<user1> se aprovecha de la especializacion en las clases para delegar la evaluacion condicional al sistema :)
	<user3> Como se ve el código de ifTrue: ?
	<rgrau`> clica en True
	<rgrau`> y luego ifTrue en la ultima columna
	<rgrau`> y abajo saldra el codigo
	<user3> ah, lo de abajo :D
	<user1> y en Boolean es self subclassResponsibility
	<rgrau`> exacto
	<user1> que claramente lo deja a eleccion de la especializacion, guay
	<user1> aunque pensaba que eso seria automatico :)
	<rgrau`> si una clase tiene un subclasResponsability no puedes instanciarla
	<user1> el orden de evaluacion que es de mas general a mas especifico?
	<rgrau`> nope, va de abajo arriba, el subclassR.... es solo para indicar que si llega ahi, error
	<user1> ah!
	<rgrau`> subclassResponsability esta implementado en la classe de mas arriba
	<rgrau`> y saca un error
	<user1> guay :)
	<rgrau`> todo da vueltas alrededor de la estructura de clases
	<rgrau`> se puede decir que sabeis el 90% del funcionamiento de smalltalk
	<rgrau`> ifTrue de False, devuelve nil y a tomarporsaco
	<user1> el ^ de ^nil
	<user1> merece algun comentario?
	<rgrau`> return
	<user1> ok
	<rgrau`> normalmente se devuelve lo ultimo evaluado
	<rgrau`> pero ^ es explicito
	<user3> ^ que le indica?
	<user1> ea, yo he practicado un poco con operaciones logicas and: y or: ya
	<rgrau`> y lo chulo es que si quieres hacer booleanos de 3, subclaseas Bool con algo tipo 'undef' o alta impedancia
	<user1> muy bonito
	<rgrau`> y todo rula
	<user1> rgrau`: aqui los objetos tienen atributos, o solo existe el objeto y los mensajes?
	<rgrau`> tiene atributos
	<rgrau`> ahora probamos algo
	<rgrau`> id al menu i abrid un terminal
	<rgrau`> tools->transcript
	<rgrau`> en el workspace probaremos un 'print'
	<rgrau`> Transcript show: 'hola'. Transcript cr
	<rgrau`> show es un metodo de la classe Transcript
	<user1> eso donde?
	<rgrau`> en el workspace
	<rgrau`> una vez tengas el transcript abierto
	<rgrau`> user5: tu interrumpe si quieres, eh
	<rgrau`> cr es un metodo que inserta un carryreturn
	<user1> voy a hacer una prueba
	<rgrau`> hay un poco de sintax sugar, para evitar repetir Transcript
	<rgrau`> Transcript show:'hola';cr
	<user1> vale, el terminal es unico en el sentido de que si abres mas
	<user1> la salida va a todos :)
	<user3> Lento estoy, ahora pillo de true, e ifTrue :D
	<rgrau`> el puntoycoma sirve para mandar metodos en cascada al objeto original
	<user1> guay
	<rgrau`> Transcript show:'hola';cr;show:'adios'
	<rgrau`> ahora, si os parece, creamos un par de clases
	<user1> jeje, funciona al extremo, me gusta
	<user1> sin excepciones
	<rgrau`> y ya habremos dado la vuelta al primer nivel
	<user1> 4+3;+2
	<rgrau`> sisi, es totalmente puro
	<user1> => 6 :-)
	<rgrau`> la logica que hay detras es unicamente la que os he contado
	<rgrau`> no hay mas
	<rgrau`> es genial en su simplicidad
	<rgrau`> y si pasas de objeto->clase a clase->metaclase, funciona por el mismo dispatching
	<user1> balance simplicidad-potencia, si
	<rgrau`> se sirven de ellos mismos
	<user1> forth es mas simple pero no hace tanta magia :)
	<rgrau`> creamos un par de clases pues?
	<user1> espera, voy a sorprender a vejeta
	<rgrau`> oki
	<rgrau`> :)
	<user3> a verrr =)
	<user1> no tira :D
	<user1> queria hacer
	<rgrau`> que querias provar to host
	<user1> 1 :to 100 :do [ Transcript show:'foo';cr ]
	<user1> pero el bloque acepta algun argumento o algo y tengo que capturarlo
	<user1> al final es\
	<user1> 1 :to 100 :do [:i | Transcript show:'foo';cr ] pero no lo entiendo
	<user1> el :i y el |
	<rgrau`> (1 to:100 ) do: [:i| Transcript show: i;cr]
	<user1> sin parentesis tambien va :)
	<user1> pero bueno la idea es clara
	<user1> hay un metodo to:do: que actua sobre enteros
	<user1> que recibe un entero y una closure
	<user1> y asi construyes un bucle
	<rgrau`> sips
	<user1> la sintaxis queda limpia y todo
	<rgrau`> y te puedes montar tu 'sintax sugar'
	<rgrau`> haciendo to:do: de Integer
	<rgrau`> o do: de Range
	<user1> yep, pero
	<user1> que es el :i
	<user1> ?
	<rgrau`> es el parametro que recibe la closure
	<rgrau`> (map (lambda (i) (print i)) (range 1 100))
	<rgrau`> es la i
	<user1> pero a que objeto se lo aplica? a ella misma?
	<user1> :i es como
	<user1> self :i
	<user1> quiza?
	<rgrau`> como?
	<user1> la sintaxis normal es
	<user1> objeto :attr
	<user1> pero aqui solo aparece
	<user1> :attr
	<rgrau`> si, [] debe ser sintax sugar para BlockClosure new:'algo'
	<rgrau`> me lo invento
	<rgrau`> pero supongo que debe ser algo asi
	<user1> ah, ok
	<user1> bueno, creemos alguna clase :D
	<rgrau`> oks
	<rgrau`> systembrowser
	<rgrau`> 1a columna, id abajo del todo
	<rgrau`> click derecho, new category
	<rgrau`> MiPrueba
	<rgrau`> abajo nos sale un 'template' de codigo para crear clases
	<rgrau`> ese texto lo evaluaremos ahi, pero no es distinto de un workspace
	<rgrau`> osea, el texto, en un workspace haria lo mismo
	<user1> click derecho donde?
	<rgrau`> en el mismo listado
	<user1> ah, en la columna
	<user1> ok
	<user3> Add Category?
	<rgrau`> sips
	<rgrau`> a la clase Object, le mandaremos el mensaje subclass:instanceVariableNames:classVariableNames:.....
	<rgrau`> que es un metodo implementado en Objecto
	<rgrau`> Object
	<rgrau`> Object subclass: #Persona
	<rgrau`> instanceVariableNames: 'dni telefono'
	<rgrau`> classVariableNames: ''
	<rgrau`> poolDictionaries: ''
	<rgrau`> category: 'MiPrueba'
	<user1> # es una sintaxis especial o convenio
	<user1> ?
	<rgrau`> es un simbolo
	<user1> ok, #persona es lo que 'persona a lisp
	<user1> ?
	<rgrau`> sips
	<user1> hecho :)
	<rgrau`> seleccionar y evaluar
	<rgrau`> do it
	<rgrau`> alt-d
	<rgrau`> clicas a persona
	<rgrau`> y ves como lo has declarado
	<rgrau`> si quieres anyadir otro attr, editas y vuelves a evaluar
	<rgrau`> 'dni telefono edad'
	<rgrau`> y do-it
	<user1> rgrau`: category supongo que es como los espacios de nombres o asi, verdad?
	<user1> perfecto, ya cree una instancia
	<rgrau`> nope, no hay namespaces
	<rgrau`> es una forma de organizar metodos
	<rgrau`> pero es solo para visualizar
	<user1> clases no?
	<rgrau`> comor?
	<user1> <rgrau`> es una forma de organizar metodos
	<rgrau`> ah, sisis
	<user3> Persona es la clase, no?
	<rgrau`> perdona
	<rgrau`> las 4 columnas son
	<rgrau`> categorias,clases,protocolos,metodos
	<user1> esta guay, ya me hago la idea,
	<rgrau`> igualmente, no hay namespaces
	<user1> si me dices la sintaxis para definir metodos ya puedo jugar un poco
	<rgrau`> categoria y protocolo son para organiar
	<rgrau`> si queremos subclasear Persona
	<rgrau`> Persona subclass: #Menor
	<rgrau`> instanceVariableNames: ''
	<rgrau`> classVariableNames: ''
	<rgrau`> poolDictionaries: ''
	<rgrau`> category: 'MiPrueba'
	<rgrau`> mandamos el mensaje a Persona en vez de Object
	<user3> ajam
	<user5> aqui hay una cosa interesante que ilustra el sistema de objetos
	<user5> jej, eso
	<rgrau`> :)
	<user1> yep, de hecho tambien hay plantilla :)
	<rgrau`> bien, ahora vamos a crear un metodo en Persona
	<rgrau`> seleccionamos la 3a columna
	<rgrau`> y se nos pone la plantilla esa
	<rgrau`> currar
	<rgrau`> Transcript show: 'estoy currando';cr
	<rgrau`> y do-it
	<rgrau`> y ahora desde un workspace
	<rgrau`> |p|
	<rgrau`> p := Persona new
	<rgrau`> p currar
	<rgrau`> seleccionar y doit
	<user3> Donde pones currar?
	<user3> En add category de la tercera columna?
	<rgrau`> no, clicas en la 3a columna (para que la ventana de abajo cambie de 'scope')
	<user1> unknown variable currar
	<rgrau`> currar
	<rgrau`> Transcript show: 'currar';cr
	<rgrau`> talcual, primera linea 'currar'
	<rgrau`> segunda linea: transcript.....
	<user1> eso puse
	<user1> do it
	<user1> seleccionando todo, y me da eso
	<rgrau`> en el system browser?
	<user1> si, donde salia la plantilla
	<rgrau`> y has eliminado la plantilla y has puesto esto?
	<user5> recuerda "aceptar" los cambios
	<user1> como?
	<rgrau`> al hacer el doit te pedira tus iniciales
	<user1> no llega a eso, me da el error antes
	<rgrau`> aver, desde el principio, clicar en persona, clicar en 'no messages', clicar en la ventana de abajo
	<rgrau`> meter el codigo
	<rgrau`> ahhh
	<rgrau`> vale
	<rgrau`> alt-s
	<user1> vale, con A-j si funciono
	<user1> o ese tambine :)
	<user1> el M-d es el que fallaba
	<rgrau`> pq do-it, intenta evaluar, a saco
	<rgrau`> 4+3 te lo evaluaria
	<user1> perfecto, ya trabaja
	<rgrau`> pero el m-s hace el accept en el scope correcto
	<user5> en la ventana de texto, se cambia el borde de color cuando se ha modificado el code
	<user5> aqui es "naranjita" :)
	<user3> no me lo guarda :D
	<rgrau`> sip. aki tb
	<rgrau`> alt-s
	<user3> ah, ahora esta en la cuarta columna
	<rgrau`> yep. es donde debe estar
	<rgrau`> lo guapo de el entorno controlao, es que para refactoring, el propio sistema controla referencias y tal
	<rgrau`> la idea es que al crear la clase, has creado un objeto
	<rgrau`> que ya esta 'vivo' en la imagen
	<user1> yep, yo lo pille ya :)
	<user1> bueno, como hago referencias a psible argumentos?
	<user1> defino un
	<user1> currar:n:
	<user1> ?
	<rgrau`> como?
	<rgrau`> ah, si
	<rgrau`> currar:horas
	<rgrau`> 1 to:horas do:[self currar]
	<rgrau`> sip, claro
	<user1> horas hace referencia al valor no
	<user1> ?
	<rgrau`> sip
	<user3> rgrau`: Otras implementaciones de smalltalk, distintas de pharo, no tienen porque tener necesariamente la misma gui, verdad?
	<rgrau`> exacto
	<user3> rgrau`: Y, en que se diferencia de squeak, lo has probado?
	<rgrau`> si, pharo fue un fork de squeak
	<rgrau`> bueno, pharo tiene la idea de ser algo production ready
	<user5> viene a ser la version minimalista, profesional, y francesa de squeak :P
	<rgrau`> squeak es mas de experimentacion
	<rgrau`> user5++
	<user1> (Persona new) currar horas:10
	<user1> eso no deberia funcionar
	<user1> ?
	<rgrau`> Persona new currar:10
	<rgrau`> o bien
	<rgrau`> (Persona new) currar:10
	<user1> error, 0 argumenos espera
	<rgrau`> has definido currar con 1 parametro?
	<rgrau`> o no la llegaste a definir
	<user1> si claro
	<rgrau`> ah, es verdad
	<rgrau`> pera , k miro
	<user5> ves currar: en la 4ta columna ?
	<rgrau`> sisi
	<user1> si, currar: justamente
	<rgrau`> estan las 2
	<user1> no currar:horas
	<user1> pero no entiendo por que es currar:10
	<rgrau`> ay
	<user1> 1 :to 100 :do [ ... ]
	<user3> (os sigo leyendo mañana, buenas noches, y gracias rgrau, siempre quise echarle un ojo a smalltalk)
	<rgrau`> lo que dice el error es que dentro del do:[AKIVAELPARAMETRO]
	<user5> buenas noches user3, un gusto
	<rgrau`> do:[:AKIVAELPARAMETROQUENOQUIERESPARANADA| self currar]
	<user3> Nos vemos en la próxima charla :)
	<rgrau`> puedes hacer
	<rgrau`> ciao user3
	<rgrau`> currar:horas
	<rgrau`> horas timesRepeat:[self currar]
	<rgrau`> la cosa es que el bloque k le mandas a 'do', tiene que admitir un parametro
	<rgrau`> Persona new currar:10
	<user1> ahora si
	<rgrau`> :)
	<user1> pero sigo sin entender, a la hora de llamarlo
	<user1> donde entra en juego el horas:
	<user1> ?
	<user4> wenas noches :)
	<user1> como en 1 :to 100 do:
	<user1> ahi el do: se escribe explicitamente
	<rgrau`> si, pero en el codigo donde implementa el to:do: de alguna manera se tiene que referenciar a los valores que le estan pasando
	<user5> ah creo que te pillo user1
	<rgrau`> la implementacion de to:do: seguramente sera algo como
	<rgrau`> to: anInteger do: aBlock
	<user5> tu quieres escribir un metodo que acepte solo un arg, y que ese arg sea un keyword argument
	<user1> user5: eso es
	<rgrau`> Persona new 10? asi?
	<user1> rgrau`: no
	<user5> pero hemos escrito Persona#currar: foo horas: bar, que son dos argumentos, uno sin nombre explicito y otro nombrado
	<rgrau`> no, era un solo argumento
	<rgrau`> Persona>>currar:tantasHoras
	<user5> lo que el quiere es un function(arg=anObject)
	<rgrau`> lo llamas como Persona new currar:10
	<user5> claro
	<user1> ya pillo como va
	<user5> user1 quiere poder escribir person currar horas: 10
	<user5> donde horas seria el named arg del mensaje currar
	<user5> no?
	<rgrau`> aha, no entonces el mensaje se llamaria currarEnHoras:anInteger
	<user1> no pero ya veo que no se puede
	<user1> es que tenia en mente eso de que un metodo tiene nombre
	<user1> pero el nombre son los argumentos en si
	<user1> imposible :)
	<user1> currar:10
	<user1> y si quieres mas argumentos entonces si es posible
	<user1> currar:10 :hasta 20
	<user5> exacto
	<user1> ya lo pille :)
	<rgrau`> exacto
	<rgrau`> al principio es un poco extranyo
	<user1> na, es facil :)
	<user5> es dificil decirlo solamente :D
	<user1> rgrau`: al ejecutar la misma imagen se carga todo igual o
	<user1> como puedo mantener varias imagenes diferentes?
	<rgrau`> el rollo es chulo, no user1 ?
	<user1> si si, esta guay :), aunque si el entorno fuese mas emacsero seria mejor :D
	<rgrau`> cuando cierras la imagen, guardas
	<rgrau`> :)
	<rgrau`> y se queda todo talcual
	<user5> que les parece si agregamos unas variables de instancia
	<user1> rgrau`: ya pero
	<user5> hola user4, btw
	<user1> si quiero mantener 2 imagenes diferenteS?
	<user1> 2 ramas
	<rgrau`> en una misma imagen lo que esta cargao esta cargao, no hay tutia....
	<rgrau`> tiene un sistema de control de versiones
	<user5> user1: hay un "save as", pero el vcs es mejor creo
	<user1> ah vale, que completo
	<user5> y aun falta el debugger
	<user5> y el unit testing
	<user1> por mi hoy va bien :) que manyana tengo facultad
	<rgrau`> el control de versiones va a nivel metodo
	<rgrau`> es muy maleable supongo
	<user5> me olvido que estan en +5
	<rgrau`> jej
	<rgrau`> bueno tio, pues nada
	<rgrau`> user1: pues si te ha molao, yo contento
	<rgrau`> otro dia debugger
	<rgrau`> y luego la tuya de lisp
	<user5> pues ha estado lindo, ty rgrau`
	<user1> sep, voy a intentar escribir algo para
	<user1> asentar lo aprendido
	<user1> alguna sugerencia?
	<user1> algo simple :)
	<rgrau`> mmm.. nose
	<user5> el ejemplo de pbe ?
	<rgrau`> manyana lo miramos
	<rgrau`> sip
	<user1> muy bien, gracias rgrau`
	<user1> hasta mañana a todos :)
	<user5> hasta mañana user1

view raw st.txt hosted with ❤ by GitHub