hashing y las aclaraciones

Hashing es una forma de ponerle un número a algo que originalmente no es un número. Así que estuve buscando un poco para ver si lo podía usar en el sistema de expedientes, así me encuentro con que una falla de documentación (que espero denunciar más antes que temprano).

Parece que la alternativa es usar Digest (qué es eso?) ya veremos. Aunque al parecer hay variados medios de hashing.

La cuestión es que quería inventarme el id de los expedientes y tengo la esperanza de poder hacer valores únicos... (son 25_000) nada más...
Bueno, la cuestión es que tengo que meter el id en el pequeño espacio entre -2_147_483_648 y 2_147_483_647 ( 2³² )

Por ahora parece que voy a usar CRC32 (de la librería zlib) y voy a ver que onda... pero lo que debería hacer es usar una gema a partir de murmurhash3.

La onda sería copiar nashby/cityhash pero con los contenidos del otro y está este a medio hacer.

Será cuestión de probar!

testeando c

Ahora estoy por aprender C (no C++ ni C#), algo bien dificil de buscar en internet (buscá C en google y seguro que salen cosas útiles)...

Para testear C, hay un "algo" que se llama Check y otros sistemas para test unitarios. (test de a partes).

El problema vino cuando quise testear el producto terminado, algo que interactúe con un programita de consola, lea el standard output y escriba en el standard input, de a turnos y chequé que los resultados son los esperados.

Asi me encontré que no hay en ruby una forma feliz de interactuar con un programa taaan simple.

Lo único que encontré es:
- Kernel.exec es muuy molesto.
- Había una gema que hacía eso, pero... el último commit es de 2008. Utilizaba algo llamado termios de linux (que no está muy bien documentado tampoco).
- Un tipo escribió una guia muy linda sobre ejecución de archivos en ruby, pero no le puso indice. (Parte 1, parte 2, parte 3)
- Ahí encontré que la posta son dos librerías olvidadas de la stdlib de ruby. PTY y Open3.
- Una posibilidad que no llegué a leer es expect.

Esto, lo quiero para poder testear estos "programas".

Un linux para viejos

Bueno, llega un momento en que uno quiere a la fuerza aplicar linux, y dice algo como, le instalo linux a mi abuela, que le va a resultar más fácil que windows y además le va a andar en el cacharro que tiene.

Pruevo varias distros:

• greenie linux una versión eslovaca tiene una versión con openbox, pero yo no entiendo nada.
• ubuntu tiene supuestamente una versión liviana, pero no es fácil.
• fedora tiene su versión con xfce que es la que estoy probando ahora.
• además pruevo otros, crouchbang (inglés), nimbleX (por error).

Todas tienen en común ser bien distintas de windows, tienen iconos chiquitos o tienen cosas sin traducir.
 Ahora estoy probando fedora 16 con xfce, que cosas le arreglo para que sea fácil?

• Iconos en el escritorio. (firefox)
• Saco lo de los distintos escritorios.
• Panel inferior. (saco el inferior y muevo el superior)
• Agrando la letra.
• Marcadores en Firefox (y cambio "Most Visited" por "Más visitados")
• Saco el icono de Sistema de Archivos del Escritorio.
• Activo el horario por Red.
• Actualizo el sistema.

Ahí queda un linux bastante estable que tiene firefox.
Tiene algunos puntos flojos, a saber:

1. El lector de mail no va y no se como poner gmail por default. (quizás con esto?)
2. No se autologea.
3. El menú de aplicaciones tiene demasiadas opciones, me gustaría sacar algunas, pero no se dónde configurarlo.
4. La tipografía es horrible.
5. Carpeta personal aparece con puntos suspensivos.
6. Las actualizaciones tardan una bocha.

Veremos que sucede, deseenmé suerte (ya a mi abuela).

Sobre git (procedimiento rudimentario)

La idea de los commits es poder separar lo que funciona de lo que no (aislar los problemas) si está todo en un gran commit no sirve de nada (excepto para poner todo o sacar todo) por lo que es importante que haya muchos commits, y que en cada uno haya un cambio.

Así que acá presento un procedimiento rudimentario para lograrlo de forma simple y clara.

La onda es que cuando te agarra la voragine programadora hagas el siguiente procedimiento, que aunque rudimentario puede funcionar.

0. hay que empezar desde *master* y tiene que estar todo *limpio*, si hay cambios de algun tipo hay que borrarlos `git co .` o guardarlos para después `git stash`

1. Creas una rama donde trabajar

        $ git checkout -b nombre_de_la_nueva_rama`

2. Haces un cambio cualquiera o dos como mucho, si corres un generador ya está, si modificas 2 archivos y lo que pusiste _anda_ ya está. La cuestión es lograr que eso que acabas de escribir ande. si agregas un botón y el botón se ve, fue, ya está, es hora de comitear.

3. Comitea lo que acabas de cambiar (ahí te pide un comentario, descriví lo que hiciste)

        $ git add . && git commit

4. Repetí 2-3 tantas veces como sea posible.

5. hacé un push (si la rama no existe primero creala)

        $ git promote
        $ git push

De esta forma quedan un monton de commits horribles, pero cada uno tiene una cosa que anda por si sola, así que uno puede, al encontrar un error, ver que commit lo creo y revertirlo `git revert` o corregirlo, pero entiende para qué está cada linea de código.

Idea para una gema. db2fixture

La cuestión es bastante simple, uno quiere hacer un fixture rápido de una cuestión que le parece interesante, como ser un registro que le causó problemas o errores en algún momento. Entonces querés hacer un test sobre el tema para asegurarte que ese problema no vuelve a ocurrir.

Como hago el fixture sin escribir, abro la consola, busco el registro y hago:

r.to_fixture "registro_problemático" # => se crearán 7 fixtures... ¿seguro?(y/n)
; yes # => OK

y como funciona?

usa muchas cosas de este plugin que hace algo parecido.
Y a eso le agrega una búsqueda de relaciones (basada en r.class.reflections) que carga también todos los registros relacionados con el primero recursivamente.

Luego, solo queda escribir el test. :) (y la gema :( )

Jugando con Token Input

Me puse a intentar usar token-input.js desde rails 3.1 y me encontré con que no fue tan dificil.

Un poco de codigo para recordarme:

El Input de formtastic:

    <%= form.input :compradores_tokens, :label => "Compradores:",
                   :input_html => {
                     "data-pre" => @contrato.compradores.to_json, :only => [:id, :name] } %>


El coffescript para cargarlo:

//= require jquery.tokeninput

$ ->
  $('#contrato_compradores_tokens').
    tokenInput '/personas/people.json',
    # NOTE: esto esta hardcodeado porque no se puede tener acceso a los helpers (helper.personas.new_people_path(:as => :json))
      queryParam: 'search[name_like]'
      crossDomain: false
      prePopulate: $('#contrato_compradores_tokens').data('pre')
      searchingText: 'Buscando...'
      hintText: 'Ingrese el nombre del comprador'
      noResultsText: "Esta persona no está registrada"


El codigo para los estilos

*= require token-input


En el modelo:

  attr_reader :compradores_tokens

  def compradores_tokens=(ids)
    self.comprador_ids = ids.split(",")
  end


Y ahí debería estar andando... :)

puppet en debian

Bueno, cree una pequeña maquina virtual Debian y le instale puppet, no diré que fue una cosa facil, pero los comandos son:

aptitude install puppetmaster puppet

nano /etc/defaults/puppet

     (enabled = true)

nano /etc/hosts

     (agregar puppet como alias a localhost)

nano /etc/puppet/manifests/site.pp

    ( y poner los manifiestos )

Las actualizaciones se hacen cuando tienen ganas pero el sistema anda y podría instalar paquetes y cosas así...

El sistema se simplifica mucho si el server ya existe y si hay un servidor DNS propio y uno agrega un alias para el puppetmaster (puppet). Pero eso no suele pasar en ámbitos chiquitos :(

exit