Undo layouts in emacs

Once you're used to being able to undo and redo window layouts in your windowmanager (hello ratpoison!), You feel the need to have this same feature everywhere.

;;; winner-mode
(winner-mode 1)
(global-set-key (kbd "C-x 4 u") 'winner-undo)
(global-set-key (kbd "C-x 4 r") 'winner-redo)

Slime configuration for common lisp

I recently bought a dead tree copy of Norvig's Book PAIP, and plan to dig harder on common lisp environment.

To set up a correct environment, there's emacs,slime and an implementation of common lisp. sbcl is my choice, for no big reason. It's just one of the free implementations.

Slime configurations are endless, but here's a decent one that mostly works for me.

	(add-to-list 'load-path "/home/kidd/programmingStuff/slime/slime/")
	(add-to-list 'load-path "/home/kidd/.emacs.d/")
	(add-to-list 'load-path "/home/kidd/programmingStuff/slime/slime/contrib/")
	(autoload 'paredit-mode "paredit"
	"Minor mode for pseudo-structurally editing Lisp code." t)
	(add-hook 'emacs-lisp-mode-hook (lambda () (paredit-mode +1)))
	(add-hook 'lisp-mode-hook (lambda () (paredit-mode +1)))
	(add-hook 'lisp-interaction-mode-hook (lambda () (paredit-mode +1)))
	;(load (expand-file-name "~/.quicklisp/slime-helper.el"))
	(require 'slime)
	(setq inferior-lisp-program "sbcl")
	(slime-setup '(slime-fancy slime-asdf slime-banner))
	(setq slime-net-coding-system 'utf-8-unix)
	(setq slime-autodoc-use-multiline-p t)
	(defun slime-repl-quickload ()
	(interactive)
	(let* ((completings
	(slime-repl-shortcut-eval
	`(cl:mapcar 'ql-dist:system-file-name (ql:system-list))))
	(system (completing-read "System: " completings)))
	(slime-repl-shortcut-eval-async
	`(cl:progn
	(ql:quickload ,system)
	(cl:format t "; System ~a loaded.~%" ,system)))))
	(defslime-repl-shortcut slime-quickload ("quickload")
	(:handler 'slime-repl-quickload)
	(:one-liner "Quickload a Lisp system."))
	;; Esto permite a SBCL cargar sus módulos contrib desde imágenes (cores)
	;; extraoficiales.
	;;(setenv "SBCL_HOME" "/usr/lib/sbcl/")
	;; Loop indentation
	(setq lisp-simple-loop-indentation 2
	lisp-loop-keyword-indentation 6
	lisp-loop-forms-indentation 9)
	(defun run-clisp ()
	(interactive)
	(slime "clisp"))
	(defun run-sbcl ()
	(interactive)
	(slime "sbcl"))
	(defun run-sbcl-gtk ()
	(interactive)
	(let ((core (expand-file-name "~/.sbcl/core/sbcl+gtk.core")))
	(slime (concat "sbcl --core " core))))
	;;;; Paredit
	(require 'paredit)
	(add-hook 'emacs-lisp-mode-hook 'enable-paredit-mode)
	(add-hook 'scheme-mode-hook 'enable-paredit-mode)
	(add-hook 'lisp-mode-hook 'enable-paredit-mode)

view raw .emacs hosted with ❤ by GitHub

Ah, there's a surprise in the book. I'll show you in a future post :)

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

Ratpoison bindings without prefix key

My window manager of choice is ratpoison. It's a really minimalist tiling wm heavily inspired by gnu screen. As such, it has a prefix key (c-t by default) and most of the bindings mimic screen ones.

At work, I recently discovered that my boss uses ratpoison too (my project manager uses xmonad, great team, isn't it). He uses ratpoison with a different configuration scheme, banishing prefix key, and using definekey at toplevel for every command.

I'm not sure whether I like this configuration or not, but I'm going to try this for a few days, and see if it works ok or what. I've written some lines to enable toplevel bindings using the super key.

Avoiding c-t as a prefix key has its advantages, but now, 'super' key chords are all clobbered by ratpoison. We'll see how it works out.

	#http://puntoblogspot.blogspot.com/2011/05/ratpoison-bindings-without-prefix-key.html
	definekey top s-h focusleft
	definekey top s-l focusright
	definekey top s-k focusup
	definekey top s-j focusdown
	definekey top s-s vsplit
	definekey top s-v hsplit
	definekey top s-n nextscreen
	definekey top s-p prevscreen
	definekey top s-space next
	definekey top s-u undo
	definekey top s-o only
	definekey top s-0 select 0
	definekey top s-1 select 1
	definekey top s-2 select 2
	definekey top s-3 select 3
	definekey top s-4 select 4
	definekey top s-5 select 5
	definekey top s-6 select 6
	definekey top s-7 select 7
	definekey top s-8 select 8
	definekey top s-9 select 9

view raw .ratpoisonrc hosted with ❤ by GitHub

Smoke Driven Development

He pensado que podríamos usar git
Con un poco de scrum y si aprendo TDD lo tenemos hecho en dos semanas
Un par de branches, un par de slots
Dos cartas porahi, un coaching porallá
Y despues, fiesta de final de proyecto, cardhú, putas y farlopa. Pago yo.

-- Alguno que yo me sé --

latex code listings in org-mode

I already talked about inserting code listings in latex some time ago. At @work
(in a ruby meaning, not a perl one), I try to write as much as I can
in org, and then export it to html, or pdf.

org-mode is fully capable of assisting you when writing code listings,
and it will export them with fancy syntax highlighting. When exporting
to html, it uses htmlize (emacs-goodies if you're in ubuntu). But when
exporting to LaTeX, things are not so straightforward. Of course,
there's extensive documentation, but sometimes, you just don't want to
read through hundreds of details. You just want something that
'WorksForMe (c)'.

(setq org-export-latex-listings t)
(add-to-list 'org-export-latex-packages-alist '("" "listings"))
(add-to-list 'org-export-latex-packages-alist '("" "color"))

I don't know if it's enough or there's another configuration related
to this sunken in my .emacs (now 609 lines long), but you know... It
WorksForMe.

Technologically impaired office

Ok, I've already spent too much time trying to write a doc in openoffice to acknowledge that most of general user-friendly apps are for total technologically impaired ducks. It's not that there are no shortcuts for everything, its much more simple than that.

Every single function has a button for it. You want to indent a paragraph, ok, there's a button for it, outdent, another button... The fscking problem is I'm not in the mood of looking through all the buttons of all toolbars until I find it. And guess what? Selecting a paragraph and pressing tab, just blows you paragaph away and adds a tab.

My Technologically impaired solution.
foreach @line {press(tab,↓,←)}

Popups are the root of all evil. Well, openoffice will nag you when the cursor is on a table, a numeration, or god knows what.

Nested enumerations with styles, another shitstorm.... Copypastable formatting, font, background highlight and all the unwanted persistency of a place-and-format. You will get signs from the past red bold letters that lived in the place you're editing 3 centuries ago.

For this and much more, I declare myself technologically impaired.