nil = NilClass.new

No mas excusas para no testear con picotest

2012-01-02T11:29:00.008-03:00

Picotest es una gem pensada principalmente para testear pequeños metodos, como helpers, funciones de calculo, etc...

Apenas se libero una primera version 0.0.1 de prueba para mostrar la idea, la cual consiste en evitar el "no vale la pena testear esto" cuando estamos frente a metodos o funciones que tienen un monton de casos pero testearlos supondria escribir mucha mas cantidad de lineas de codigo de lo que implicaria la propia funcionalidad que se testea

La solucion a esto en picotest es ofrecer un DSL que permita escribir una gran cantidad de casos de prueba en una o por lo menos muy pocas lineas. Por ejemplo:

require "picotest"

suite(1 => 1, 4 => 2, 9 => 3, 16 => 4).test(Math.method(:sqrt))

Tambien tiene sintaxis especifica para hacer oracle testing y mocking muy sencillo (seguir los enlaces para mas informacion)

Enlaces

Post un poco mas detallado, con ejemplos: http://tario-project.blogspot.com/2012/01/no-more-excuses-for-not-testing.html
Sitio en github: https://github.com/tario/picotest/

The Ruby Game

2011-12-27T11:26:00.002-03:00

http://therubygame.com/

Es un site que tira acertijos o problemas ruby en los que todos pueden participar enviando el codigo y ves los resultados al instante, lo copado es que podes ver un ranking de las soluciones que todos enviaron y aprender cosas interesantes de la sintaxis de ruby

Let's the game begins!

Git para usuarios de Subversion

2011-12-08T13:55:00.042-03:00

O mejor dicho:

Git NO es para usuarios de Subversion

Ir de svn a git, no puede ser:

Siendo usuario SVN, leer guia "Git para usuarios de Subversion"
Siendo usuario SVN, Usar git traduciendo los comandos que ejecutarias si usaras svn (epic fail),
Encontraran esa experiencia fea mientras sacan en conclusión que git posee una complejidad innecesaria y es muy difícil de usarlo

"Para un usuario de svn siempre sera mas facil usar svn que git"

Par ir de svn a git, es mejor seguir estos pasos:

Siendo usuario SVN, leer guia "Como volverse un usuario de git"
Siendo usuario git, Usar git de manera natural

Asi git se usaria mejor, pero quedan dos problemas:

"Para un usuario de git siempre sera mas facil usar git que svn" , es decir, que una vez acostumbrado a git usar svn se vuelve complicado.
Y mas importante, cambiar de el svn mindset al git mindset no es para nada algo trivial

Si se sigue insistiendo con git, como una mera variante de svn, esto es lo q podria pasar (lo mas comun):

Siendo usuario SVN, leer guia "Git para usuarios de Subversion"
Pasar meses de agonia mientras se maldice a git, a Linus Torvalds y al manager/PL/co-equiper/profesor que te hizo usarlo ya que es muy complicado al pedo ("¡lo unico que quiero hacer es commitear!", "¡mis cambios desaparecieron!", "¡el merge fallo y perdi todo!", y asi...)
Librarse de git de alguna manera y volver al placido y reconfortante svn (o cvs :( )

O si no, esto es mas raro que pase:

Siendo usuario SVN, leer guia "Git para usuarios de Subversion"
Pasar meses de agonia mientras se maldice a git, a Linus Torvalds y al manager/PL/co-equiper/profesor que te hizo usarlo ya que es muy complicado al pedo ("¡lo unico que quiero hacer es commitear!", "¡mis cambios desaparecieron!", "¡el merge fallo y perdi todo!", y asi...)
Aprender como funciona y hacer "cosas que con svn no hacia", explotar sus ventajas
Volverse "usuario git" al "entender como funciona" a costa de todo el sufrimiento previo
Optar por git como control de versiones preferido en todo al punto de creer que usar subversion en realidad un obstáculo

De todo esto se concluye que es muy difícil que alguna tabla de equivalencia de comandos o "mini-tutorial" sirva para que un usuario que esta cómodo con svn pueda trabajar igual de cómodo y feliz con git, o por lo menos que valga la pena el cambio, para eso un usuario debe volverse "usuario de git" antes de usarlo y/o en primeras etapas del uso de la herramienta.

Que es ser un usuario de svn y que es ser un usuario de git (mindsets)

En esta seccion me voy a referir a un "usuario de svn" a alguien que usa svn desde hace mucho tiempo, y que esta comodo y feliz con la herramienta ya que tiene ese "mindset". Lo mismo para un "usuario de git".

No obstante, la característica mas importante a analizar no es la herramienta, sino la manera de pensar las cosas, los conceptos y en ultima instancia como resuelve las situaciones del dia a dia con su herramienta favorita. Como esto no es "git evangelism", y el foco es estudiar como pasar de svn a git, sere lo mas objetivo posible

Lo mas sencillo sera mostrar la siguiente tabla:

Problema o concepto	Usuario de svn	Usuario de git
Tengo código que quiero guardar, pero "no esta listo" para integrarlo al trunk por lo que no quiero commitearlo ¿Que hago?	"Facil: tengo tres opciones: copio el codigo, y lo pego en un notepad, copio en el mismo archivo pero comentado No hago nada, porque se que puedo volver atrás con ctrl+Z crear un branch, pero preferiria que no"	"Facil: puedo commitear ya que ese commit es local, o si no también puedo crear un branch"
Estoy trabajando en una feature nueva que todavia no commitie, y alguien me pide que resuelva un bug ¿que hago?	GTFO, esperar hasta que termine la feature y haga el commit Hacer checkout del mismo repo en otro directorio, arreglarlo ahi y commitearlo Copiar el codigo a otro directorio, revertir la WC, arreglarlo ahi y copiarlo	Guardo un "stash", arreglo el bug, commit, push. restauro el stash Hago un branch
Tengo una funcionalidad a medio hacer sin commitear y me tengo que ir a mi casa, mis compañeros se quedan y podrian continuarla	No commiteo, solo yo sigo mi trabajo mañana commiteo aunque el trunk quede inestable Les doy mi computadora Hago un zip con el codigo y se los mando Me quedo hasta que pueda commitear algo bueno	Commiteo (es local) y despues pusheo a un branch asi los demas pueden seguir trabajando en el
Dos o mas integrantes del equipo colaboraran en el desarrollo de un nueva feature, que tardara un mes	Ahora si se justifica crear un branch Pair-Programming y commitear cuando termine (no conviene) Fragmentar en features mas pequeñas y commitear todos los días siempre y cuando "no rompan nada"	Definitivamente hay que crear un branch
Dos o mas integrantes del equipo colaboraran en el desarrollo de un nueva feature, que se completara en el dia	Pair-Programming y commit cuando se complete	Branch
Commit	"Es la esencia de esto, hay que hacer update antes del commit para integrar los cambios del servidor"	"Puedo commitear cuando quiera independientemente de que ocurra en el 'servidor'"
Branch	"Creare branches solo cuando sea estrictamente necesario (por ej: features que tardaran mucho mucho tiempo) o lo indique la gente de SCM"	"Lo mas importante es saber manipular branches, porque aparecen todo el tiempo si se trabaja de manera distribuida"
Merge	"Pasa automatico cuando hago update pero hacer un merge manual es un quilombo y tarda, por eso no convienen los branches"	"Pasa automaticamente cada vez que hago un pull y hacerlo manual es trivial y rapido"
Historia	"La historia se almacena en una secuencia de changesets, por eso cada revision tiene un numero, eso lo hace sencillo"	"La historia se almacena como un DAG (Arbol) de commits, entender eso es importante para comprender los branches"

El usuario de svn usa los sencillos comandos provistos por svn y varias herramientas mas como editores, IDE, compresores, mail, etc... para resolver los problemas del dia a dia, mientras que el usuario de git para resolver los mismos problemas diarios usa solamente git, que para ser justos, git en realidad es un filesystem mas un set muy extenso de herramientas sencillas, pero git como conjunto de herramientas es complejo, quiere ser lo suficientemente complejo y sofisticado para cubrir todas las necesidades y que no sean necesarios ni notepads, ni código comentado, ni mails, ni ctrl-Z para manejar versiones de código.

Un usuario de git estara pensando todo el tiempo que hace control de versiones en branches, para el es fundamental saber como manipular branches (crear, mergear, etc...) ya que sabe que los branches se crean todo el tiempo por trabajar de manera distribuida. Asumen el concepto de que es literalmente imposible trabajar sin branches en un equipo de desarrollo y por lo tanto no buscaran el imposible de "evitar branch a toda costa" sino solamente se dedicaran a controlar los branches que surgen para que no diverjan demasiado.

Consideran que todas las versiones son parte de un arbol que muestra la divergencia.

Un usuario de svn se enfoca principalmente en la "linea principal" y pensara en branches solo si surgen ciertas situaciones puntuales como por ej una feature que tardara demasiado tiempo (que en general es mejor evitar) o una version alterna del producto a medida. Asumen que la creación de branches siempre conlleva un overhead que en muchos casos solo sirven para complicar mas las cosas, muchos usuarios svn concuerdan en que si un branch va a durar mucho tiempo (digamos semanas) y se justifica podria aceptarse si el beneficio que se presume traera el branch supera ese overhead. Asi mismo cuando un branch se extiende en el tiempo y diverge mucho la integracion a la linea principal se vuelve mas complicada por lo que la integracion de esos "branches mounstruosos" es algo que no se busca (true story).

No consideran que la diferencia entre su working copy y lo que hay en el servidor sea un branch por que commitear y updatear es mucho mas facil que manipular branches.

Ven las versiones del repositorio como algo lineal

¿ Que pasa cuando hay que usar una herramienta "diferente" ?

Si un usuario svn, pasa a usar git con la consigna "reemplazo svn con git en mi set de herramientas", se encontrara que la complejidad de git, que es mayor que la de svn, sumada a la complejidad de las herramientas que esta acostumbrado a usar (bloc de notas, mails, etc...) se convertira en una molestia y no podría trabajar bien. Mientras que un usuario habituado a git, usa git para una mayor cantidad de cosas aprovechando al maximo posible las posibilidades de la herramienta (que son la cara buena de esas complejidades) y no permitiendo que surja necesidad de usar algo adicional, asi es como muchos se maravillan con git mientras otros no entienden porque si git es tan complicado.

Por ejemplo, a un usuario svn generalmente no se le ocurriría crear branches de corta duracion, porque tiene la idea de que son complicados y no valen la pena, ahi habria una ventaja que no se aprovecharía (mientras que lidear con muchas de las cosas complicadas esta implícito en el uso dirio). A alguien habituado con svn tambien le causaria mucha confusion el hacer un git pull y que el merge automatico no funcione, que se haya arrepentido o lo que sea ya que lo que hay en git no puede ser visualizado con un modelo lineal.

También es complicado para un usuario de git trabajar con svn, ya que tiene la costumbre de manejar el versionado de código solamente con una herramienta, se encontrara con que en svn los branches cortos no valen la pena y que hay muchas herramientas que faltan en comparación con git al que esta habituado y como esta acostumbrado a usar git todo el tiempo casi no conoce de herramientas "extras" y trabajar con svn le seria dificil.

Por eso el philosoraptor de la imagen se pregunta porque no existen manuales de svn para usuarios de git (mas bien seria manuales de las herramientas adicionales que hacen falta para complementar svn) si existen manuales de git para usuarios de svn.

Conclusión, como pasar de svn a git

Comprender que con git las cosas se hacen diferente, que hacerlas "a la vieja usanza" es mas complicado que con la herramienta de siempre
Abordar git de cara a las ventajas (ej: branching, merging, distribuido, forks, staging area, versionado local, etc...)
Cambiar la manera de hacer las cosas, para aprovechar funcionalidades de git (no pensar, tal funcionalidad no la uso porque así no hago las cosas, cambiar la manera de hacer las cosas)
Pensar "out of the box", estar listo para cambiar las estructuras de pensamiento mas elementales
Al enfrentarse a complejidades adicionales que no había en svn, buscar comprender porque es asi, como eso se relaciona con ventajas de la herramienta y como aprovechar esas ventajas
Ver las versiones como un arbol y manipularlas de esa forma. NO tratar de que las cosas funcionen como en svn (por ej: no pretender que git pull funcione como svn update porque son cosas diferentes)
Invertir tiempo, mucha gente que usa git dice que lo vale. No existe una manera rápida de aprender git pero el aprenderlo vale la pena

Links

Libro GitMagic: http://www-cs-students.stanford.edu/~blynn/gitmagic/intl/es/book.pdf

Libro ProGit: http://progit.org/

Blog GitEvangelism: http://gitevangelism.blogspot.com/

Generador de memes: http://memegenerator.net/

¿Que version de ruby esta seleccionada con RVM?

2011-11-30T11:17:00.005-03:00

RVM

RVM es una herramienta impresionante que permite entre muchas otras cosas switchear de versiones de ruby o gemsets con simples comandos ahorrandonos lo que seria un "configuration hell" cada vez que querriamos cambiar la version de ruby (no se puede andar instalando y desinstalando ruby todos los dias)

El que hace un uso intensivo de RVM con múltiples versiones de ruby/gemsets sabra que averiguar la version@gemset activada en un momento dado requiere correr el comndo rvm current, esto podria ser tedioso si se abren multiples tabs y se quiere saber en un vistazo cual es la version de ruby activada y en primera instancia se puede recurrir a cambiar los titulos de los tabs, pero hay otra cosa adicional que se puede hacer

Poner la version de ruby en el prompt

Cambiar el COMMAND_PROMPT en .bashrc o .bash_profile para que muestre en todo momento la version de ruby activada (ver screenshot), incluso se pueden usar colores y poner lo que sea, aca va un ejemplo de la linea que yo agregue al final de mi .bashrc para que el prompt salga como en la imagen:

PROMPT_COMMAND="echo -n -e '\033[1;31m'\$(rvm current) '\033[0;37m'-\ "

Y de aca puede haber un montón de derivaciones, como por ej poner ruby -v en lugar de rvm current o incluso algunos lo usan para mostrar a que host están conectados por ssh

Actualizacion

Una versión mejorada del comando podría ser agregar algún texto diciendo que es rvm al principio y al final en lugar de poner un comando ANSI para retornar al color gris claro específicamente, usar el color "default" que es el color del texto que sale en la terminal (que esta sujeto a la configuración de la terminal y no necesariamente sera gris claro)

PROMPT_COMMAND="echo -n -e '\033[1;31m'rvm: \$(rvm current) '\033[0m'-\ "

Links

Secuencias de escape ANSI: http://mipagina.euskaltel.es/iosus/linux/Bash-Prompt-HOWTO-5.html

PROMPT_COMMAND: http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x264.html

Sitio oficial de RVM: http://beginrescueend.com/rvm/

¿RVM + bundler es un problema? NO (Solucion)

2011-11-29T12:25:00.009-03:00

Estoy armando un entorno para desarrollo con rails, y rvm... el como instalar rvm se puede ver en un montón de sitios, empezando por el sitio oficial http://beginrescueend.com/rvm/install/

En resumen, con RVM instalado, tiro esta secuencia de comando

el primero para instalar ruby 1.9.2:

sudo rvm install 1.9.2

Despues, si todo salio bien, hay que switchear a esa version de ruby

rvm use 1.9.2

Instalar la gem rails

gem install rails

Hasta ahi todo bien, pero al intentar generar un aplicacion con rails asi:

rails new testapp

Algo no funciona...

El Problema

Veran que bundle se cuelga "indefinidame

nte" y mientras ruby podria llevarse una porción apreciable de CPU (yo por mi parte espere varios minutos y lo único que obtuve fue perder un núcleo durante ese tiempo y el comando no se completo). Si bien en muchos lugares se explica que esperando un rato largo (10 o 15 minutos) el comando se completa, no es muy tolerable para lo que es el "desarrollo rapido" con RoR.

La Solucion

Buscando por la web, me encontré con este articulo, que explica cual es el problema y da una posible solución (que al menos funciono en mi caso). Básicamente explica que el problema tiene que ver con rubygems, no con bundler.

Lo que hay que hacer es asegurarse de que el cache de gems esta generado, esto se hace corriendo el comando bundle pack, como dice la explicación que extraje de la pagina:

WHAT YOU CAN DO

So it’s still slow. My general advice is to:

Check in your vendor/cache directory with your .gem files. If bundle install doesn’t make one, force it with bundle pack.
On new installs, CI runs, and deploys, use bundle --local which will attempt to resolve using only vendor/cache
Lock down to specific versions (or use the twiddle-wakka) in your Gemfile

Y despues deberia tardar mucho menos en ejecutarse

Workaround

Si por casualidad la solución que les di no funciona pueden aplicar el workaround de crear la aplicación con rails usando la opcion --skip-bundle:

Recuerden que esto causa que las gems básicas de la aplicación no se instalen, por lo que tendrán que instalarlas a mano, para eso hay que ver el archivo Gemfile que esta en el directorio raíz de la aplicacion recién creada e instalar las gemas que figuran ahí con el comando gem.

Y después si usan gemas nuevas que no se especifican por default no olviden agregarlas al Gemfile igual ya que es muy útil por si quieren deployar la app a heroku después o simplemente para que las dependencias estén explicitas. Recuerden que después se puede correr el comando "bundle install" a mano en cualquier momento.

Links

La fuente en donde conseguí la solución: http://robots.thoughtbot.com/post/2729333530/fetching-source-index-for-http-rubygems-org

Pagina oficial de RVM: http://beginrescueend.com/rvm/

Explicación de como instalar RVM: http://beginrescueend.com/rvm/install/

Rubyconf Argentina 2011

2011-11-11T10:03:00.027-03:00

No podía dejar de ir a este evento, no voy a contar todo lo que vi porque el post se volveria demasiado extenso, pero voy a incluir las cosas que mas me impactaron.

Ruby Fun Day

Asi llamaron a la previa que organizaron para dos dias antes de evento. Estuvo muy bien pensado y realmente cumplio lo que decia el titulo Ruby-Fun-Day, en un principio no estaba seguro de ir pero mas tarde me di cuenta de que si no hubiera ido me hubiera arrepentido.

El RubyFunDay lo organizaron para los que querian iniciarse en el mundo de ruby y no anden tan desorientados en las charlas (el plato fuerte) pero para los que tienen cancha también estuvo muy bueno porque dio la oportunidad para conocer gente copada, actualizarse y por ahí otras actividades relativas a agile.

Ese dia aproveche la jornada para aprender de rails y heroku que los tenia un poco olvidados en un taller dictado por @bendycode (Stephen Anderson).

Vean el sitio de tryruby recargado con dibujitos del libro Poignant Guide de Why, es impresionante y una forma muy copada de aprender el lenguaje ruby

Ruby, Ruby, Ruby, Ruby, POO OO OO, la cancion de ruby

Desde el martes, el primer dia de la conferencia, escuche la canción. La deje de ringtone en mi telefono, es muy pegadiza:

&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;br&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;

El presente de ruby es 1.9

Yutaka Hara dio la charla llamada "Pasado, Presente y Futuro de Ruby", básicamente la lección que mas me quedo es que hay que migrar todo a ruby 1.9, porque ruby 1.8 es el pasado, basta hacer unos simples benchmarks para ver que ruby 1.9 es mucho mas rápido que su antecesor sin contar otras mejoras como ligeros improvements en la sintaxis del lenguaje, inclusión "out-of-the-box" de rubygems y un sin numero de otras cosas (talvez en la pagina oficial de ruby se encontrara información detallada)

En un momento de la charla @yhara pregunto quien usa Ruby 1.8 y a mi me llego a dar un poco de vergüenza levantar la mano

Mientras que ruby 1.9 esta muy bueno, siempre tuvo una cosa que no me gusto que es la falta de compatibilidad hacia atrás (igual esto seguramente tiene justificación relacionada con las impresionantes mejores que trae), esta característica hace que la migración a 1.9 sea difícil, no tanto por las aplicaciones hechas por uno mismo, sino por las dependencias ya que no todas las gemas funcionan con ruby 1.9.

Esto no me detendrá para migrar y la respuesta al problema de las dependencias no soportadas en ruby 1.9 es forkear las dependencias, en la gran mayoria de los casos la gema que no anda con ruby 1.9 es solo por un par de lineas que usan sintaxis no soportada por ruby 1.9, lo unico que hay que hacer para que funcione es arreglar esas lineas y listo, pero eso es un tema para otro post...

Links:

Slides de la charla que dio @yhara_en: http://ht.ly/7nOL7
Notas acerca de que voy a hacer para migrar proyectos: http://tario-project.blogspot.com/2011/11/migrating-everthing-to-ruby19.html

Cuba Web Micro Framework

En una espacio que organizaron para "Ligthing Talks" una de las charlas que dieron me llamo bastante la atención, Cuba es un framework mas minimalista que sinatra, vale la pena probarlo, me preguntaria como seria factible deployar eso a heroku

Actualizacion: el usuario maxidr aporto la info necesaria via comentarios en este post para deployar un app hecha con cuba (o con cualquier framework basado en rack) a heroku sin mayor esfuerzo, pasense por http://devcenter.heroku.com/articles/rack para mas info

Ahora, por ejemplo, asi es una aplicacion con tests incluidos:

# cat hello_world.rb
require "cuba"

Cuba.use Rack::Session::Cookie

Cuba.define do
 on get do
   on "hello" do
     res.write "Hello world!"
   end

   on true do
     res.redirect "/hello"
   end
 end
end

# cat hello_world_test.rb
require "cuba/test"

scope do
 test "Homepage" do
   visit "/"
   assert has_content?("Hello world!")
 end
end

Links:

https://github.com/soveran/cuba

http://cuba.is

¿Quien hace el mejor asado?

Muy graciosa la charla, despues se puso algo mas serio y explico cosas bastante interesantes. @tenderlove (Aaron Patterson), ruby commiter y rails commiter, analizo porque el router (el componente de rails que decide a que controlador llamar, que acción y con que parametros de acuerdo a la url) actual es lento en muchos casos y explico como se metio en las tripas del algoritmo de regular expression para cambiar el orden del algoritmo de búsqueda de rutas que implica evaluar un mismo texto contra varias expresiones regulares.

El resultado de esa investigación fue Journey, un nuevo enrutador con un algoritmo mas optimo y por lo tanto mas rapido para mas cantidad de rutas. Este se integrara a rails seguramente para la version 3.2

Links:

http://www.slideshare.net/tenderlove/rubyconf-argentina-2011

https://github.com/tenderlove/journey

Super Nario GC

Narihiro Nakamura, un commiter de MRI y un mago del Garbage Collection dio una charla acerca de Parallel Marking, una implementacion mas performante del GC de Ruby.

Basicamente el GC de ruby corre en un solo thread mientras que ademas tiene que detener todos los threads en ejecución hasta que finaliza el proceso de garbage collection, Parallel Marking en resumidas cuentas hace posible un garbage collection multi-thread con las consecuencias positivas en la performance que eso conlleva.

Para demostrar cuales fueron los resultados de su trabajo, Nari mostro ahi mismo el Super Mario GC que mostraba en pantalla estadisticas del GC e instanciaba objetos a proposito para provocar que se invoque el GC a cada rato.

Cuando corrio el juego con su implementacion del GC las pausas ocasionadas por este casi no se veian ni se notaban, solo se podia apreciar por un texto en el medio de la pantalla que titilaba una fraccion de segundo cuando el GC se ponia a trabajar, sino no habia manera de saber que el GC estaba trabajando, despues cuando corrio exactamente lo mismo con el GC clasico las pausas pasaban a ser dolorosas para la dinamica del juego.

Nari explico que en la implementacion actual el 30% del CPU era invertido en el GC "Stop-the-world" y que la implementacion de Parallel marking ganaba un 40% de ese tiempo invertido, esto considerando que las pruebas las hizo con un procesador de dos nucleos, pero si se ejecutara en procesadores de 4 u 8 nucleos (que mas o menos es lo que tienden a salir los procesadores asi por estos tiempos) el tiempo invertido en GC seria mucho mucho menor

Ojala que esa optimizacion se incorpore pronto.

El Cuento de los Tres Arboles (en ingles TTT)

@chacon explica en detalle lo que pasa con el subcomando reset de git. Los que nunca usaron git quedaron :O porque sin contexto es muy difícil entender de que se estaba hablando, los que usan git a diario seguramente sacaron algo nuevo de la charla. Espero que mucha gente haya perdido el "miedo" al reset y aprendido que reset --hard usualmente es una pesima idea.

Para aquellos experimentados en git (como yo, muahahahahhahaha) la charla no represento ninguna novedad en lo técnico pero fue una buena lección de como dar lecciones (con diagramas, dibujitos, comparaciones, etc...)

Github wants you

Aparentemente github no descarta la busqueda de talentos mas alla de las fronteras de EEUU donde residen sus headquarters, incluso en lugares donde *actualmente* (por lo menos hasta donde yo se), github no tiene oficinas, porque un lema al que puso enfasis fue "work where and when you want".

@mojombo, Tom Preston-Werner (vendria a ser algo asi como el Batman de git con un logo de pulpo en lugar de murcielago) explico como empezaron github y con muchos estímulos visuales (talvez, creo yo, un poco exagerados) se dedico a convencernos de ir (vacaciones flexibles, seguro medico, ambiente distendido, esas cosas).

Yo, personalmente, no creo que github en ese sentido sea muy diferente a otras compañías, pero trabajar ahi seria muy interesante, por las cosas que hacen que es algo que todos lo ven desde la perspectiva de usuario de la plataforma o "superfan"

Aca la deck de @mojombo:

http://speakerdeck.com/u/mojombo/p/optimizing-for-happiness

Igualmente nada se comparara con haber visto esa presentacion en vivo

Ruby hasta en el drinkup

Ni sabia que habia una bebida que se llamaba Ruby (el nombre completo es Absolute Ruby Red) , también vi un lambda el domingo cuando iba al RubyFunDay y la patente del taxi en el que volvi despues del drinkup decia "GEM"

RVM

No hubo una charla acerca de eso, pero hablando con otros rubystas durante la conferencia me di cuenta que tendría que probarlo. Al final lo instale y me di cuenta de que es una magnifica herramienta, sobre todo imprescindible cuando se tiene que trabajar con múltiples versiones de ruby de manera comoda (ejemplo: buscar que una gem sea compatible con ruby 1.8 y ruby 1.9)

Como nota final, talvez me este olvidando de algo, pero ya llego la hora de cortar el post... cualquier cosa seguramente habrá una segunda parte de este post si queda algo mas que decir.

¡concluyo CodeCamp 2011!

2011-10-15T18:43:00.029-03:00

Y me puse la camiseta para dar una charla de git, junto con mi colega Nico Paez, quien obviamente no tardo en escribir este post acerca del tema (les recomiendo visitar el post ya que da acceso a interesantes recursos)

La charla que di

Gestion de la configuracion con ~~nuget~~ y Git (si, nuget tachado), la charla mas que nada empezo siendo iniciativa de Nico Paez quien se ve que la tiene muy clara en la oratoria sobretodo en lo didactico (enseña en la UBA) y se logro una exposicion muy copada, a pesar de que realmente no nos alcanzo el tiempo (esto mas bien significa que teniamos mucho para decir, y que sobre siempre es mejor a que falte ;) )

Cabe aclarar que Nico posee profundos conocimientos de muchos otros temas (los que hicieron posible la presentación). Aun asi, sus conocimientos de git todavia no son suficientes para que pueda ver 100% de las ventajas que git ofrece y tuve que dar un empuje (push?) en ese sentido en etapas de preparacion de la presentacion.

A los planteos de "seguir el tema", lo mas probable es que escriba algunos cuantos post, con resumenes tecnicos y continuando lo que quedo pendiente de la charla y no pudo ser en el momento

Por ultimo quiero felicitar a Nico Paez pues ha sido un gusto compartir esa actividad y tuvo mas aceptacion de lo que me imaginaba (vean los smiles en la foto). Ademas saque una enseñanza importante acerca de las presentaciones con diapositivas:

NO hay que poner diapositivas llenas de texto porque distraen al publico de lo que el/los oradores dicen, hay que recurrir a graficos, o a titulo sencillos que indiquen de que se esta hablando, en ocasiones yo como publico tambien me distraje leyendo diapositivas con texto

Links de la charla:

Post en el blog de Nico con el quickstart de git

Diapositivas usadas en la sesion

Las charlas a las que fui

Actualizacion: Ahora si funciona el sitio codecamp, talvez el dia de la jornada quedo saturado, ahi agregue los links

Desarrolla con Node.js + HTML5 + Windows Azure juegos multiplayer realtime y seras millones

¿Que mas hay que decir? ¡Juegos multiplayer! ¡Sentencias/presagios de muerte para flash! ¡Java Lopez! De chico tenia el berretin de hacer jueguitos, despues los hice con QBasic (me siento viejo :S) , despues con VB, despues con Div Games Studio, pero estas historias son para otro post. Lo importante es que volver al mundo del desarrollo videojueguil con esta clase de tecnologias (HTML5 y demas yerbas) seria volver por una de las puertas grandes

Desarrollo de juegos con XNA para WP7 y XBOX

Impresionante charla, queria saber en que estado estaba eso del XNA. Y por lo visto logran cosas muy copadas (con 3D y todo), pero para mi gusto demasiado exclusivo de plataformas microsoft, por el momento me inclinaria mas al HTML5 con javascript, o Java, algo que corra "en todos lados"

C++, el fantasma de las natividades pasadas, presentes y futuras

El pasado lo conociamos casi todos (esta en los libros), el presente lo vi (y no me gusto), a mi y a la mayoria de los presentes en esa charla nos intrigo el futuro,

A mi me gusto la charla, me entere de cosas que no sabia que existian (¡C++ tiene lambdas!) y tambien de cosas del nuevo c++ que hay en windows 8, que no tiene garbage collector ni es managed (a cambio tiene la mega-performance y el bajo nivel) pero tiene reference counting integrado con el lenguaje, interaccion casi "magica" con cualquier otro lenguaje como por

ej javascript y seguro un monton de cosas mas que el tiempo no da para explicarlas todas en una sola charla.

No me gusto cierta parte del mensaje tanatico, si puede llamarselo asi, que anuncia que "todo estara en c++" (igual solo es una forma de decir), fuera de ese detalle la charla me gusto bastante y el c++ con todas las implementaciones a nivel IDE que agregaron ahora sera mas "soportable"

Masas de desarrolladores, masas de chocolate

Masividad de desarrolladores talentosos exponiendo ideas y/o curiosos en la cacería de

conocimiento

Masividad de azucar, masas y cafe masivo... la comida/bebida

ideal para las 24x7 de la mayoria de los informaticos, y que en realidad no llevan a la practica por falta de dinero/infraestructura hepatica capaz de procesar toneladas de glucosa diaria

Disclaimer: no llegue a sacarle fotos a las masas, pero eran del estilo de las que se ven en la foto y eran ricas

Unicas Criticas

A la tarde se acabo la azucar (o no se conseguia) para el cafe :(, lo perdono al considerarlo tambien una buena medida para controlar el consumo adictivo de glucosa (combinado con el sedentarismo tipico de la profesion IT puede llegar a ser dañina) y teniendo en cuenta de q las masas ya proveian la sobredosis necesaria de glucosa

No podia ir a las 10 charlas que habia en cada horario a la vez, si bien no eran todas taaaaan interesantes, habia horarios en los que era muy dificil decidir entre dos o tres sesiones interesantes que habian al mismo tiempo

Anti-Pattern legacy: making a zip in the era of DVCS

2011-09-14T11:58:00.012-03:00

Un anti-patrón es una solución repetitiva incorporada o aprendida para la cual se demostró que lejos de resultar una buena solución para un problema (como aparentaría en un principio) genera mas problemas que los que soluciona.

Mientras que el concepto se popularizo como anti-patrón de diseño con orígenes en el libro Design Patterns, el concepto de anti-patron se utiliza en variedad de escenarios como en la programación (ej: el infame Codigo spaghetti), project managament (ej: Groupthink)

Anti-Patrones como Patrones Legacy

Algunos (¡y muchos!) anti-patrones como Waterfall model (Desarrollo de software en cascada), son practicas o patrones generalmente aceptados y enseñados en viejas épocas y que ahora al quedar obsoletos fueron reemplazados por otras practicas mas eficaces (Desarrollo iterativo, metodologías agiles, etc...) . A pesar de eso viejas practicas quedan en el knowhow colectivo y lo importante es saber reconocerlos como anti-patrones y no como una practica que haya que fomentar (y también saber cuales son las practicas que son convenientes por estos tiempos).

Anti-Patrones en Control de versiones

Como se había mencionado anteriormente, el concepto de anti-patrón se extendió rápidamente a variedad de entornos, siendo uno de ellos el mundo de las versiones (o como algunos le dicen, SCM), un área del desarrollo de software que crece mas lentamente que otras (el porque de esto seguramente lo tratare en algún que otro post).

A pesar de no haberse desarrollado mucho, SCM (o abreviado CM) fue un ciencia/brujería/técnica que paso por varias fases a lo largo de su historia pasando por herramientas que solo servían para trabajar individualmente, sistemas de control de versiones concurrentes para equipos (CVS :P), sistemas centralizados mas avanzados para dar mejor soporte a ramas aunque no sea lo suficientemente bueno (ej: SVN), sistemas distribuidos (ej: Mercurial) (para información detallada vean este excelente articulo acerca de la historia del source control).
Esta historia es la que habilita la posibilidad de que determinadas buenas practicas muy comunes y que resultaban satisfactorias ayer sobrevivan mas allá de su obsoletización para convertirse en anti-patrones hoy.

Los Patches que se usaban antes

Una de las practicas que fue muy utilizada durante un tiempo fueron los patches, sobretodo en los entornos de desarrollo open source, en épocas donde la internet estaba en pañales y cosas como codeplex, github, googlecode no existían ni en la imaginación (es mas, muchas de esas compañías ni siquiera existían), cuando alguien realizaba una contribución a un proyecto lo que generalmente este hacia era generar un patch (que no es mas que un .tar.gz o .zip del diff entre determinadas versiones y/o el contenido de esas versiones) y posteriormente se lo hacia llegar, era común mandarlos por email firmados, adjuntarlos en foros, BBS, etc... En definitiva, no existía el concepto de "commitear a un repo en la nube".

El "Make a zip" que se usa ahora

Posteriormente exploto la internet, llegaron los servicios, se estabilizaron y herramientas como SVN pudieron cobrar mas protagonismo, yo por ejemplo usaba el servicio de http://www.assembla.com/, que por esos momentos ofrecia SVN (estamos hablando del 2006 aprox.).

Sin embargo, existía cierta "cosa" por la cual "commitear al repo" no era tan frecuente, estaba (y esta) vigente Continuous Integration, una excelente herramienta para llevar a cabo proyectos integros aprovechando al máximo un versionador, pero que inadvertidamente dejaba varios asuntos de lado.

Uno de esos asuntos es el intercambio de código "unmanaged", es decir, código que no debería ser parte de la mainline en ese momento, pero que lo seria en el futuro o que tiene que por diversas razones tiene que "estar en algún lugar".

Noten que hasta el momento no use la palabra con B.

Entonces, generalmente es fácil caer en este razonamiento: "Si ahora se esta usando un repositorio para compartir una mainline, y eso es fabuloso, entonces como envió el código que no tengo que commitear por H o por B razon ? Uso lo que ya conozco, y hago un patch para poder enviar el contenido" ( o en otras palabras, hacer un zip ) lo cual parece que es algo bueno porque era una practica normal y promovida en las viejas épocas, y al trabajar con sistemas de control de versiones centralizado como el mas popular de esa generacion (svn) incluso yo creo que trabajar con codigo "unmanaged" de esa forma es mas practico que hacer branches la mayoria de las veces.

DVCS's y la palabra con B

Pero la practica de realizar patches, en DVCS's como Mercurial o Git solo existe como una practica legacy, un anti-pattern (aunque siempre habrá excepciones, pero deben ser las menos y muy poco frecuente). En herramientas distribuidas de versionamiento, las soluciones alternativas al problema del código "unmanaged" están a mano y es mas facilitada por la herramienta que ofrece alternativas mas practicas que el uso de patches, mails con código o archivos zip y por supuesto mas practicas que las soluciones ofrecidas por herramientas de generaciones anteriores.

Intercambiar código con otros desarrolladores solamente a travez del repositorio y usar otros métodos solo para los que por alguna razón no puedan, no deseen, o no sepan como acceder al repositorio.

Yet another blog?

2011-09-12T16:09:00.008-03:00

le preguntaba a un co-worker , Nicolas Paez y Angel "Java" Lopez. si seria conveniente o no crear un blog nuevo para los articulos pendientes que tengo acerca de SCM (no centrado en git) y me di cuenta que la respuesta no es tan obvia como imaginaba en un principio.

Segun Nicolas es conveniente que tenga un solo blog unificado, esto suena bastante bien por una cuestion de simiplicidad y para poder dar una referencia de mi (ej. el blog de Dario Seminara) pero al imaginarlo me vi escribiendo varios articulos muy especificos de diferentes temas en el mismo blog. Por ej vean la detallada explicación de un problema tecnico de un proyecto particular, la explicación de como usar branches en git y un resumen de herramientas UML online ¿todos esos articulos caben en el mismo blog? ¿o mas bien lo mio solo es una impresion erronea?

Los temas acerca de lo que iba a escribir no caben en gitevangelism ya que tratan de alejarse de git mientras el titulo de aquel blog indica que contiene ayudas tecnicas de git (pretendo que cualquiera que entre a ese blog encuentre lo que el blog promete por titulo, ni mas ni menos)

Los nuevos articulos tampoco parecen ir muy bien en este blog (Nilclass) porque a pesar de que Nilclass haya quedado como el blog de "miscelaneas" estos temas son muy especificos, densos y analiticos. No es un post que uno quiera ver en el camino cuando busca lo "generico"

Segun las propias palabras de Nico: "Yo tengo un unico blog y escribo sobre distintas cosas, pues no tengo tantas cosas para escribir", lo cual es algo que yo asocio a la estrategia de mantener un solo blog al ser pocas las cosas para escribir. Mientras, por mi parte, ahora estoy experimentando como explotar al máximo la comunicación mediante blogs. Buscando la manera de escribir todo lo que sea escribible y publicable (tratando de seguir un ritmo similar al de Java Lopez) y difundir aquellas ideas genéricas, que si bien es muy probable que fueran aplicables en un entorno real de trabajo, no conviene explicarlas en una meeting/retrospective o en medio de un trabajo enfocado en lo concreto.

Un ejemplo de eso es este mismo post, que originalmente fue una conversacion en medio del trabajo y se convirtio en un post que podra ser leido por cualquiera en la web incluyendo obviamente tambien a las personas a la cuales me interesa que la informacion les llegue.

Todavia no decidi en que blog iba a escribir esos articulos pero aprendi muchas cosas acerca del mundo del blogging que resulto ser mas nuevo para mi de lo que creia en un principio

Mis blogs

NilClass: http://nilclass.blogspot.com/

Ruby y Miscelaneas
Git Evangelism - http://gitevangelism.blogspot.com/

Blessed are those who use git for source control. Tips, tecnicismos, conceptos y explicaciones acerca de git
Tario Projects - http://tario-project.blogspot.com/

Blog for projects: Technical details about personal open source projects

La memoria y TDD: Refactor/test backlog & Sleeping in Red

2011-07-18T22:09:00.018-03:00

Hace tanto tiempo que no escribo en este blog, y ahora vuelvo a escribir (sin razon aparente) para contarles unas impresiones acerca de como se me ocurre optimizar TDD en relacion con la memoria (humana), en esto cualquier comentario que puedan aportar no solo sera bienvenido sino que tambien muy apreciado

Lo basico

Bueno, para no dar mas vueltas voy directo al tema empezando por la basico (salteen este parrafo si saben basicamente en que consiste TDD)
TDD es una practica de programacion que basicamente consiste en escribir los tests primero y refactorear el codigo convenientemente, este proceso se ejecuta de manera iterativa pasando por tres fases en cada iteracion: rojo, verde y refactor. A grandes rasgos:

La fase "roja" consiste en escribir tests que fallen expresando especificaciones de como las cosas deberian funcionar, antes de que se implementen
La fase "verde" consiste en buscar que esos tests pasen a toda costa, es decir que "vale todo" de manera que el codigo se llena de chanchadas en esta fase (lease codigo duplicado, harcodeos, variables globales y cualquiera de esas cosas feas que se ven en las pesadillas)
La fase de refactoring la cual hace mas lindo el codigo, limpiando todo lo que se ensucio en la fase verde anterior mientras se mantenga el 100% de tests en verde

Para mas informacion de TDD pueden ver el articulo de la wikipedia o simplemente buscar en la web que esta lleno de blogs que explican cosas muy interesantes

¿Que tiene que ver la memoria con TDD?

La memoria tiene que ver con todo, y en el caso especifico de TDD, la memoria del programador actua diferente de fase en fase (suponiendo que no use un soporte externo como voy a explicar mas adelante).

En la fase roja, que inicia el ciclo de TDD, la informacion que el desarrollador utiliza para escribir los tests son las especificaciones (para reducirlas a especificaciones de componentes en el codigo, etc...). No se necesita ninguna informacion memorizada ya que las especificaciones vienen escritas (y si no, ya no es un asunto de TDD). Solo se requiere informacion extra para escribir casos "borde", caminos "no felices" o cualquier cosa que no este explicitamente en la especificacion.
En la fase verde, se tiende a usar informacion que se escribe en los tests para hacerlos pasar, como por ejemplo nombre de clases, metodos u otra informacion que se escribio en los tests. Depende del caso, se suele utilizar mucho conocimiento del proyecto, pero por ahora eso no importa porque esa memoria esta mas alla del scope de un ciclo de TDD
En la fase de refactor, se utiliza informacion que esta en el codigo (por ej, al observar metodos duplicados) e informacion producto de ideas, razonamientos, observaciones al codigo efectuadas en cualquier momento, ya que el codigo se esta observando siempre y hay que considerar que refactorear codigo para mejorar su calidad interna no es una tarea trivial (como si lo es hacer que los tests pasen) y requiere mas trabajo mental

Las fase que mas informacion producida en el mismo ciclo y mas trabajo mental requiere es la de refactor, la fase verde requiere mas trabajo mental que la roja

Refactor backlog

El que haya usado TDD, seguro se encontro en la situacion de duplicar cierto codigo para hacer que un test pase teniendo en mente refactorizarlo despues (no en el momento), no deberia memorizarse esa informacion ya que eso es proclive a olvidos y disminuye la concentracion en la tarea del momento, en lugar de eso es mejor usar un "backlog" (que seguramente no sera el mismo backlog agile, es algo distinto) o un "ToDo list" el cual se debe alimentar cada vez que se observe algo que deba ser refactoreado y que no corresponde hacerlo en ese momento

Test Backlog

Para aplicar el mismo concepto que en el parrafo anterior, cada vez que miramos al codigo, se nos ocurre "¿y si llamara a tal metodo con tal argumento, fallaria?", lo mejor en ese caso sera escribir un test que pruebe eso. No suena muy practico interrumpir el trabajo para hacer pasar los tests o el trabajo de refactoring para escribir el nuevo test fallido en el momento, por eso es mejor anotar los test nuevos en algun lugar a medida que se van descubriendo e implementarlos mas tarde. En mi opinion, lo ideal es hacerlo al finalizar la fase verde o de refactor con todos los tests pasando (se considera que se vuelve a la fase roja)

Dormir en rojo

Todos tenemos que descansar en algun momento, y el verdadero descanso consiste en distraccion total y si es posible completo olvido del trabajo (y si es posible irse a dormir :P). Eso implica que, al volver al trabajo, tratar de recordar informacion acerca de la tarea que se estaba realizando antes de interrumpirla para descansar, es significativamente mas costoso que recordar lo que se estaba haciendo hace pocos minutos o segundos (como en el caso del trabajo continuo).
La fase que menos memoria reciente requiere (despues de la inicial) es la verde (la de hacer pasar los test), por eso si se va a interrumpir la tarea lo mas conveniente es hacerlo con todos los nuevos tests fallando (al terminar la fase roja) ya que si se hace antes del refactor al volver se tendra que recordar los items de refactor pendientes (a pesar de usar el backlog, este solo actua como un ayuda-memoria que hay que leer, no como una memoria auxiliar). La fase roja inicial requiere menos memoria reciente pero es mas trabajosa, usa informacion de las especificaciones y es mucho menos trivial por lo que aunque tambien sea util interrumpir antes de escribir los tests no es tan conveniente como pausar despues de escribirlos.

Conclusiones

Voy a asegurarme de escribir todos los test que pueda antes de interrumpir la tarea para descansar, y despues hacerlos pasar cuando vuelva a trabajar
Voy a implementar un backlog/ToDo con items de refactor que voy a consultar cuando haga pasar todos los test
Voy a implementar un backlog/ToDo con items de test (pero voy a ver si eso realmente es util o no)

Links

TDD en la wikipedia: http://es.wikipedia.org/wiki/TDD

El blog para los proyectos

2011-03-13T21:36:00.005-03:00

Se llama Tario's Project Blog ( http://tario-project.blogspot.com/ ) y lo hice especificamente para los proyectos para los que estoy trabajando bajo ese nickname en github (https://github.com/tario) y posiblemente otros. El objetivo de esto es construir un site separado donde se pueda consultar el status de esos proyectos y al mismo tiempo no saturar este blog con esa clase de informacion. Ademas, Tario's Project sera escrito integramente en ingles para tener un mayor alcance (mas tarde evaluo si implemento la version en español del blog o aprovechando alguna que otra feature de internacionalizacion que vi que tiene blogger)

Lo ideal en realidad, seria dedicar una pagina a cada proyecto, pero en este caso los proyectos son chicos y son muchos ademas de que estan muy relacionados unos con otros (por ej, el release de cierto gem puede tener alto impacto en la usabilidad de otro ya existente), mas adelante, si corresponde, habra un site para proyectos que crezcan en importancia.

Enlaces:

El nuevo blog: http://tario-project.blogspot.com/
El sitio de repositorios en github: https://github.com/tario

Buscar la raiz cuadrada mas rapida, con Ruby

2011-01-25T19:08:00.011-03:00

Se vienen los examenes y uno de ellos es el de Analisis Numerico, y como estoy usando mucho la raiz cuadrada en un proyecto en el que estoy, me decidi a buscar una raiz cuadrada mas rapida que la que trae el propio framework ;)

La verdad, es que por default, las librerias matematicas calculan la raiz cuadrada con una muy buena precision, pero pueden surgir casos en los que esa precision es innecesaria (por ejemplo, si se trunca el resultado de la raiz cuadrada, es decir, tirar a la basura los decimales que se calculo) y lo que si es importante es poder efectuar los calculos rapido

Sea cual sea el lenguaje en e que se va a programar, ruby esta bueno para probar los algoritmos muy facilmente, en este caso se utiliza el metodo de Newton-Raphson para calcular la raiz cuadrada de un numero


# x**2 - a = 0

# calcula la raiz cuadrada y se le puede especificar la precision, es decir
# la cota superior del error del resultado
def Math.my_sqrt(a, precision)
 
  x = 1
  oldx=1

  iter = 0
  # newton raphson
  while 1
    oldx = x
    x = x - ( x**2 - a ) / ( 2 * x)
    break if (oldx-x).abs < precision
  end
 
  x
end

def show( code )
  print "#{code} => #{eval(code)}\n"
end

show "Math.my_sqrt(2.0, 0.5)"
show "Math.my_sqrt(2.0, 0.05)"
show "Math.my_sqrt(2.0, 0.005)"
show "Math.my_sqrt(2.0, 0.0005)"

show "Math.sqrt(2.0)"

Salida del programa


Math.my_sqrt(2.0, 0.5) => 1.41666666666667
Math.my_sqrt(2.0, 0.05) => 1.41421568627451
Math.my_sqrt(2.0, 0.005) => 1.41421568627451
Math.my_sqrt(2.0, 0.0005) => 1.41421356237469
Math.sqrt(2.0) => 1.4142135623731

Enlaces:

Metodo de Newton explicado en la Wikipedia
Explicacion del metodo de newton usado para calcular la raiz cuadrada de un numero

¡Habemus Blog!

2010-12-12T12:50:00.007-03:00

El nuevo blog gitevangelism se dedica a la promocion de GIT. Un sistema de versionamiento que tiene asombrosos features pero que lamentablemente no esta lo bastante
difundido, por lo menos en los ambientes que frecuento: en los trabajos y en la facultad.

Sin duda, el sistema de control de versiones mas usado y difundido es el SVN, son muy pocas personas las que conocen a fondo las prestaciones de ambos como para poder elegir y por eso podria parecer que lo unico que agrega GIT son "commits locales" y "complejidad innecesaria". gitevangelism se encargara (entre otras cosas) de desmistificar esto y promover el conocimiento acerca de esta herramienta y como el control de versiones esta mas asociado a la forma del proceso de desarrollo de lo que en principio se cree.

El nuevo blog:
http://gitevangelism.blogspot.com

--amend

Overview de herramientas UML online

2010-08-24T20:33:00.037-03:00

Resulta que me anote en una materia interesante y estoy necesitando encontrar una herramienta de UML a mano, facil y si es posible colaborativa... esto es online, o "en la nube"

Ya que estoy probando varias opciones, aprovecho para escribir un overview de todas las herramientas que probe. Para cada herramienta se incluye un diagrama generado con esta y la evaluacion de las siguientes caracteristicas:

* Almacenamiento: Si tiene storage para almacenar los diagramas online
* Vistas: Si tiene vistas publicas dinamicas para que se pueda mostrar en una pagina o en un blog la ultima version del diagrama
* Diagramas: Que tipos de diagramas se pueden hacer (diagramas de actividad, casos de uso, clases, objetos, secuencia, despliegue, colaboracion, transicion, componentes)
* Exports: Si se puede exportar como imagen o como algun otro formato editable
* Imports: Si se puede importar imagenes o incluso otros objetos
* Coop: Si es colaborativo, o sea, si varios usuarios pueden editar el diagrama simultaneamente diseñando de manera cooperativa.
* Estabilidad: Si es posible editar sin que se cuelgue o tenga algun otro fallo que afecte el trabajo
* Portabilidad: Si funciona en varios navegadores (por ahora testeados en Mozilla Firefox 3.6.8 con Ubuntu Linux)
* Registracion: Si es necesaria, y que implica
* Costo: Si tiene paquetes de uso gratis, si tiene paquetes de servicio pago, que limitaciones y precios hay de cada uno de ellos
* Engine: Como funciona, si usa java, flash, etc...

Cacoo
http://cacoo.com/

Segun mi opinion, uno de los mejores, si se pudiera guardar el diagrama en la computadora local seria perfecto

* Almacenamiento: SI
* Vistas: SI (ej: https://cacoo.com /diagrams/hB18F3rQnjWqxQ74/view )
* Diagramas: casos de uso, clases, secuencia, estados, componentes, deployment, ER y tiene mas bibliotecas de objetos
* Exports: Solo imagenes en formato PNG (la version gratuita)
* Imports: Cualquier tipo de imagen
* Coop: SI
* Estabilidad: Si tenes una conexion mala no lo uses
* Portabilidad: Funciona bien en firefox 3.6.8 y en Ubuntu Linux
* Registracion: SI o SI es necesaria (tambien con la version gratuita)
* Costo: Gratis (limitacion de 3 colaboradores por diagrama)
Engine: flash

Creatly
http://creatly.com

Este diagramador puede guardar archivos en la computadora local (ademas de poder guardarlos online)

* Almacenamiento: SI
* Vistas: SI
* Diagramas: Actividad, Clase, Colaboracion, Componentes, Deployment, ER, Objetos, Secuencia, Estados, Casos de uso, networking, electronica, de flujo
* Exports: PNG, JPG, PDF, Creatly File
* Imports: Image, Creatly File
* Coop: SI
* Estabilidad: Me colgo el firefox una vez, pero la mayoria de las veces lo pude usar
* Registracion: Se puede usar sin registracion (aunque se recomienda registrarse y es gratuito)
* Costo: Actualmente Gratis para 2 collaborators, U$S4.95 para 5 collaborators y un 1 Gb, U$S9.95 para ilimitado espacio y collaborators. No se puede tener varios proyectos ni exportar archivos en formato "editable" en la version gratuita. Ver http://creately.com/plans7

yUML
http://yuml.me/

Este es rarisimo, hay que poner un codigo (como una especie de lenguaje) y genera el diagrama. No tiene editor y es el que menos funcionalidades tiene, lo unico bueno que tiene es que funciona bien sin impotar cual sea el browser

* Almacenamiento: NO
* Vistas: NO (Algo parecido)
* Diagramas: clases, actividad, casos de uso
* Exports: Imagen PNG
* Imports: NO
* Coop: NO
* Estabilidad: 100% Siempre funciona, porque es muy sencillo
* Portabilidad: 100%, ya que no importa que browser uses, el diagrama se genera del lado del servidor a partir del "codigo" que se le ingrese
* Registracion: no hay
* Costo: Gratis

gliffy
http://www.gliffy.com/

Este es interesante, tiene el estilo del cacoo y al creatly, pero viene con templates base para crear diagramas (con lo que ayuda bastante al usuario primerizo), lastima que no me anda el drag&drop (¿sera mi version de flash?), cualquier cosa pruebenlo (no se necesita registracion para probar). En lo personal para lo que necesito no tiene elementos de suficientes diagramas.

* Almacenamiento: SI
* Vistas: SI (Ej: http://www.gliffy.com/pubdoc/2214754/S.png)
* Diagramas: Diagramas de flujo, networks, ER, UI, Diagramas de clases, secuencia, casos de uso
* Imports: SI, Formatos GIF, JPEG y PNG
* Exports: SVG(Visio), Gliffy Xml, Formatos graficos JPEG y PNG
Coop: SI
* Estabilidad: Por lo visto es estable, pero no lo pude probar bien
* Portabilidad: Me fallo en firefox 3.6.8 con Ubuntu Linux, talvez funcione en otras plataformas
* Registracion: Se puede usar sin registracion (aunque se recomienda registrarse y es gratuito)
* Costo: es Gratis, pero es un trial de 30 dias

gModeler
http://www.gskinner.com/gmodeler/

Mismo problema de drag&drop como con gliffy, mas tarde probare este y otros con otro entorno.

* Almacenamiento: NO (Aunque permite guardar como XML localmente)
* Coop: NO
* Portabilidad: MALA, no funciono en firefox 3.6.8 con Ubuntu Linux
* Registracion: no hay
* Costo: es totalmente Gratis

Mas tarde voy a probar gModeler desde otro entorno

Enlaces:

Cacoo: http://cacoo.com
Creatly: http://creatly.com
yUML: http://yuml.me/
gliffy: http://www.gliffy.com/
gmodeler: http://www.gskinner.com/gmodeler/

Diagramas UML online

2010-08-19T22:37:00.003-03:00

Visiten esta web:

http://yuml.me/

Permite crear diagramas UMLs online usando un lenguaje bastante interesante, no tuve mucho tiempo para probarlo mas que para hacer este diagrama que les estoy mostrando

La magia del TDD: un ejemplo real en ruby

2010-08-16T12:48:00.018-03:00

Este fin de semana comence un proyecto, una nueva gema que "desparsea" los arboles generados por la gema ParseTree. Explicar los detalles de ese proyecto no es el tema de este articulo, sino mas bien contar la experiencia con TDD.

Para los que no saben que es TDD la wikipedia explica. Sin son vagos como para clickear el link, TDD es una metodologia que basicamente tiene dos pilares: "write tests first" (escribir los test primero) y "refactoring".

Resulta que lo que estoy desarrollando consiste en una funcion que revierte o encuentra la preimagen de otra funcion (es decir, genera un string con codigo ruby que resulte en un determinado arbol cuando se parsee con ParseTree).

Este requerimiento tiene un grado muy alto de testeabilidad ya que se puede calcular el input correspondiente a partir del output esperado (seria como el testeo oracle, pero al revez porq estamos buscando hallar la inversa de una funcion que ya tenemos, que es ParseTree)

Manos a la obra:

Paso 1) Escribir los tests primero:
http://github.com/tario/unparse_tree/tree/0ca29f14

En este caso se fue desarrollando de manera de ahorrar lineas y probar *todos* los casos (mas adelante se sabe que se omitieron algunas cosas, pero creo q eso es comun en TDD sobre todo cuando el analisis de cobertura no es viable)

Paso 2) Implementar hasta que todos los tests pasen:
http://github.com/tario/unparse_tree/tree/48c9a997

Cambios hasta que funcione, algunos "harcodean" o ponen "magic values", otros agregan funcionalidad a conciencia, lo importante es que cada commit disminuye el numero de errors + failures reportados y no se modifican los tests

Paso 3) Refactoring:

En esta etapa se modificara el codigo hasta que se vea minimamente "bien", es decir, se eliminara codigo duplicado, se implementaran las cosas "de verdad" en lugar de usar "magic values", "harcodeos" o "if extraños" y cualquier cambio que mejore el diseño/la distribucion del codigo, de mas esta decir que por cada cambio todos los tests siempre tienen que pasar. Todavia no alcance esta etapa en el proyecto... ya llegara.

Paso 4) Vuelta al paso 1:

Con nuevos requerimientos y/o bugs encontrados, se genera una nueva bateria de tests y el ciclo vuelve a comenzar.

De todo esto, en la practica me encuentro con las siguientes ventajas de usar TDD:

* La validacion de si el codigo funciona es automatica, con solo ejecutar un comando puedo saber si "rompi" el codigo o si estoy progresando
* TDD guia a escribir el codigo de manera "correcta" o por lo menos mas prolija
* Se puede testear un numero mas grande de casos, con lo que se cubren mayor cantidad de posibilidades

Y, como todo, tiene sus desventajas (aunque se mitigan y son evidentamente superadas por las ventajas)

* Hay que programar las pruebas que si no se usara TDD, no se tendrian que programar (de todas maneras, con o sin TDD siempre hay que testear el software, y sin TDD se hace de forma manual)
* Las pruebas no garantizan cobertura total, es decir, pueden ser %100 exitosas las pruebas y el software fallar en la practica al haber omitido algo (esta claro que la idea en principio no es confiar ciegamente en las pruebas, mas bien TDD tiene que basarse en la construccion de pruebas)
* Durante la fase de desarrollo, me doy cuenta de errores que se ven en el codigo o al escribir el codigo, pero no puedo corregirlos si no existen tests que pasen como resultado de esa correccion (para resolver esto se puede optar principalmente por dos alternativas, una seria registrar como un "ticket" la necesidad de agregar el test para el proximo ciclo, la otra seria agregar el test en ese mismo momento, aunque eso se alejaria del espiritu del TDD y superpondria los pasos 1 y 2)

Cabe destacar que las ventajas del TDD asi como otras metodologias son apreciables a mediano y largo plazo (TDD mas que otras), ya que a medida que avancen los ciclos de TDD, los tests desarrollados en ciclos anteriores cumpliran el rol de automatizar las regresiones, es decir, que si se modifica el codigo en un proyecto que tiene 8 meses de vida, las pruebas automaticas rebelaran si se rompio funcionalidad implementada al principio del proyecto, tres meses atras, dos meses atras, que implemento otra persona, etc...
Despues de varias iteraciones, volvere a postear para hacer un analisis de las ventajas de TDD a largo plazo

Enlaces

http://en.wikipedia.org/wiki/Test-driven_development
http://github.com/tario/unparse_tree/tree/0ca29f14 (tests creados en el primer ciclo de unparse_tree)
http://github.com/tario/unparse_tree

Soy malo para los nombres de blogs

2010-08-10T22:31:00.004-03:00

He creado un nuevo blog, llamado Soy malo para los nombres de blogs, sera el sumidero de las sobras de todos los blogs, no entren ahi

Enlaces:

http://soymaloparalosnombresdeblogs.blogspot.com/

Sandbox de codigo ruby (remake 2010)

2010-06-22T22:38:00.009-03:00

Anteriormente en este mismo blog anuncie la creacion de un sandbox para ruby. Ese proyecto se cancelo y quedo definitivamente incompleto. El proyecto se llamaba arena-ruby-sandbox.

Hace un tiempo comenze el desarrollo de un nuevo sandbox (llamado shikashi), pero con un diseño y una idea totalmente distinta: mientras arena-ruby-sandbox es un intento de sandbox en codigo ruby puro, shikashi se implementa utilizando una modificacion al interprete de ruby hecha en C en formato de extension (llamada rallhook).

Funciona mejor que su antecesor ademas de permitir usar casi todos los elementos del lenguaje como clases y metodos singleton cosa que arena-ruby-sandbox no permitia.

Recientemente libere la version 0.7.1 de rallhook ademas de la version 0.1.0 del sandbox shikashi. La documentacion del gem (que incluye instrucciones de como instalarlo, ejemplos de uso y descripcion completa del API) esta en http://tario.github.com/shikashi/doc/

NOTA: tambien se puede instalar haciendo


gem install shikashi

Cosa que no menciona el README y lo actualizare en proximos releases.

Post-mortem debugging en linux

2010-06-19T11:51:00.005-03:00

Que es el debugging post-mortem

El debugging post-mortem es una clasica tecnica de debugging que consiste en que el sistema operativo genera un volcado completo de los registros, los threads y la memoria de un proceso que termina de manera anomala (ya sea por SIGSEGV o por SIGABRT), en linux estos volcados se llaman "cores" y se pueden examinar con gdb para ver en que punto del codigo ocurrio el error, los threads con sus backtraces, los registros, e incluso el valor de las variables (si se tiene informacion de debug) en el momento en que termino el proceso.

Como activarlo

Por default, en la mayoria de los sistemas linux viene desactivado, pero activarlo es tan simple como ejecutar en la terminal:


ulimit -c 4000000000

Que determina que el limite maximo para el tamaño del core sera de aproximadamente 4Gb (valores mucho mayores pueden ser rechazados a no ser que se tenga privilegios de root).

Esto solo tiene validez en la shell en la que se activo, si se necesita que este siempre activo para cualquier sesion, se podria agregar la linea "ulimit -c 4000000000" al final del archivo ~/.bashrc


echo ulimit -c 4000000000 >> ~/.bashrc

Como verlo funcionando

Se crea un programa de purebas, "mytest.c" que genera un error abort()


#include "stdlib.h"

int main()  {
abort();
}

Se compila generando informacion de debug y se ejecuta:


gcc -ggdb mytest.c -o mytest
./mytest

El programa falla y seguramente anunciara que se genero el core (en mi caso solamente el archivo generado se llama "core", en algunos sistemas pone el pid o cosas asi)

Se puede usar gdb para analizar el core, tambien hay que pasarle como parametro el ejecutable que genero el core para poder ver la informacion de debug:


gdb -c core mytest

A partir de entonces se puede examinar el estado que tenia el programa en el momento de finalizar como si se tratara de un debug normal:


(gdb) bt
#0  0x00007f55e7ef3a75 in raise () from /lib/libc.so.6
#1  0x00007f55e7ef75c0 in abort () from /lib/libc.so.6
#2  0x000000000040052d in main () at mytest.c:4
(gdb) info threads
* 1 Thread 4352  0x00007f55e7ef3a75 in raise () from /lib/libc.so.6
(gdb) disass main
Dump of assembler code for function main:
   0x0000000000400524 <+0>: push   %rbp
   0x0000000000400525 <+1>: mov    %rsp,%rbp
   0x0000000000400528 <+4>: callq  0x400418 
End of assembler dump.
(gdb) print/x $rcx
$4 = 0xffffffffffffffff
(gdb)

Deshacer el push en git

2010-06-18T18:18:00.017-03:00

Actualizacion: Quick fix

Alguien pusheo commits que no debia, o por alguna razon se pretende "deshacer" commits que ya se enviaron al servidor central.

Quick fix

Buscar el commit a donde se pretende volver: (usar git log o git reflog, etc...), y despues hay que ejecutar estos commandos (donde a_donde_volver se reemplaza por el commit):


git reset a_donde_volver
git checkout HEAD .
git push --force

Y a trabajar

NOTA: usar --force solo para casos especificos como este, ya que directamente sobreescribe cambios en la rama remota (que es lo que se pretende hacer en este caso)

Narrado (for dummys)

Todo lo que voy a explicar es asumiendo que se esta trabajando en la rama master (que es la default en git), si no estas trabajando en la rama master, el comando "git branch" muestra la rama de trabajo en la que estas trabajando

Antes, que nada, se puede hacer un tag del master actual:


git tag ultimo_master master

Posteriormente, hay que encontrar el commit al cual se quiere volver, se pueden revisar los logs (el nombre de la rama es opcional, si no se indica usa la rama de trabajo actual):


git log [master]

Supongamos que el commit al que se quiere volver es 0123456789abcd..., puede ser util taguearlo para referenciaro facilmente mas adelante (aunque se puede hacer todo referenciando al commit, directamente)


git tag a_donde_volver 0123456789abcd...

Posteriormente, se hace un reset a para que la rama master local referencie a ese commit, y despues un checkout para cambiar los archivos y que coincidan


git reset a_donde_volver
git checkout HEAD .

Despues, hay que sobreescribir la referencia master remota con la actual, pero hay que usar --force para que git no verifique si se trata de un fast-forward (porque sino rechaza la operacion), recordar usar --force solamente en casos especificos como este.


git push --force

Y despues se puede seguir trabajando normalmente

Bonus track

Puede ser util crear un branch en el servidor a partir del master original antes de que se revierta (para poder analizarlo entre todos, etc...), para hacer esto:


git push origin ultimo_master:refs/heads/old_master

Y en este post explico como usar los branches:

http://nilclass.blogspot.com/2009/08/branches-remotos-en-git.html

Solucion a sectores dañados en linux. EXT2 y EXT3

2010-06-16T13:14:00.004-03:00

Sintomas

El sistema se cuelga en tareas estupidas como reproducir una pelicula, instalar paquetes, configurar cosas, abrir determinados archivos para despues de un tiempo de estar "colgado" anunciar que hasta la tarea mas simple fallo por un "I/O error".

Hace falta confirmarlo tambien con los logs, la informacion necesaria aparece en el syslog (en /var/log/syslog ), se encontraran lineas similares a estas:


Jun 16 16:17:56 ubuntu kernel: [ 6193.840250] Buffer I/O error on device sda1, logical block 155153547
Jun 16 16:17:56 ubuntu kernel: [ 6193.840254] Buffer I/O error on device sda1, logical block 155153548
Jun 16 16:17:56 ubuntu kernel: [ 6193.840258] Buffer I/O error on device sda1, logical block 155153549

O tambien de estas:


Jun 15 20:16:01 ubuntu kernel: [   25.636424] ata1.00: status: { DRDY ERR }
Jun 15 20:16:01 ubuntu kernel: [   25.640935] ata1.00: configured for UDMA/133
Jun 15 20:16:01 ubuntu kernel: [   25.640951] ata1: EH complete
Jun 15 20:16:01 ubuntu kernel: [   29.172011] ata1.00: exception Emask 0x0 SAct 0x7fff SErr 0x0 action 0x0
Jun 15 20:16:01 ubuntu kernel: [   29.172013] ata1.00: irq_stat 0x40000008
Jun 15 20:16:01 ubuntu kernel: [   29.172016] ata1.00: failed command: READ FPDMA QUEUED
Jun 15 20:16:01 ubuntu kernel: [   29.172022] ata1.00: cmd 60/08:28:a7:74:3f/00:00:09:00:00/40 tag 5 ncq 4096 in
Jun 15 20:16:01 ubuntu kernel: [   29.172025] ata1.00: status: { DRDY ERR }
Jun 15 20:16:01 ubuntu kernel: [   29.176722] ata1.00: configured for UDMA/133
Jun 15 20:16:01 ubuntu kernel: [   29.176740] ata1: EH complete
Jun 15 20:16:01 ubuntu kernel: [   32.440790] ata1.00: exception Emask 0x0 SAct 0x7fab SErr 0x0 action 0x0
Jun 15 20:16:01 ubuntu kernel: [   32.440792] ata1.00: irq_stat 0x40000008
Jun 15 20:16:01 ubuntu kernel: [   32.440795] ata1.00: failed command: READ FPDMA QUEUED
Jun 15 20:16:01 ubuntu kernel: [   32.440801] ata1.00: cmd 60/08:48:a7:74:3f/00:00:09:00:00/40 tag 9 ncq 4096 in
Jun 15 20:16:01 ubuntu kernel: [   32.440805] ata1.00: status: { DRDY ERR }
Jun 15 20:16:01 ubuntu kernel: [   32.440807] ata1.00: error: { UNC }
Jun 15 20:16:01 ubuntu kernel: [   32.445770] ata1.00: configured for UDMA/133
Jun 15 20:16:01 ubuntu kernel: [   32.445785] ata1: EH complete

Solucion

Si algunos sectores del disco estan dañados sera inevitable que se pierda el disco entero tarde o temprano, por eso lo primero que se debe hacer es backup de toda la informacion.
Posteriormente, para poder seguir usando el disco, se debe hacer una revision completa marcando los bloques dañados como tal, el comando que hay que ejecutar es:


e2fsck -c /dev/sda1

Reemplazando /dev/sda1 por la particion que tengan que reparar.

Esto solo se puede hacer con la particion desmontada, para poder hacerlo asi recomiendo una de tres opciones:

1) Usar un live-cd como los de ubuntu, que les permite acceder a las particiones, tienen los comandos basicos y hasta entorno grafico para que puedan, por ej, escribir articulos en su blog publicando la solucion (es mi caso)

2) Usar una opcion de "rescue" (no estoy seguro si viene con ubuntu, pero viene con todos los fedora) eso les da una shell con privilegios de root pero nada de graficos, de ventanitas de gelatina, ni menos cubos de escritorio girando

3) Inician el sistema normalmente, y con Ctrl+Alt+F1 pasan a la consola sin graficos, ejecutan:


sudo init 1

Para pasar a runlevel 1 que detiene todos los servicios (incluyendo el entorno grafico) y permite desmontar cualquier particion, ahi ejecutan el escaneo y cuando termine vuelven a montar la particion y hacen


sudo init 5

Para volver a runlevel 5

Esta ultima es mas para "hackers" pero es innecesariamente complicada y me fracture el dedo indice cuando quise hacerla.

Renovado diseño del blog

2010-06-13T18:05:00.009-03:00

Tarde de domingo sin saber que hacer, renovacion visual del blog. Se hicieron los siguientes cambios.

* Se cambiaron los colores blancos, claros de blogs de psicologia newbies por colores darks, bizarros propios del underground, el H4X0R1NG, el KRAK0RING y PRHEKIRING aunque el blog NO PUBLICARA ARTICULOS DE ESA CATEGORIA :P (para eso hay blogs muy buenos en la web)

* Se cambiaron los colores del syntax highlighting en el style para que tenga sentido con los nuevos colores (todo dark) y se incluyo el style como tag en el template del blog para acelerar la carga de la pagina

* Se incluyeron todos los Javascripts de highlighting en el template del blog (en los tags ) en lugar de que sean referencia remota al sitio donde estaban alojados, con esto se acelera por mucho la carga de la pagina.

* Se cambio el fondo por uno de esos fondos "geeks" que hay en las opciones, pero como esto es ruby, se pinto de rojo (el original era azul)

Lo que mas me ayudo fue el plugin firebug para probar como quedan los colores antes de grabar en el template, y analizar un poco el source code de la pagina.
Tambien me sirvio bastante el irb para escapear el javascript, la libreria CGI:


require "cgi"
CGI.escapeHTML("<script>alert('hello world')</script>");
# => "&lt;script&gt;alert('hello world')&lt;/script&gt;"

Espero que la experiencia blogger sea mas ruby ahora

Definicion de clases y metodos en un eval

2010-05-29T21:27:00.005-03:00

Una de las miles de cualidades que tiene ruby como lenguaje dinamico es la ejecucion de codigo ruby contenido en un string mediante el uso de la funcion eval.
Asi se pueden hacer cosas bastante interesantes ejecutando codigo ingresado dinamicamente ^_^
No obstante es necesario conocer como sortear determinados obstaculos en la ejecucion de codigo dinamico


class Runner
    def run(code)
        eval(code)
    end
end

runner = Runner.new

# ¡¡FAIL!! :(, no se puede definir classes desde adentro de un metodo (Runner#run)
runner.run("
    class X
        def foo
            print \"hello world\n\"
        end
    end
    
    x = X.new
    x.foo
    ")

Lo que se intento hacer en el ejemplo anterior, para el interprete es equivalente a:


class Runner
    def run(code)
       # いけない！!! 
       # en ruby no esta permitido definir clases adentro de metodos
       # (aunque si permite hacer otras cosas locas XD )
       class X 
           def foo
                print \"hello world\n\"
           end
       end
    
       x = X.new
       x.foo
    end
end

Para poder hacerlo correctamente hay que pasarle un segundo parametro a eval que es el "binding", un binding representa el contexto en ruby de donde se llama el binding, que incluye las variables locales, etc... mejor verlo en el ejemplo que explicarlo:


class Runner
    
    class << self
        attr_accessor :runner_binding
    end
    
    def run(code)
        # se especifica un binding al eval para definir el contexto
        # en el que se ejecuta el codigo
        eval(code, Runner.runner_binding)
    end
end

# se copia el binding del contexto actual (fuera de cualquier clase o metodo)
Runner.runner_binding = binding

runner = Runner.new

# se puede definir clases en el codigo pasado a eval, porque el binding
# esta afuera de cualquier declaracion de clase o metodo y el eval se
# llama con ese binding
runner.run("
    class X
        def foo
            print \"hello world\n\"
        end
    end
    
    x = X.new
    x.foo
    ")

Que para el interprete es lo mismo que reemplazar el codigo en donde se llama a binding en lugar de en donde se llama a eval:


class Runner
    
    class << self
        attr_accessor :runner_binding
    end
    
    def run(code)
        # se especifica un binding al eval para definir el contexto
        # en el que se ejecuta el codigo
        eval(code, Runner.runner_binding)
    end
end

# よろしい
# Runner.runner_binding = binding
    class X
        def foo
            print \"hello world\n\"
        end
    end
    
    x = X.new
    x.foo

Y ya que estamos, les cuento que otra cosa tiene el eval para hacer


def bar
  1/0 # ZeroDivisionError
end

def foo(code) # ¿porque siempre foo?
eval(code)
end

foo("bar") #

Resultado:


test.rb:6:in `foo': test.rb:2:in `/': divided by 0 (ZeroDivisionError)
 from test.rb:2:in `bar'
 from (eval):1:in `foo'
 from test.rb:9:in `eval'
 from test.rb:6:in `foo'
 from test.rb:9

Mejor, pasarle unos argumentos adicionales a eval especificando el "archivo" y el numero de linea de donde viene el codigo evaluado


def bar
  1/0 # ZeroDivisionError
end

def foo(code) # ¿porque siempre foo?
eval(code, binding, "foo_eval.rb", 1)
end

foo("bar") #

Resultado:


test.rb:2:in `/': divided by 0 (ZeroDivisionError)
 from test.rb:2:in `bar'
 from foo_eval.rb:1:in `foo'
 from test.rb:6:in `foo'
 from test.rb:9

Ahora se puede ver mejor en el backtrace de donde viene el codigo, con esto mejorada la trazabilidad cuando se usa eval.

¡Cuidado! Pizza Radioctiva

2010-05-06T10:01:00.007-03:00

Ficha tecnica:

Radiancia: 5.9 Kilopluts a temp. ambiente
Queso: 1.8 Kilogramos
Tomate: 4.5 Terawatts

Aceitunotones nominal: 2 (ya disipados)
Vida Media: 9 minutos desde la salida del horno

Como escribir una extension ruby en C en 5 minutos

2010-03-24T15:58:00.004-03:00

Lo siguiente toma lugar entre las 15:51 pm y las 15:56 pm

Para crear una extension en ruby lo primero que hay que hacer, es crear el "extconf.rb", basicamente tiene que tener el siguiente contenido:


# extconf.rb
require 'mkmf'

dir_config("exttest")

create_makefile("exttest")

Posteriormente, hay que crear el archivo del codigo fuente en C de la extension, que minimamente tiene que haber uno, en este caso creamos uno de prueba, bastante resumido, el cual crea un modulo ruby y le define dos metodos, ambos implementados en C:


// exttest.c

#include "ruby.h"

static VALUE foo(VALUE self) {
 printf("Foo invoqued\n");
 return Qnil;
}

static VALUE sum(VALUE self, VALUE a, VALUE b) {
 return INT2NUM( NUM2INT(a) + NUM2INT(b) );
}


void
Init_exttest()
{
 VALUE rb_exttest = rb_define_module("Exttest"); // definir el modulo
 
 rb_define_singleton_method(rb_exttest, // en que modulo
   "foo", // nombre del metodo
   foo, // puntero a la implementacion C del metodo
   0 // cantidad de argumentos del metodo
   );

 rb_define_singleton_method(rb_exttest, // en que modulo
   "sum", // nombre del metodo
   sum, // puntero a la implementacion C del metodo
   2 // cantidad de argumentos del metodo
   );
 
}

Para generar el makefile (solo hay que hacer esto una vez), se ejecuta el script extconf.rb:


ruby extconf.rb

Para construir la extension, se debe lanzar el siguiente comando:


make

Eso genera, entre otros archivos intermedios, extconf.so, el cual contiene la extension misma compilada a codigo nativo de la plataforma donde estan corriendo todo, para instalarla en el sistema, hay que correr (como root):


make install

Para usar la extension:


# test.rb
require 'rubygems'
require 'exttest'

Exttest.foo # el metodo foo definido en exttest.c!!
print Exttest.sum(4,9),"\n" # el metodo sum definido en exttest.c!!

Posteriormente, se pueden hacer cosas mas interesantes como definir clases, clases anidadas en modulos, metodos, etc...
Para la proxima voy a explicar como encapsular la extension como gem y distribuirla

links:

* http://onlamp.com/pub/a/onlamp/2004/11/18/extending_ruby.html: Fuente que inspiro este articulo y ejemplo practico de como wrappear la libreria GenX como libreria ruby GenX4r
* http://rhg.rubyforge.org/chapter04.html: Tutorial que muestra como definir clases y modulos
* http://ruby-doc.org/doxygen/1.8.4/group__ruby__interp.html: Documentacion completa de funciones C para definir extensiones de ruby incluyendo funciones de conversion de datos

En github solo se tarda 60 SEGUNDOS

2010-03-10T09:58:00.003-03:00

Esta mañana, entre a la internet con la idea de migrar un proyecto que tenia en googlecode (con svn) a git (y el mas conocido repositorio gratuito en internet de git es github)
El hecho de tener que migrar commits de svn a git ademas de la registracion, setup del repo git y demas cosas me hacian imaginar q seria una experiencia de trabajo.
Pero me soprendi: no solo registrarse y crear el repositorio fueron tres simples clicks, sino que tambien hay literalmente un boton "migrar SVN a GIT" en el cual solo te pedia la url del servidor svn... tras la operatoria (que encima fue rapida), pude ver mis commits convertidos a git.
Asi que el que este entusiasmado con git, sabe que no solo puede registrarse facilmente a un repositorio git gratuito sino que puede tambien migrar cualquier repositorio de svn para no perder la valiosa informacion de los commits en la mudanza.

Enlaces:

GitHub:
http://github.com/

GoogleCode ( Aun asi esta bueno si quieren usar un repo svn y el issue-tracker les puede gustar :) ):
http://code.google.com/

Analisis de mergeo en git

2010-02-24T09:53:00.005-03:00

Cada vez que se mergea una rama en otra, es necesario conocer que modificaciones se estarian introduciendo concretamente en la rama de destino antes de proceder al mergeo mismo.

El comando git-merge-base permite saber cual es el "common parent" de dos commits dados, es el "merge-base" el que define que segemento de cambios se incluiran al hacer el mergeo.

Supongamos que se quiere mergear a la rama xxxxx, los cambios de la rama yyyyy, pero antes se desea conocer que cambios se incluiran


# se cambia la rama de trabajo a yyyyy
$ git checkout yyyyy

# se busca el "merge base
$ git merge-base HEAD xxxxx
123456789abcdef

# se analizan los cambios que se incluiran viendo el segemento de cambios desde el merge-base
# hasta el ultimo commit de xxxxx
$ git log 123456789abcdef..xxxxx
( aparece una enumeracion de los commits que se van a incluir si se procede al mergeo)

# o tambien, se podria
$ git log $(git merge-base HEAD xxxxx)..xxxxx
( aparece la misma salida que del comando anterior)

# si se aceptan los commits vistos en el log, se procede al mergeo
git merge xxxxx

NOTA: Ademas de usar estos practicos comandos ayuda bastante mantener una nomeclatura y una gestion ordenada de las ramas que permitan tener en claro cuales son los "merge-base" de los mergeo que se ejecutaran.

Recuperar commits "perdidos" en git

2009-12-09T22:32:00.003-03:00

Cada tanto puede pasar que de checkout en checkout, nos encontramos con:

"¡oh no!, todos los commits que hice hoy no estan en la rama, incluso nisiquiera se donde estan"

Pareciera que todo el trabajo del dia quedo "perdido", pero no es asi, si se commiteo, esos commits estan en alguna parte... quiza no apuntados por ninguna referencia, pero estan.

Una de las maneras mas practicas de encontrarlo es usando el comando


git reflog

Que da por salida un registro de las operaciones que se hicieron, algo como esto:


8705300... HEAD@{0}: commit: aplicado metodo para desactivar los metodos privado
104683b... HEAD@{1}: commit: corregida restauracion de constantes
0a714ab... HEAD@{2}: commit: corregido error
f47b0e6... HEAD@{3}: commit: implementado metodo para activar y desactivar privi
7760e03... HEAD@{4}: commit: definido metodo permit, para definir muy facilmente
2936507... HEAD@{5}: commit: renombrado metodo para preguntar el permiso para ej
93757af... HEAD@{6}: commit: agregados enable y disable privileges con prints
4a2e9c3... HEAD@{7}: commit: agregado metodos para crear bloques unprivileged y
f19eb66... HEAD@{8}: commit: completado holder de manera que puede tener el codi
abc82d0... HEAD@{9}: commit: separado metodo create_holder
5185142... HEAD@{10}: commit (initial): primer commit

Incluye los "SHA1" de los commits hechos recientemente, de los cuales se pueden tomar los cambios y enviarlos al lugar correspondiente con git merge, crear branches o lo que sea necesario hacer.

Sandbox de codigo ruby

2009-11-29T11:58:00.005-03:00

La semana pasada empece el desarrollo de una libreria de ruby que permita crear "sandbox" de codigo ruby

Un sandbox (traducido literalmente del ingles como "caja de arena") es un entorno "protegido" que permite ejecutar programas de una manera en la que no es posible que estos programas afecten a lo que esta "afuera" del sandbox (Por ej: ejecutar un programa de manera que no pueda tener acceso al sistema de archivos de la computadora en la que se esta ejecutando)

Para el caso particular de ruby, cuando se da, por ejemplo, el caso del desarrollo de una plataforma que ejecuta dinamicamente codigo enviado por muchos usuarios... es esperable que este codigo no pueda acceder al sistema de archivos o a la bases de datos de la aplicacion (el caso de una aplicacion Rails). En ese caso un "sandbox" que encierre al codigo en su ejecucion restringiria la ejecucion de codigo no deseado.

En lo que se ve a simple vista en la web, no hay mucho desarrollo al respecto... y lo que hay pareciera ser plugins algo mas especificos de rails como acts_as_runnable_code. Es por eso que comence el proyecto arena-ruby-sandbox, que define la posibilidad de ejecutar el codigo asi:


require "sandbox"

class X
 def foo(a)
  print "foo(#{a})\n"

  # estoy afuera del sandbox, por lo tanto puedo
  # hacer cosas "privilegiadas" como crear archivos
  # cosa que no puede hacerse desde adentro del sandbox
  File.open("foo.txt") do |f|
   f.write "foo(#{a})\n"
  end

  a+5
 end

 def foo_no_invocable
  print "foo_no_invocable\n"
 end
end

# instanciar el sandbox
s = Sandbox::Sandbox.new

x = X.new

s.serivice_provider = x
# indica que el metodo foo se puede ejecutar desde adentro del sandbox
s.permit :foo

print s.run("2+2") # => 4

print s.run("foo(2)") # => 7 (y escribe el archivo foo.txt con "foo(2)" )

print s.run("foo_no_invocable") # => NoMethodError (nunca se especifico que foo_no_invocable se podia invocar)

s.run("
 File.open('foo.txt') do |f|
  f.write \"foo\n\"
 end
")  # => NameError: uninitialized constant File
  # ( la clase File no existe adentro del sandbox
  # no se puede acceder al filesystem desde el sandbox

links

http://arena-ruby-sandbox.googlecode.com

Autocarga perversa

2009-11-24T20:11:00.005-03:00

Textualmente, la rdoc del core de ruby, dice asi:

mod.const_missing(sym) => obj

Invoked when a reference is made to an undefined constant in mod. It is passed a symbol for the undefined constant, and returns a value to be used for that constant. The following code is a (very bad) example: if reference is made to an undefined constant, it attempts to load a file whose name is the lowercase version of the constant (thus class Fred is assumed to be in file fred.rb). If found, it returns the value of the loaded class. It therefore implements a perverse kind of autoload facility.


 def Object.const_missing(name)
   @looked_for ||= {}
   str_name = name.to_s
   raise "Class not found: #{name}" if @looked_for[str_name]
   @looked_for[str_name] = 1
   file = str_name.downcase
   require file
   klass = const_get(name)
   return klass if klass
   raise "Class not found: #{name}"
 end

Esa funcion puede utilizarse para implementar "alguna clase perversa de mecanismo de autocarga", para citar un ejemplo, rails lo utiliza como parte de su funcionamiento habitual para recargar las clases automaticamente sin necesidad de reiniciar el servidor ni ejecutar ningun comando explicito (¿rails = perversion?, esto me emociona).

links

http://ruby-doc.org/core/classes/Module.html#M001693

http://www.google.com.ar/search?q=%22It+therefore+implements+a+perverse+kind+of+autoload+facility%22

Web-Base Real Time Syntax Highlighting

2009-11-22T21:06:00.010-03:00

Codepress es un editor de codigo fuente, que funciona 100% en javascript (del lado del browser) haciendolo muy simple de instalar y utilizar, por ejemplo, pueden editar el siguiente fragmento de codigo:

NOTA: puede que el highlighting no sea tan "automagico", pero seguro se refresca cada vez que se teclean las comillas dobles... despues cualquier cosa se investiga mas la herramienta...

NOTA2: Todavia no pude hacer andar bien el editor en el contexto del blog... pero al final estan todos los links a las paginas de prueba que muestran todo el potencial de la herramienta

Pagina de demo de codepress: http://bobdawg.org/codepress/
Descarga del paquete: http://sourceforge.net/projects/codepress/files/codepress/codepress-v.0.9.6/
Mi pagina de prueba: http://codepress-test.coolpage.biz/codepress/prueba.html

Tags remotos en git

2009-08-31T10:47:00.007-03:00

Correccion: parametros de git push cambiados para que el envio de la ref sea mas propio

Otro elemento importante que aporta el versionador git, son los tags... No es muy intuitivo tampoco como hacer que los tags sea remotos, pero es parecido a como se hacen los branches e incluso mas simple (ya que no hay nada que trackear)

1) Enviar al repositorio central el ref de ese tag (en el ejemplo es el actual commit)

git push origin HEAD:refs/tags/nombre_del_tag

Este comando envio el "ref" local refs/tags/nombre_del_tag al servidor con el nombre refs/tags/nombre_del_tag
Cuando alguien haga pull del repositorio central recibira los tags y va a poder trabajar con ellos como si los hubieran creado con git tag en su repositorio.

Branches remotos en git

2009-08-31T09:40:00.008-03:00

Git es un poderoso sistema de gestion de versiones, que entre otras cosas, esta pensado para gestionar branches ( cosa que por ej svn no tiene ), al ser git descentralizado y al ser de uso comun con varios repositorios para un mismo proyecto, surge la necesidad de crear ramas de manera distribuida tambien, algo que no es muy intuitivo.

1) Con git push se crea el branch en el repositorio remoto (en este caso origin), asi de simple

git push origin HEAD:refs/heads/nombre_del_branch

2) Despues tenemos que asegurarnos de tener actualizado el repositorio

git fetch origin

3) Verificamos que el branch remoto ha sido creado

git branch -r

4) Generar un branch local que "trackee" el branch remoto

git checkout --track -b nombre_del_branch origin/nombre_del_branch

Ese ultimo comando crea un branch local que "trackea" el branch que se creo antes en el repositorio remoto. Y con trackear implica que los cambios y commits del branch remoto vendran a este branch local al hacer git pull e iran de nuestro branch remoto al hacer git push.

Fuente: http://www.zorched.net/2008/04/14/start-a-new-branch-on-your-remote-git-repository/

Ruby RAII

2009-07-16T23:44:00.003-03:00

RAII (Resource Acquisition Is Initialization) es una técnica aplicable en muchos lenguajes de programación como C++ y los lengujaes .net que sirve para asegurar que la liberación de un recurso siempre se llevara a cabo al cerrarse un bloque de código sin importar que evento ocurrise (retorno de una funcion, excepcion, etc...). Ruby por supuesto que cuenta con esta posibilidad a través del uso de métodos con bloques de código (palabra clave yield)

He aqui un ejemplo:


#
# La clase X tiene un metodo open para inicializar (open)
# Y uno para cerrar, seria una tragedia si el metodo open
# se invocara y no se invoque el close correspondiente al final
#
#
class X
 def open( argument1, argument2 )
  print "open with argument1=#{argument1} and argument2=#{argument2}\n"
 end

 def operation1
  print "running operation1\n"
 end

 def operation2
  print "running operation2\n"
 end

 def close
  print "closing\n"
 end
end


#
# Mejor usar RAII
#

class X
 def self.open( *args )
  x_instance = X.new
  x_instance.open( *args )
  begin
   yield(x_instance)
  ensure
   x_instance.close
  end
 end
end


#
# Y se usa asi
#
X.open( "arg1", "arg2" ) do |x|
 x.operation1
 x.operation2
end

Espero que os haya iluminado

NilClass horror

2009-06-23T11:19:00.003-03:00

Un horror



# el nil class es la clase de la cual nil es instancia
class NilClass
  # todo metodo desconocido que es invocado sobre el nil
  def method_missing(method_obj,*args)
     method_obj.to_s
  end
end

print nil.koiiiewiiriieiw,"\n"

print @oooooooooooooooooooooo.blahhhhhhhhhhhhhhhhhhhhhhhhh,"\n"
print @ewewewwwewo.dakishimetakokoronokusumo,"\n"

# un horror
print $uqhwuiqwhrqrqwrkjwqhrjkqwhrqwkjrhqwrjkwqrhkqwrjqwrj.l,"\n"

Un horror

Comparacion de rangos

2009-06-21T14:10:00.002-03:00

Es muy común al programar, encontrarse con la necesidad de verificar algún rango de algo:


# la manera "dificil"
if a > 3 and a < 9 then
   print "a esta entre 3 y 9\n"
end

Mejor asi, usando el operador ===


# la manera "canchera"
if (3..9) === a then
   print "a esta entre 3 y 9\n"
end

Como si esto fuera poco, el operador === tiene todos los usos que uno se pueda imaginar, como por ej, para verificar si un texto matchea una expresion regular:


# la manera "canchera"
if  /^ruby/ === txt then
   print "'#{txt}' tiene ruby al principio\n"
end

Y si se les da la gana, pueden usar este operador en sus propias clases (también obviamente definirlo o redefinirlo para la clase existente que quieran)



class X
   def ===(a)
      print a,"\n"
   end
end

Ruby hooking

2009-06-05T10:33:00.004-03:00

Les traigo un truco que los asombrara... con una tenica de hooking aplicada al ruby para poder enganchar los metodos que quieran de cualquier objeto y controlar su ejecucion, asi como registrar llamados a ese metodo , filtrar cosas, etc.

Aca el module q lo hace posible:

hooking.rb


module Hook
 def hook( method_name, hook_name = nil, old_method_name = nil)
  
  obj = self
  
  # si no se le pasa el nombre de la funcion que controla el hook
  # arma un nombre de funcion
  hook_name ||= "#{method_name}_hook" 
  
  #lo mismo con el nombre de la variable de instancia
  # que almacena la referencia al metodo original
  old_method_name ||= "__old__#{method_name}"
  
  # almacenar el metodo original
  eval("@#{old_method_name} = self.method( method_name.to_sym)")
  
  # redefinir el metodo para que invoque el metodo de hook, pasandole
  # un bloque de codigo que ejecute el metodo original, entonces el metodo
  # de hook puede invocar al metodo original usando yield
  eval("
  def obj.#{method_name}(*x)
   self.#{hook_name}(@#{old_method_name},*x) do |*x|
    yield(*x) if block_given?
   end
  end
  ")
  
 end
end

class Object
 # includir el modulo de Hook en Object para que se pueda aplicar a todo Object
 include Hook
end

Y ahora un pequeño ejemplo de como podria usarse

main.rb


require "hooking"

class X

 def foo( num )
  print "metodo foo invocado con num = #{num}\n"
 end
 
 def bar 
  print "metodo bar invocado\n"
  [1,2,3].each do |x| yield(x) end
 end
 
end

x = X.new

x.hook(:foo)

def x.foo_hook( foo_original, num )
 print "foo invocado\n"
 
 # se invoca al metodo original, pero alterando los parametros
 foo_original.call( num+1)
 
 print "fin de foo\n"
end

x.hook :bar
def x.bar_hook(  bar_original )
 
 print "bar invocado\n"
 
 bar_original.call do |x|
                # tambien se puede alterar y controlar
                # el uso de yield del metodo
  yield(x+2)
 end
 
 print "fin de bar\n"
end


x.foo(3)
x.bar do |x|
 print x,"\n"
end

Me olvide de mostrarles el mirror rubik

2009-06-03T23:19:00.002-03:00

Salio hace com 80 mil años, jaja, vean este video:

Y el video REVIEW:

Programacion ruby EN un celular :p

2009-04-21T14:04:00.008-03:00

No pude evitar observar la palabra clave del ruby "def" (se usa para DEFinir metodos en ruby) en una de las teclas del celular, asi que imagine: esto esta pensado para programadores de ruby, en seguida me puse a pensar como seria programar EN un celular:


# para pner cmtrios ay q scrbrlos tods asi
# est mtodo c pue d usr cmo print
def abc(ghi)
print ghi,"\n"
#porq noay na tcla cn "end" en l celu?
end
abc "hla mndo!"
abc "cmo ests"

Aprendiendo git-svn en 5 minutos

2009-03-15T16:03:00.011-03:00

Este finde estuve viendo las posibilidades que tiene git-svn, nunca use git pero me llamo mucho la atención el manejo que tiene de múltiples repositorios, cuya primera utilidad que le vi es poder trabajar "offline", es decir, sin acceso al repositorio central, y mantener la granularidad de los commits ya que se puede commitear al repositorio "local" cuantas veces se quiera hasta que en un momento se mandan todos los commits en un "push". En el caso de git-svn, se pueden visualizar y analizar en los logs del servidor SVN cada uno de esos commits como si hubiese mandando cada uno de ellos de manera "normal". git-svn también puede ser de agrado para los fanáticos de git cuando se vean forzados a trabajar con un repo svn y seguramente tiene un sin-fin de utilidades mas.

Actualizacion: Usuarios de svn pueden aprender git de una manera muy facil en Git - Svn Crash Course

Lo primero y principal para utilizar esta herramienta es instalarla, yo que uso fedora, me basto con:


yum install git-svn

Seguramente, para los usuarios de debian y afines sera suficiente (corrijanme si me equivoco):


apt-get install git-svn

Posteriormente, se aprende como utilizar la herramienta para clonar un repositorio SVN para los usuarios de git, o "checkautear" usando git, para los usuarios de svn:


git-svn clone $URL

Donde $URL es la url completa del servidor svn como "file:///usr/srv/svn/proyecto" o "http:///www.websvn.com/svn/proyecto", lo que hace el comando, es crear una copia local del repositorio SVN, al estilo de git, esto equivale al checkout de svn y por lo tanto solo debe hacerse la primera vez, obviamente es necesario tener acceso al repositorio para poder hacer esto

A partir de haber clonado el repositorio, ya se puede trabajar con el repositorio local, para los que sean usuarios de git es simple: es lo mismo que en git (guarda al final que no se pushean los cambios de la misma manera), y para los que no conocen el maravilloso mundo de git, también es sencillo, simplemente hay que ejecutar el siguiente comando con cada commit:


git commit archivo -m 'mensaje'

El comando es igualito al de svn, pero tengan presente de que este comando "commitea" solo al repositorio local, el que se clono al principio, asi mismo NO requiere acceso al repositorio ni ninguna conexión con el, pueden hacer este commit todas las veces que hagan faltan sin necesidad de contactar al repositorio.

Cuando logran conexión con el repositorio o cuando lo crean conveniente, llega la hora de hacer el "push" (mandar todos los commits que se hicieron local al repositorio central), el comando el siguiente:


git-svn dcommit

Cuando ejecuten el comando, verán como git-svn manda cada commit que se efecto localmente desde la que se clono el repo o se hizo el ultimo dcommit, y lo mas importante, lo que da todo el sentido a esto: a cada commit que efectuaste con "git commit", le corresponde UN commit de svn que puede analizarse y verse en los logs del servidor svn por cualquier otro usuario y con las herramientas svn clásicas.

Bueno, esto fue git-svn para Fedora 32 y espero que les haya gustado. Chau!!!

Try ruby (in the NilClass Blog)

2009-03-11T22:10:00.002-02:00

Cableando algunos iframe por ahi logre incorporar el interprete de ruby que anuncie en el post anterior directamente inscrustado en ell blog, para ahorrarles ir a la otra pagina ;), prueben el ruby!!!

Try ruby! (in your browser)

2009-03-11T21:37:00.003-02:00

Actualizacion: la nueva direccion de tryruby es http://tryruby.org/

Buscando algun applet o algo asi para acercarles el ruby en este blog para que puedan palpar la magia de ruby sin nececidad de que se instalen nada, me encontre con http://tryruby.org/, una pagina muy curiosa que te ofrece un tutorial de ruby con interprete incluido en la pagina!, es decir, podes aprender ruby como Yukihiro manda sin necesidad de bajarte ni instalar nada. En lo proximo.

FreeMind, la exprimidora de jugo mental

2009-03-07T00:01:00.005-02:00

El Jueves que pasado, tratando de hacer algo bueno para el rsif, no se me ocurria que cosa buena programar, ni ninguna parte del soft que diseñar, ni siquiera ideas que documentar. Ocasion ideal para utilizar la aplicacion que les voy a comentar: se trata del Freemind. El freemind es un programa que te permite hacer brainstorming, es decir, volcar a algun lugar las ideas flotando en la intangibilidad de la conciencia antes de que migren a olvidolandia, tambien permite multiplicar facilmente las ideas de varios participantes en un grupo de trabajo. Para poder hacer eso, te permite crear "mapas" que son arboles (como el que se ve en la imagen) o una "mariposa" lleno de ideas que descargas directo de tu atormetado cerebro (o varios cerebros si es un grupo) por intermedio del teclado y mouse; los nodos del arbol que podes ir armando, contienen simplemente cualquier texto que se quiera poner, a los que se le pueden añadir cualquier cantidad de iconos. Al final, se obtendra como resultado un map "mariposa" cuyas alas estan hechas de las ideas que se crearon/escribieron y cuya utilidad es obvia.

Sitio oficial de freemind: http://freemind.sourceforge.net

El pentaminx es una cosa de locos

2009-03-05T21:42:00.005-02:00

Es un rubik pero en version dodecaedro diabolico (con pentagrama en cada cara), por si el V-cube 6 del post anterior te parecia para bebes, podes disfrutar del reto que ofrece el Pentaminx, el cual consta de 12 hyper-enfermizas caras dividas en aproximadamente 100 partes de las cuales 20 de ellas son secciones de las puntas de la estrella central y una es un pentagono interior. El mounstruo esta hecho de un total de 975 piezas, y se dice que el record mundial de resolucion mas rapida fue de 75 horas

De finales a RSIF

2009-03-04T21:29:00.004-02:00

Complete la agonizante fase de examenes, sin entrar en detalles como me fue, solo voy a decir que lo unico que me interesa es volver al proyecto de rsif, la vuelta a rsif va a ser con un nuevo planteo el cual van a poder conocer leyendo el blog de rsif e implicara cambios muy importantes acerca de la metodologia de desarrollo apuntando a mejorar el uso, la utilidad, la flexibilidad y lograr objetivos practicos con el framework.

El proyecto hara ignicion en un mega-post tras algunos dias de meditacion extrema, ruby testing y filosofia ruby

V-Cube 6x6x6 Resuelto en 3 minutos y 28 segundos

2009-02-12T15:35:00.004-02:00

Este chabon resuelve el V-Cube de 6x6x6 en 3 minutos y 28 segundos, por si no lo sabían, el de 6x6x6 existe materialmente e incluso hay algunos como los del video que resuelven asi:

openVPN temporal rapida y practica en linux

2009-02-11T17:17:00.004-02:00

Con estos comandos, pueden crear una vpn de manera muy rápida y sencilla con openvpn, y sin necesidad de "configuración", si por alguna urgencia necesitan vpn...

En el server:


openvpn --proto tcp-server --lport 9000 --dev tun0 --ifconfig 10.4.0.1 10.4.0.2

En el client


openvpn --proto tcp-client --rport 9000 --remote DIRECCIONIPREMOTA --dev tun0 --ifconfig 10.4.0.2 10.4.0.1

NOTA: asegúrense de que no colisionen las ips del ifconfig y que los puertos sean accesibles (en el ejemplo el 9000),

NOTA: pueden no especificar el proto, y utiliza el protoclo por defecto UDP

Forma elegante de expresar el codigo ascii de un caracter especifico

2009-02-11T14:51:00.003-02:00

Simplemente hay que utilizar el operando "?", anteponiendo lo al carácter del cual se quiere obtener el código ASCII, en el siguiente ejemplo se usa "?A" para obtener el código ASCII de la letra A mayúscula


# el abecedario en mayúsculas
# la funcion chr convierte un numero al carácter que representa en ASCII
print (0..25).map{|x| (?A+x).chr}.join(" ")

Ampliar la funcionalidad de una clase existente

2009-02-06T15:43:00.005-02:00

Hola, estamos viendo el ruby para PC, y hoy les voy a pasar un truco para agregarle funcionalidad a una clase ya existente en el lenguaje (también otra que se haya definido de la manera que sea, puede ser extendida )

Supongamos que no nos gusta que el metodo para convertir a entero de la clase String, se llame to_i, y nos parece mejor idea que se llame to_integer



class String
   def to_integer
      to_i
   end
end

print "99".to_integer + 1, "\n"

Lo que hicimos fue definir de manera parcial la clase String, esto es, definirle los métodos que queramos a String, obviamente manteniendo también los métodos originales de la clase String

Bueno, esto fue ruby para PC, y espero que les haya gustado, chau

Usa yield, por que si no lo usas se oxida

2009-02-06T11:56:00.004-02:00

Sin duda, yield es un elemento muy poderoso de estos lenguajes de programación "modernos", en definitiva, lo que yield hace es invocar el bloque de código que se le paso por parámetro a un método especifico. Un ejemplo



def foo(x)
   if x < 3
      yield
   end
end

foo(2) { print "hola mundo" }

Con la sola definición de yield no es sencillo darse cuenta rápidamente de como podría aplicarse, pero para que se den una idea, todos los métodos del array que reciben bloques estan implementados usando yield, estos son (entre otros), each, inject, select, find, etc..., también métodos como synchronize del mutex usan yield con propósitos de RAII y con un sin fin de aplicaciones. Aca otro ejemplo:



# compone cualquier funcion dos veces, toma como inicio el parámetro
def compdouble(x)
  yield(yield(x))
end

# devuelve x*x*x*x = 81 (composicion doble de x*x)
print compdouble(3){ |x| x*x }, "\n"

también puede servir para pasar expresiones como parámetros, que solo seran evaluadas si se necesitan, la siguiente idea se aplico en el logger de rsif



# invocamos logger.info con parametro normal, entonces el
# interprete siempre evalúa la expresión
# para pasarle el parámetro a logger.info,
#sin importar si logger info vaya a loguear o no
# aveces evaluar determinadas expresiones conlleva
# a invocar metodos, accesar a bases de datos,
# hacer calculos, etc..

logger.info Locale.hello_world

# Es mejor si en lugar de pasarle el paremetro
# normalmente, se lo pasemos en un bloque
# entonces el bloque solo sera invocado
# si el parametro necesita ser evaluado, es decir
# cuando el metodo decida que va a loguearlo, definitivamente

logger.info { Locale.hello_world } # las llaves hacen que se pase el bloque de código

# pseudo-codigo resumido de logger.info:

def logger.info( x = nil )
  if loguear
     if block_given?
         print yield,"\n"
     else
         print x,"\n"
     end
  end
end

Otro ejemplo es la implementación de visitor pattern usando ruby, con yield es muy cómoda de implementar y también de usar (el link que les pase hace la comparativa entre la implementación de lo mismo en varios lenguajes)

Espero que les haya sido de utilidad, hasta el próximo post

¿Porque pasa? Grave vulnerabilidad de ejecucion de codigo en el kernel 2.6.28 (y otros)

2009-02-02T19:12:00.004-02:00

Asi como le escucharon, salio un nueva vulnerabilidad del kernel 2.6.28 con impacto de ejecución remota de código ( o Denial of service, segun el caso ), aca una copia de la nota original, de watchmouse:

------------------------------------------------------------------------------------------------------------------------

The Linux Kernel is prone to a remote buffer-overflow vulnerability because the software fails to perform adequate boundary checks on user-supplied data.

An attacker can exploit this issue to execute arbitrary code with kernel-level privileges. Successfully exploiting this issue will result in the complete compromise of affected computers. Failed exploit attempts will result in a denial-of-service condition.

The issue affects Linux Kernel 2.6.28; other versions may also be vulnerable.
------------------------------------------------------------------------------------------------------------------------

Que bueno que en el software libre estas cosas se corrigen rapido, lo mas que podemos hacer es actualizar el kernel y ya hay una versión patcheada, o parchearlos nosotros mismos si esta a nuestro alcance

La nota original de la pueden leer aca

En securityfocus pueden ver mas información acerca de la vulnerabilidad, las versiones afectadas del kernel, etc...

net-security también publico una nota

Comenzo el proyecto RSIF (hace un rato)

2009-01-31T00:50:00.003-02:00

Buscando una excusa interesante para hacer un proyecto en ruby, me encontre con que no habia ninguna herramienta de sql injection automatizado (hecha por mi). De ahi que comenze con el proyecto Rsif. Rsif significa Rsif Sql Injection Framework, y es lo que dice (o mejor dicho, quiere ser :p ), y lo mas orientado posible a la participacion de cualquiera.

Si quieren mas informacion, pasense por el blog de rsif, que es el que motivo este articulo, en primer lugar

El Ruby brilla y refleja: local_variables y demas

2009-01-29T22:53:00.007-02:00

Para los que no saben, en el scope de cada metodo en ruby nacen las variables locales (y mueren si no "trascienden", pero eso es asunto de otro post), ruby tiene algunas variables predefinidas en toda funcion que pueden hacer cosas interesantes, una de ellas es "local_variables", la cual es un array de todas las variables locales definidas hasta el momento, se puede usar de la siguiente forma:


a = 1
b = 2
c = 3

local_variables.each do |vn|
   print "#{vn}=#{eval(vn)}\n"
end

eso devuelve por la salida:


a=1
b=2
c=3

Las utilidades que pueden darle a esto les dejo a su imaginacion

Todo mal, Diego Gomez es un clone, frakin cylon machine

2009-01-19T22:33:00.010-02:00

La verdad que no me esperaba una tragedia como esta, al parecer, mi amigo y compañero de trabajo tiene sangre de mentira en las venas, una fuente ATX en lugar de corazón y un destello rojo en vez de alma :(, esto lo descubri buscando el blog de Dieguito por la web para encontrarme con que se vislumbran dos copias de este modelo de cylon:

* Diego Gomez "phantom", tiene un blog, es aficionado a la tecnología, la web, el software libre y el humor (usa debian)

* Diego Gomez "deck", tiene un blog, es aficionado a la tecnología, la web, el software libre y el humor (seguro usa debian también)

Para el que este desinformado acerca del tema de los cylon, solo les digo que fueron construidos por el hombre, se rebelaron, y se ven como y creen que son humanos :(

Factorial super compacto en ruby

2009-01-12T00:10:00.001-02:00

Posiblemente algunos conoceran la clasica implementacion del factorial en ruby, para los que no, la posteo aca:



def factorial(n)
 if n > 1
  # casos mayor que 1, se usa la formula recursiva
  # n! = n*(n-1)!

  n * factorial(n-1)
 else
  # casos 0 y 1, devuelve 1
  1
 end
end

Les presento una forma mas compacta de expresar el factorial



def factorial(n)
  # el metodo inject del rango 2..n multiplica
  # todos los elementos del conjunto tal como indica
  # el bloque de codigo que se le esta pasando
  (2..n).inject{|x,y| x*y}
end

A donde sea que vayan, lleven un interprete de ruby con ustedes

Patch para VMware Server 1.0.8 en linux kernel 2.6.27

2009-01-02T23:40:00.008-02:00

Termine una versión del patch para vmware bajo linux para kernels nuevos ( testeado en un fedora con kernel 2.6.27.9 ), básicamente este patch corrigen los problemas descriptos en este post

A las correcciones descriptas en el articulo anteriormente mencionado, se le suma la corrección de la deferencia de puntero nulo, la que producía el colapso del kernel (el de la maquina host :S ) y escupía este backtrace:

[<f99e76a1>] HostIF_SetFastClockRate+0x8d/0x148 [vmmon]
[<f99efd65>] Vmx86_SetHostClockRate+0xad/0xd5 [vmmon]
[<f99e5a87>] LinuxDriver_Ioctl+0x4c6/0xdcd [vmmon]
[<c0118694>] kmap_atomic_prot+0x102/0x137
[<c0395846>] _spin_unlock+0x5/0x1c
[<c017bd62>] mnt_drop_write+0x64/0xdd
[<c01f0680>] rb_insert_color+0x4c/0xad
[<c013260a>] enqueue_hrtimer+0xc9/0xd4
[<c0132ba5>] hrtimer_start+0xf9/0x129
[<c011a13c>] hrtick_start_fair+0xf7/0x123
[<c0129e78>] group_send_sig_info+0x12/0x56
[<c0129eed>] kill_pid_info+0x31/0x54
[<c012a44e>] sys_kill+0x73/0x13e
[<c0172b53...

Pasaba que en el archivo linux/hostif.c, en la funcion HostIF_SetFastClockRate, aproximadamente por la linea 3480, habia algo asi:



res = filp->f_op->ioctl(filp->f_dentry->d_inode, filp, RTC_PIE_ON, 0);
if (!cap) {
 cap_lower(current->cap_effective, CAP_SYS_RESOURCE);
}

Y aparentemente, en ocasiones, filp->f_op->ioctl (que es un puntero a una función, para los mas desprevenidos), tenia el valor de 0, es decir un puntero a nada, para solventar esto, simplemente cambie ese bloque de codigo por esto:



// mejor verificamos si ioctl es un puntero nulo antes
// de deferenciarlo como puntero funcion
if (filp->f_op->ioctl == 0) {
// si el puntero es nulo, hacemos de cuenta que
// la función devolvió status de error
res = -1;
} else {
// ojo, en esta seccion de esta deferencia ioctl como puntero
// que bueno que ya se verifico
res = filp->f_op->ioctl(filp->f_dentry->d_inode, filp, RTC_PIE_ON, 0);
if (!cap) {
   cap_lower(current->cap_effective, CAP_SYS_RESOURCE);
}
}

Y con eso se chequeo el puntero antes de deferenciarlo

Uh, casi me olvidaba, aca esta el patch, tengan en cuenta que es para la version 1.0.8-126538 (no se descarata que funcione en otras versiones de vmware, pero yo solo lo probe con esa), por favor, si lo prueban comenten a este articulo que tal les fue, si hubo problemas, para que version de vmware y linux (kernel) instalaron el patch, etc...

Feliz año nuevo

2009-01-01T00:54:00.001-02:00

Feliz año 2009 para todos, y que todos sus proyectos se cumplan y sean de software libre.

VMware 1.0.8-126538 en kernels nuevos, una odisea

2008-12-29T19:50:00.010-02:00

Actualizacion: los problemas de vmmon descriptos en este articulo y algunos mas se resolvieron en el patch que publico y describo en este post

Desde hace unas semanas que me hice un tiempo e instale fedora 10 con kde4 y toda la magia, pero llego el momento en que necesite virtualización, ahí empezó una entretenida historia (entretenida ahora que termino bien :D )
Si algunos de los que están leyendo esto comparten la experiencia de haber intentado instalar la ultima versión de VMware en uno de los últimos linux con el kernel 2.6.27.9 o alguna versión parecida, (encontré foros de personas que decían que este mismo problema pasa también en el ultimo ubuntu, seguro en otras distribuciones tambien ), habrán leído en la pantalla unas groserías particulares, cuando ejecutaron el famoso vmware-config.pl:

"/tmp/vmware-config1/vmmon-only/./include/compat_semaphore.h:23:27: error: asm/semaphore.h: No such file or directory"
"/tmp/vmware-config24/vmmon-only/linux/driver.c:153: error: se especificó el campo desconocido ‘nopage’ en el inicializador"

y asi...

No aguante mas y entre a meter mano en el codigo, primero lo del semaphore.h, no era complejo, simplemente cambiaron al .h de lugar, ahora esta en linux/semaphore.h en lugar de asm/semaphore.h en el nuevo kernel:



#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
#include "asm/semaphore.h"
#else
#include "linux/semaphore.h"
#endif

respecto a lo de nopage, no se bien que significa :(, lo unico que hice fue comentar las dos lineas que causaban problemas:


...

static void LinuxDriverPollTimeout(unsigned long clientData);

static struct vm_operations_struct vmuser_mops = {
//      .nopage = LinuxDriverNoPage
};

struct vm_operations_struct vmuser_locked_mops = {
//      .nopage = LinuxDriverLockedNoPage
};

static struct file_operations vmuser_fops;
static struct timer_list tscTimer;

...

Tomar nota de esto ultimo, queda pendiente evaluar el significado de todo eso

Y eso no fue todo, como todo un clásico de la programación C, al corregir errores, el compilador revela los otros errores que antes no se mostraron al no llegar a compilar esas secciones, quedo un desbarajuste en la función smp_call_function, que según el smp.h del kernel, tomaba 3 argumentos, y en driver.c y hostif.c del codigo fuente de vmmon, lo llamaba pasando 4 parámetros, a esto, lo resolvi eliminando el tercer argumento de todas las llamadas a la función smp_call_function ( y compat_smp_call_function, que era un sinónimo en ese código ). Elimine el tercer parametro porque en la definición de la funcion smp_call_function en el código del kernel mas viejo era el "retry" el tercer parámetro extra que había demás en relacion al nuevo



// version nueva EN linux/smp.h

/*
* Call a function on all other processors
*/
int smp_call_function(void(*func)(void *info), void *info, int wait);

// version vieja en linux/smp.h

/*
* Call a function on all other processors
*/
int smp_call_function(void(*func)(void *info), void *info, int retry, int wait);

Por ultimo, queda una llamada a kill_proc en linux/hostif.c, que segun el compilador no existe un kill_proc definido, ahi simplemente comente la linea :p

Y por ultimo, al compilar vmnet, surge el mismo problema del semaphore.h, la solución es exactamente la misma que con la compilación del otro modulo

Al final funciono todo, al punto que compilo todo, pude configurar todo lo que necesite y pude crear y bootear una maquina virtual, si embargo dos cosas (que habia mencionado antes) quedaron atadas con alambre:

1) el .nopage = LinuxDriverNoPage comentado casi al principio de linux/driver.c
2) el kill_proc comentado casi al final de linux/hostif.c
3) La version del kernel que no supe precisar en el #if que incluye el semaphore.h

Disculpen no haber subido el parche que genere, pero esos últimos dos puntos me parece que quedaron muy truchos y no quiero que cause problemas tratándose este código que toque de nada mas y nada menos que de módulos del kernel

Lo probe un poco, y al parecer el cambio del kill_proc genera algunos problemas, ya que al correr la mayoria de las maquinas virtuales, vmserverd termina por un error causado en el kernel,

con este problema:

Kernel failure message 1:
BUG: unable to handle kernel NULL pointer dereference at 0000000000000000
IP: [<0000000000000000>] 0x0
PGD 12944067 PUD 12942067 PMD 12941067 PTE 0
Oops: 0010 [1] SMP

y con este backtrace:

[] ? HostIF_SetFastClockRate+0xb0/0x137 [vmmon]
[] Vmx86_SetHostClockRate+0xb4/0xc9 [vmmon]
[] LinuxDriver_Ioctl+0x3d3/0x923 [vmmon]
[] ? inode_has_perm+0x5b/0x61
[] ? __dequeue_entity+0x61/0x6a
[] ? remove_wait_queue+0x2f/0x39
[] ? file_has_perm+0x83/0x8e
[] LinuxDriver_CompatIoctl+0x2b/0x40 [vmmon]

Fijense que la funcion con problemas, es la que modifique comentando el kill_proc, se resolveria cuando encuentre una implementacion de kill_proc que use las posibilidades de este nuevo kernel

Después de un rato, corregí la función , reemplazando a kill_proc por su equivalente el nuevo kernel, tal como explica en esta pagina , cuando compilo, siguió existiendo el mismo error, buscando por la web, encontré algo acerca de please revert commit 53f1b1433da7eac2607a4...; aparentemente, un chabon hizo un commit, que crashea el kernel cuando cierta función se llama de cierta forma, espero que actualizando el kernel cuando se corrija o patcheandolo pueda solventar este problema

Extraccion de direcciones de mail de texto en dos lineas

2008-12-26T13:09:00.008-02:00

DISCLAIMER: la siguiente información se difunde solo con fines educativos, el blog de NilClass NO fomenta el spam



# El codigo consta de dos chainings, 
# el primero abre el archivo y escribe en el 
# (todo el codigo hasta el .write inclusive)

# en el primer chaining

# abre el archivo (File.new( "..." , "w") )
# invoca el metodo write

# en el segundo chaining

# abre el archivo, para lectura
# hace un read al archivo, para leer todo su contenido
# hace un split, usando como divisor la expresion regular
# la expresion regular especifica que matchee todo lo que
# no sea ni letra minuscula ni letra mayuscula ni numero
# ni esos caracteres que pueden tener las dir. de mail
# despues el chaining hace un select de los strings que contienen
# el caracter "@"
# y por ultimo, efectua un join uniendo todas las cadenas
# con el caracter de salto de linea (\n) de por medio

ary = File.new("rawtext.txt").read.split(/[^a-zA-Z0-9@._-]/)
File.new("mails-parsed.txt","w").write ary.select{ |x| x =~ /@/ }.join("n")

# nota: esta claro que pude haber hecho todo en una sola linea
# pero lo separe en dos para que quepa en la columna del post

Conexion a bases de datos mysql via ruby

2008-12-22T15:41:00.002-02:00

Por razones que no vienen al caso encontré e instale una librería para ruby que permite conectarse a los motores de bases de datos mysql, la misma la pueden encontrar en http://www.tmtm.org/en/ruby/mysql/, la libreria se puede usar mas o menos asi:


require "gramas"
require "mysql"
my = Mysql::new("localhost", "username", "password", "database")
res = my.query("select name,surname from users")
res.each do |row|
  col1 = row[0]
  col2 = row[1]
end

Como mantener una lista de subclasses en una clase

2008-12-16T01:44:00.007-02:00

Definiendo el método de clase inherited, se pueden hacer muchas cosas cuando se hereda una clase, entre ellas esto:


# defino un modulo para agrupar los métodos que se agregan a las clases
module SubclassesRegister
 def subclasses
  if @subclasses == nil
   @subclasses = []
  end

  @subclasses
 end
end

# la clase principal, la que implementa la funcionalidad de registrar las subclases
class RegisteredClass

 def self.inherited(x)

  # se le agregan los metodos para que mantenga la lista de superclases ( a la superclase de x)
  x.superclass.extend SubclassesRegister unless x.superclass.include? SubclassesRegister

  # cuando alguna clase hereda de esta, se registra la subclase (si la superclase no es esta)
  if x.superclass != RegisteredClass
   self.register_subclass(x)
  end
 end

 def self.register_subclass(subclass)

  superclass = subclass.superclass
  print "registered #{subclass} as subclass of #{superclass}\n"

  # agregar la clase subclass a la lista de subclases de su superclase
  superclass.subclasses << subclass
 end
end

class Animal < RegisteredClass
 def self.enu
  # puedo obtener las subclases con solo usar el metodo "subclasses"
  print "subclases de Animal: #{subclasses.join("; ")}\n"
 end
end

class Perro < Animal
 def self.enu
  # cualquier clase de la jerarquia que extienda directa o indirectamente de RegisteredClass
  # puede obtener la lista de sus subclases
  print "subclases de Perro: #{subclasses.join("; ")}\n"
 end
end

class Terrier < Perro
end

class Dogo < Perro
end

class Gato < Animal
end


Animal.enu
Perro.enu

Espero que les haya sido de utilidad

¡¡¡ Aleluya !!!, consegui el Rubik original

2008-12-15T23:55:00.006-02:00

Al principio crei que era un sueño, pero lo consegui, con empaque original y todo, en pocas palabras, el de la foto de la derecha
Por si no lo sabian, en Argentina, durante un tiempo importante no hubo distribuidor oficial del cubo Rubik, y ahora es muy dificil de conseguir, y lo consegui.
El cubo es mucho mas maleable que cualquier "imitacion" que se puede conseguir practicamente en cualquier negocio, aparentemente el plastico del que se componen las piezas tiene mayor calidad y por lo tanto dura mas; y los stickers tambien, en el mismo tiempo de uso que en los otros cubos los stickers empezaban a perder el color, este sigue aparentando que no se uso !!!, es increible.
Como bonus tambien me compre uno de 4x4 (code name: The Revenge of Rubik), el de la otra foto

La guerra de cookies

2008-12-12T13:09:00.004-02:00

No se como describirlo, no se sabe como empiezo, en un instante dado, salto uno diciendo
"Quiero editar cookies", y el otro dijo "No se puede, estan en el server", entonces , el otro dijo... Mejor pongo un guion:

-

Lo siguiente ocurre entre las 12:00 pm y las 13:00 pm

Matt: Quiero setear una cookie
Diego: No se puede, esta en el server
Caco: Podes usar javascript.cookie
Matt: Solo setea localhost, quiero setear para ese host
Diego: No tiene sentido setear una cookie, el server no la va a aceptar, el server genera la cookie
Matt: Quiero setear una cookie en el browser
Robert: Miren esto
Diego: Espera
Matt: Espera
Diego: No tiene sentido setear una cookie, el server no la va a aceptar, el server genera la cookie
Matt: ¡¡¡Quiero poner la cookie!!!
Robert: Miren esto
Diego: Espera
Matt: Espera
Diego: No tiene sentido setear una cookie, el server no la va a aceptar, el server genera la cookie
Matt: ¡¡¡Quiero poner la cookie!!!
Robert: Miren esto
Diego: Espera
Matt: Espera
Diego: No tiene sentido setear una cookie, el server no la va a aceptar, el server genera la cookie
Gise: BBAAAAAAAAAAAAASTAAAAAA!!!
Matt: ¡¡¡Quiero poner la cookie!!!
Diego: No tiene sentido setear una cookie, el server no la va a aceptar, el server genera la cookie
Matt: ¡¡¡Quiero poner la cookie!!!


for i in (1..3000)
 print "Diego: NO se puede\n"
 print "Matt:  SI se puede\n"
end

Robert: Miren esto (mostrando el cuadro de agregar una cookie )
Diego: Espera
Matt: Espera. A ver...

Robert: Usa ADD N EDIT COOKIES para Firefox

Matt: Robert encontró lo que quería desde el principio
Diego: ¿eso era?

end

He descubierto una funcion no documentada en dos sistemas operativos: AltTAB ReversO

2008-12-10T16:37:00.007-02:00

El fin de semana descubri algo muy loco. ¿ Alguno de ustedes se encontró altabulando en decenas de ventanas en el escritorio , y de repente se dan cuenta de que se pasaron la que querían, y por lo tanto se ven obligados a dar toda la vuelta ?. La solucion esta a milímetros del meñique, mientras mantienen apretada la tecla ALT, presionen y mantengan apretada la tecla SHIFT tambien, cuando presionen TAB, altabulearean en sentido reverso !!
Lo curioso de esta técnica, es que funciona en los escritorios de Windows, en Kde y Gnome (si algún usuario de MacOS esta leyendo esto, por favor que deje un comentario acerca de si esto también sirve en el mundo bizarro) ; no solo eso, también funciona en el navegador Firefox para las pestañas (en este caso la tecla para cambiar de pestañas es control+tab, pero también sigue siendo el poderoso SHIFT, el agente reversor de la funcionalidad )

Esto fue todo por hoy, espero que les haya gustado, chau

Lo que pasa cuando no se usan "captchas" y como te obligan a pagar linux

2008-12-10T11:03:00.003-02:00

Miren todos los comentarios que dejaron de este articulo:

http://www.todo-linux.com/modules.php?name=News&file=article&sid=416

Hablando del tema en cuestion, espero que los "SGAE" locales ( i'am from Argentina ), no sean tan "creativos"

Hacer split de strings con expresiones regulares

2008-12-08T23:55:00.005-02:00

Imaginense el caso:


str = "hola como estan chau"
str.split.each do |x|
 print x,"\n"
end

Dara como resultado:

hola
como
estan
chau

Pero si tuvieramos (agregando signos de puntuacion entre las palabra):


str = "hola,como estan;chau"
str.split.each do |x|
 print x,"\n"
end

La salida seria:

hola,como
estan;chau

Y en la mayoria de los casos, eso no es lo que buscamos, para obtener lo que queremos (separar todas las palabras, sin importar que las dividan), podemos recurrir a lo siguiente:


str = "hola,como estan;chau"
str.split(/,|\s|;/).each do |x|
 print x,"\n"
end

O mejor aun


str = "hola,como estan;chau"
str.split(/\W/).each do |x|
 print x,"\n"
end

Eso retorna las cuatro palabras separadas. El argumento /,|\s|;/ que se le paso a split , es una expresion regular que matchea el caracter coma, el punto y coma o espacio indicandole que tiene que tomar cualquiera de estos como separador, en el segundo caso, la expresion regular indica que tome como separador cualquier caracter que no sea alfanumerico. Como imaginaran, esto es bastante util para extraer facilmente palabras de textos webs, txts, etc...

Espero que les haya gustado, chau

El cyber de los cartoneros ocupas

2008-12-07T23:23:00.004-02:00

Hoy fue uno de esos dias raros, en los que sali a la calle en busca de un cyber con internet, porque en casa se descompuso internet, y necesitaba enviar este post. Lo cierto que tras cuadras de recorrido, llegue al unico que encontre, el tipico negocio locutorio-kiosko-cyber-psicologo-verdulero, entre preguntando cuanto cuesta la hora, y me sorprendi al escuchar que dijo "setenta y cinco centavos", (precios como este solo los vi en la epoca pre-apocaliptica del 1 a 1). Lo cierto es que le di para adelante, y empuñando en alto mi usb, me dijo "usb anda a la 6".
Y en la seis, y en todas las demas, Windows 98 Edicion Cartonero, con buscaminas y solitario 2D !!!, con Intenet Exploder 6.0, msn 6.0 y mIRC version 0.01beta (este ultimo es falso, ni siquiera habia mIRC) todo un emergente mundo retro. Aun con todo esto, me quede ya que no habia otra, y tenia que lanzar urgente un tar.gz al cyber-espacio, cuando me disponia a colocar el pen-drive, observe pasmado que el gabinete AT , ¡¡¡estaba pidiendo EUTANASIA!!! por poco y tenia una entrada para floppy 5 1/4 ( se ve que se lo sacaron para poner un 3 1/2 en su lugar, que es mas moderno ).
El monitor por supuesto, a 640x480, porque era lo maximo que soportaba. En una carpeta que estaba por ahi, en una esquina, estaba el magnifico instalador del IE 6.0 (ya que win98 venia con IE 5.0 ), todo un reto, hacer que funcione algo, ahi, cualquier programa que traia en el usb, anunciaba "Windows 2000 or higher is needed for install..."
El cyber hecho por cartoneros ocupas, se hizo con toda la intencion (de hacer plata facil) recuperando maquinas DE LA BASURA, y por extension, instalando sistemas operativos DE LA BASURA TAMBIEN, pero a ese lugar no vuelvo, aunque me paguen 75 centavos la hora a mi en lugar de que yo les tenga que pagara ellos.
Aclaracion: no tengo nada en contra de los cartoneros, siempre y cuando no pongan cybers a cuadras del congreso

Programa para generar imagenes "flasheras"

2008-12-07T20:19:00.008-02:00

Hoy estuve navegando por la web, y me tope con un articulo de un blog, el cual promovia y ensañaba el uso de un programa llamado apophysis. Esta aplicacion, servia para generar imagenes fractales, como esta:

En el primer link que inclui en este articulo hay muchos mas ejemplos, no los inclui todos en este post porque se ve que tienen alta resolucion y ocasionan gran cantidad de trabajo al browser :p
Hasta el proximo articulo, van a conocer mis conclusiones acerca de esta herramienta cuando la pruebe

4x3x2 = FRACTURA EXPUESTA DE PULGAR

2008-12-05T22:04:00.000-02:00

A mi sinceramente no se me hubiera ocurrio algo asi. Aparentemente el que manipula el paralelepipedo ortogonal rubik (no es un cubo, en terminos estrictos) se fracturo el pulgar jugando con eso (aun asi, sigue)

el NilClass

2008-12-05T20:46:00.000-02:00

Vean el siguiente ejemplo



# un array asociativo
array = { 1 => "Robert", 2 => "Ruby" }

# imprimir las longitudes de las cadenas del array
(1..3).each do |i|
 #  CUIDADO al tratar de procesar el string numero 3, se generara un error 
 # "undefined method 'length' for nil:NilClass (NoMethodError)"
 print "longitud de la cadena #{i}: #{array[i].length}\n"
end

el elemento 3 del array asociativo, era un nil, por lo tanto devolvio ese error, pero, trato de invocar el metodo al objeto nil, que es de tipo NilClass, eso significa que se puede definir el metodo en el objeto



# un array asociativo
array = { 1 => "Robert", 2 => "Ruby" }

# antes, puedo definir el metodo length del nil
def nil.length
 0
end

# imprimir las longitudes de las cadenas del array
(1..3).each do |i|
 # Esta vez no genera ningun error
 print "longitud de la cadena #{i}: #{array[i].length}\n"
end

Tambien es valido definir el metodo en el NilClass, por lo que conozco es lo mismo (NilClass es una clase cuya unica instancia es nil)


# un array asociativo
array = { 1 => "Robert", 2 => "Ruby" }

# antes, puedo definir el metodo length en la clase NilClass
class NilClass
 def length
  0
 end
end

# imprimir las longitudes de las cadenas del array
(1..3).each do |i|
 # Esta vez no genera ningun error
 print "longitud de la cadena #{i}: #{array[i].length}\n"
end

En definitiva, para explicar lo ocurrido, nil es el objeto referenciado por las variables que no referencia a nada, es algo parecido al hecho de conceptualizar una entidad que creo la parte del universo que no fue creada por nadie, o la definicion del "eter" gas que conduce las ondas de luz que existe en todo el espacio exterior , donde se suponia que hay "vacio"
A diferencia de lenguajes como java , o .net, los cuales admiten variables que no hagan referencia a *nada*, dando lugar a "NullPointerExceptions", en ruby esto no tiene sentido, por lo tanto no pueden existir variables que apunten a la nada, si existen variables que apuntan al objeto nil, que representa a la nada, lo cual nos lleva a que tanto los lenguajes mencionados anteriormente se rigen por el mismo principio: la nada en un contexto tan abstracto, tiene el mismo nivel de tangibilidad que cualquier algo (como clases, metodos y otras cosas), java define a esa nada como un "null", y ruby como un "nil".
La diferencia que si existe, es que en java esa representacion de nada, es "especial", es algo mas, una cosa aparte; en cambio, en ruby, la representacion de la nada, es nil, que tambien es un objeto ya que en ruby todo es un objeto, por que lo "especial", se admite en la menor medida posible, ya que añade gran complejidad a esto.
Al ser la representacion de nada un objeto como los demas, admite todo lo que los objetos admite: metodos, mas instancias, estado, etc..., si esto tiene sentido o no definira el programador, si quiere usar estas funcionalidades o no, se puede decir tanto que no tiene sentido que la nada tenga "funcionalidades" como tambien se puede decir que no es correcto que la nada no pueda ser tratada como un concepto al igual que los demas, como las clases, metodos y variables
Espero que les haya sido de utilidad, cerramos con otra exhibicion de nil, menos charla y mas accion:


# ESTO NO SE PUEDE HACER, POR RAZONES ¿OBVIAS?
# atencion: todas las lineas de codigo posteriores dan algun tipo de error

# duplicamos el nil original, ya que es un objeto
# esto no anda, no se puede duplicar el concepto de la nada
# para crear otro concepto, el concepto de nada
# es unico (el patron singleton)
otronil = nil.dup 

# instanciamos otro nil usando la NilClass
# no se puede fabricar distintos conceptos de nada
# eso conlleva a la nada (valga la redundancia)
otronilmas = NilClass.new

Ahora algo que funcione



# se le pueden definir los metodos que sean al NilClass
# y tambien variables locales
class NilClass
 def initialize
  super
  @vacio = 4
 end

 def vacio= (a)
  @vacio = a
 end
 def vacio
  @vacio
 end
end

nil.vacio = 4
print nil.vacio

Las viscicitudes y la esquizofrenia de proyectos "privativos" que emplean a la "gente del linux"

2008-12-05T12:04:00.000-02:00

Estoy por a punto contraer esquizofrenia aguda si no resuelvo el siguiente:

Estoy trabajando en una suite de proyecto$$$ de $oftware privativo$$$ (no hay problema en eso, el mundo es dinero) que esta empleando , como fuerza de trabajo tecnica principal, mucha "gente del linux" (me incluyo entre ellos) , seguidores de Richard Stallman (el tipo es un grosso) y sus enseñanzas filosoficas.
Exitosamente ambas partes ( la parte $privativa$, y la parte GNUsera ) han logrado dejar totalmente de lado sus prejuicios ideologicos para convivir en armonia en un proyecto que progreso (y progresa) bastante, como dos equipos remando en la misma direccion, al unisono, pero hasta cierto limite.
El limite surge cuando, se vislumbra una incompatibilidad de conceptos cuyas raices son esos profundos mandatos y estructuras ideologicas, conceptos de los que no se habla, pero se ven plasmado en los hechos.
El principal ejemplo de esto, es la aplicacion del concepto del "producto de software privativo", con la "propiedad intelectual" ( de lo cual estoy en contra y a favor de eso (mas en contra ( pero no al punto de rechazar el proyecto ) ) ), lo cual genera un obvio y comprensible requerimiento por parte del cliente de un producto autonomo ( que no requiera administracion, solo talvez mantenimiento ) y que por lo tanto tenga una gran plusvalia. No estoy en contra de eso, mas bien quiero lograrlo, pero la parte GNUsera no comprende, a nivel subconsciente, lo que significa el "producto de software privativo y que no necesite administracion", por lo tanto, sin darse cuenta, estan rechazando el desarrollo de soft en torno en la funcionalidad con parches (como reiniciar los servicios automaticamente ante un problema) y estan privilegiando el desarrollo de herramientas de monitoreo y administracion del servicio (cuando segun la otra parte, el servicio deberia administrarse solo ) y tambien estan dando prioridad al analisis detallado de bugs o problemas para darle solucion definitiva (como todo buen desarrollador de software libre) , pero siendo que esto no es para este contexto.
En este punto, si bien no tenemos a los dos equipos remando para sentidos opuestos y el barco girando sobre si mismo, no estan remando exactamente para la misma direccion, lo cual causa trayectorias circulares (de circulos bastante grandes), pero circulares al fin.
No se puede definir con certeza cual es la direccion correcta, el planteo de un "servicio que no necesite administracion" es bastante cuestionable, pero al mismo tiempo dejar que un servicio dependa en exceso de sus desarrolladores tambien es cuestionable, al igual que pretender que un producto privativo de poco personal este a la altura de soluciones libres o de grandes empresas. Hasta ahora solo describi el problema y no la solucion, pero es probable que si no se resuelve este problema, el proyecto no supere ese limite y yo termine en un loquero hablando con visiones :(

Comentarios acerca de posibles soluciones son bienvenidos

Highlighting a los post

2008-12-05T11:08:00.000-02:00

Gracias a los instructivos de un buen post de este blog cuya direccion me paso Caco_Patane (pasense por su blog), pude configurar el highlighthing de codigo para los posts, ahora si que da gusto publicar post con codigo, vean el "hola mundo" del highlighting:


def holamundo
    print "hola mundo!!!\n"
end

# los parentesis son un guiño
# para los que programan en C ;)
# son opcionales :D
holamundo()

Tambien el mitico factorial en ruby:


def factorial(n)
    if n == 0
       1
    else
       n*factorial(n-1)
    end
end

Cubos rubiks siameses, para no creer

2008-12-04T21:37:00.002-02:00

Pasen y vean este fenomeno, cruel error de la naturaleza ( bastante creativo ) al parecer el cubovulo fue inseminado con dos juegos de stickers en lugar de uno, pero no llego a dividirse por completo como para generar cubos gemelos, y el resultado fue esta anomalia:

Un video de una resolucion bastante rapida del cubo:

Tambien un video con los tips de como resolverlo:

Robert, fijate la botella del agua

2008-12-04T18:58:00.000-02:00

¿Fue a caso mi culpa ??, ¿ la mala suerte ?, ¿ sera el destino acaso, si tal cosa existe ?, ¿ o talvez sera la ineludible voluntad de los Dioses ?, mis preguntas comienzan a partir de una conjura de hechos que me ubicaron en el poder y la responsabilidad de ser el guardian universal de la botella atada con un cordon de zapatillas. Pero mejor explico (con narrativa anacronica)
Cuenta la historia de una vieja que se queja del agua que cae desde el aire acondicionado de nuestra oficina (el aire imprescindible en estas epocas de clima infernal/invernal (el mundo se volvio loco)), la onda es que se quejo , se quejo hasta que no se como terminamos instalando un complejo sistema de tubulacion que redirige la salida estandar del aire acondicionado a la entrada estandar de la botella.
Una vez, en una epoca , mas o menos al principio del 2008, en la empresa donde trabajo, deciden realzar una instalacion masiva en todas sus sucursales e instalaciones locales, sin percaterse de la anomalia q se avecinaba.
En un futuro post-apocaliptico, todos en la empresa mueren en un misterioso incendio
Todo esto lo termino escribiendo en un blog, mientras alguien intenta apagarme la maquina para evitar que la verdad sea rebelada
Antes de todo eso mande un curriculum para entrar a la empresa.
Despues de leer toda esa historia en el blog, empiezo a darme cuenta de mi ignorancia acerca de los limites entre la casualidad y la causalidad respecto de porque mi nuevo puesto de trabajo se encuentra convenientemente a 30 centimetros de la famosa botella, y a raiz de entonces, a cada rato me dicen "Robert, fijate la botella de agua" y de ahi me insipiro a inscribir ese articulo del blog

FIN???

Un blog agrego una referencia al mio

2008-12-04T18:47:00.000-02:00

Es el blog de Diego Gomez, un compañero de laburo, les recomiendo este blog, es bastante completo y tiene todo lo bueno (solo le falta mas fedora y mas ruby, pero exceptuando eso es buenisimo)

Ahi tienen el blog
http://blog.dgomez.com.ar/

Y aca tienen el articulo que referencia a este blog, cerrando de esa manera una referencia ciclica, un circulo infinito referencial:

http://blog.dgomez.com.ar/node/46

Como me gusta escribir posts en este blog

2008-12-04T18:31:00.000-02:00

Me gusta escribir post en un blog, sobre posts auto-referenciales como este, hoy empece un blog por presion, y al final estan presionando para que lo deje ¿?

Carencia de syntax highlighthing

2008-12-04T18:25:00.000-02:00

Dirigido a los millones de seguidores del recien instaurado blog, les ofrezco mis mas sinceras disculpas por haber suspendido los post que incluyen tips de programacion ruby o de otros lenguajes inferiores. Las razones de esta determinacion, es el desconcimiento por parte mia de como ofrecer codigo en el blog con syntax highlighting (y ademas automatico), que de no existir puede causar graves problemas oculares y mentales (cuando chico, en mis inicios, prograba sin highlighting). Es asi, que en favor de la salud ocular, mental, psicologica y espiritual de los lectores, decidi suspender el envio de post que tengan codigo fuente hasta que resualva definitivamente el tema del syntax highlighthing. Disculpen las molestias ocasionadas

No soy un servidor DNS

2008-12-04T18:18:00.000-02:00

Cada dos minutos recibo una peticion de resolucion de ip por chat, diciendo :
"pasame la ip de tal servidor", o "dame la ip de tal otro", o "¿te acordas cual es la ip de ese servidor" ?, y yo les contesto con la ip en cuestion de segundos mirando mis tablas hostname => ip. Me tienen la swap llena, un dia de estos voy a redirigir sus dnss a sitios porno, a ver si se dan cuenta... ( si leen este post no dejen que se enteren... )

Comentarios del codigo del post anterior (sin el codigo incluido, para q los pongan ustedes hehehe)

2008-12-04T15:49:00.000-02:00

# leo el filename del primer argumento
# leo la expresion en lenguaje ruby del segundo argumento
# si no hay filename finalizo
# leo blocksize del tercer argumento y si no vino le asigno el default de 1
# leo init del cuarto argumento y si no vino le asigno el default de 1
# leo fin del quinto argumento y si no vino le asigno el default de 10
# abro el archivo para recorrerlo, de a bloques
# ejecuto la expresion pasada como parametro, como codigo ruby !!!

Como programar un editor hexadecimal programable en 15 minutos y usando menos lineas que el titulo de este post

2008-12-04T15:39:00.000-02:00

Herramientas necesarias:
* ruby
* ruby
* ruby
* ganas de programar

... les debo las instrucciones ...

Codigo terminado:


class App
        def main( args )
                filename = args[0]
                expresion = args[1]

                if filename == nil
                        return
                end

                blocksize = ( args[2] || 1 ).to_i
                init = (args[3] || 0).to_i
                fin = (args[4] || 10).to_i

                File.open(filename, "rb+") do |file|

                        i = init
                        while ( i < fin )
                                file.pos = i

                                stream = file.read(blocksize)
                                origstream = stream.clone

                                eval(expresion)

                                if stream != origstream

                                        file.pos = i
                                        file.write(stream)
                                end

                                i=i+1
                        end
                end
        end
end

App.new.main(ARGV)

NilClassBlog.new

2008-12-04T15:35:00.000-02:00

Creado nuevo blog "NilClass", solo porque unos compañeros de laburo lo pidieron ( y creo q tenian razon ) ...