El Firefox 26 me dejó de mostrar los íconos de las carpetas en los bookmarks.
A esto lo podemos ver en la siguiente imagen (click para ampliar):
La solución es muy sencilla y la encontré acá. Se trata de agregar el siguiente código:
@namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
menu.bookmark-item > .menu-iconic-left {
visibility: visible;
}
en el siguiente archivo:
~/.mozilla/firefox/<profile_name>/chrome/userChrome.css
Yo lo hice de esta forma (ejecutar la línea completa como usuario normal, sin el $
), donde <profile_name>
es el nombre del perfil de Firefox que se quiera modificar:
1
|
|
Espero que le sirva a alguien. Saludos!
]]>En un post anterior comenté que había comenzado a leer un libro sobre SciPy y NumPy. En los primeros capítulos encontré ejemplos simples de la utilización de SciPy. Hoy voy a mostrar el código de dos de ellos, para los cuales implementé sus respectivos gráficos. El primero es sobre ajustar una distribución de puntos con dos Gaussianas, y el segundo es sobre encontrar los puntos de intersección de dos curvas.
Como cada paso está comentado en el código, entonces no me voy a detener en las explicaciones. Es más para tener estos ejemplos como anotaciones cuando necesite hacer un cálculo simple y un gráfico modesto, nada más que eso :-)
Si no tenemos los paquetes necesarios, en Fedora los instalamos así:
# yum install numpy scipy python-matplotlib
Si usamos Vim, podemos usar el plugin para templates del cual hablábamos ayer. Entonces creamos el archivo:
$ vim fitting-two-gaussians.py
y copiamos el siguiente código:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
|
Luego lo ejecutamos, pero antes le damos los permisos necesarios para ello:
$ chmod +x fitting-two-gaussians.py
$ ./fitting-two-gaussians.py
( 1.01566899098 +/- 0.00385041607346 )
( 3.01416857209 +/- 0.00491510905728 )
( 0.99386852028 +/- 0.00492078923246 )
( -1.91566245187 +/- 0.00722572741217 )
( 15.0208881795 +/- 0.000735898852204 )
( 0.529428527565 +/- 0.000735896650911 )
Como resultado, obtenemos los seis parámetros de las dos Gaussianas y sus respectivas incertezas. El gráfico es el siguiente (click para ampliar):
Siguiendo los pasos anteriores, creamos el archivo:
$ vim intersection-points.py
y copiamos el siguiente código:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
|
Luego lo ejecutamos, dándole sus permisos antes:
$ chmod +x intersection-points.py
$ ./intersection-points.py
( 13.4077307829 , -0.365922692171 )
( 18.1136612829 , -0.318863387171 )
( 31.7833086315 , -0.182166913685 )
( 37.0799991955 , -0.129200008045 )
( 39.8483778612 , -0.101516221388 )
( 43.8258775032 , -0.0617412249676 )
En este caso, el resultado son los seis puntos de intersección entre las dos curvas. El gráfico es este (click para ampliar):
]]>Uno de mis editores de texto preferidos es Vim, sobre todo cuando se trata de editar archivos en consola o bien para escribir código. Y es acá donde entra en juego este plugin para Vim llamado vim-template, el cual nos proporciona un conjunto de plantillas para diferentes tipos de archivos.
Primero que nada necesitamos tener Vim, al cual lo instalamos de la siguiente manera en Fedora:
$ sudo yum install vim-enhanced
Luego descargamos el plugin:
$ wget https://github.com/aperezdc/vim-template/archive/master.zip
y lo instalamos al mismo tiempo que lo extraemos:
$ unzip -j master.zip 'vim-template-master/plugin/*' -d ~/.vim/plugin
$ unzip -j master.zip 'vim-template-master/templates/*' -d ~/.vim/templates
De esta manera, ya tenemos instalado el plugin vim-template en ~/.vim/
.
Dentro de las plantillas, se utilizan variables que van a ser expandidas según su valor. Estas variables también pueden ser sobreescritas, y es lo que voy a hacer ya que las que me interesan no toman un valor muy representativo.
Dentro del archivo ~/.vimrc
(lo creamos si no existe) voy a colocar las sigientes líneas que tomarán un valor diferente según cada usuario:
1 2 3 |
|
las cuales representan la licencia del código, el email del usuario y su nombre, respectivamente.
También voy a configurar el template que más uso (~/.vim/templates/template.py
), y para ello voy a sustituir todo su contenido por lo siguiente:
1 2 3 4 5 6 7 8 9 10 |
|
De esta forma queda configurado el plugin a mi gusto. Hay plantillas para otros lenguajes de programación también, y no necesariamente tienen que ser modificados. Uno también puede crear su propio template para el lenguaje que más utilice y que no esté por default en el plugin.
Podemos usar este plugin de dos maneras diferentes. Una es creando un nuevo archivo, dándole un nombre y el sufijo de interés. En este caso, para poner en práctica las configuraciones hechas anteriormente, vamos a crear un archivo Python:
$ vim foo.py
y cuando presionemos enter obtendremos lo siguiente:
Otra forma es abriendo Vim sin crear ningún archivo:
$ vim
y seleccionando luego el template desde dentro, para C en este caso:
:Template c
con lo cual obtendremos:
Podemos ver más información y definición de variables en la página de vim-template.
]]>Este fin de semana comencé a leer un libro introductorio sobre SciPy y NumPy, al cual pueden verlo acá:
SciPy and NumPy (Optimizing & Boosting Your Python Programming)
Voy a comentar sobre un cálculo interesante que se habla en el segundo capítulo sobre la diferencia en la eficiencia computacional entre el objeto list
y el objeto ndarray
.
Las operaciones sobre los elementos de una lista sólo pueden ser hechas a través de bucles iterativos, lo cual es computacionalmente ineficiente en Python. El paquete NumPy permite superar las deficiencias de las listas de Python mediante un objeto para almacenamiento de datos llamado ndarray
.
Utilizando el comando mágico %timeit
de IPython, comparamos las diferencias en velocidad de ndarray
de NumPy versus las listas de Python al ser multiplicados por un escalar. Primero creamos un array que contenga 1×107 elementos:
In [1]: import numpy as np
In [2]: arr = np.arange(1e7)
y luego convertimos el array en una lista:
In [3]: larr = arr.tolist()
En el caso de las listas, tenemos que crear una función para emular lo que ndarray
puede hacer:
In [4]: def list_times(alist, scalar):
....: for i, val in enumerate(alist):
....: alist[i] = val * scalar
....: return alist
Ahora hacemos el cálculo en IPython con %timeit
, primero multiplicando el array por 1.1:
In [5]: %timeit arr * 1.1
10 loops, best of 3: 58.9 ms per loop
y luego haciendo lo mismo con la lista, usando la función creada para ello:
In [6]: %timeit list_times(larr, 1.1)
1 loops, best of 3: 1.44 s per loop
Esto nos muestra que la operación con el objeto ndarray
es ~ 25 veces más rápida que el bucle con la lista. Por lo tanto, cuando sea posible, deberemos trabajar con objetos array en lugar de listas.
Interesante resultado para mí que soy un aprendiz de Python! :-)
]]>Esta especie de tutorial de PyGObject (Python y GTK+ 3) es casi una traducción literal de su documentación. Más que un tutorial, es el ejemplo más simple de como crear una ventana vacía. Seguidamente, extenderemos el script para agregarle un botón que realiza una determinada acción. Se necesita un conocimiento razonable del lenguaje Python, el cual dudo en tener :-)
Antes de comenzar, recomiendo los siguientes documentos para que podamos aprender un poco más sobre PyGObject:
https://developer.gnome.org/gnome-devel-demos/stable/tutorial.py.html.en
http://pfrields.fedorapeople.org/presentations/OhioLF2011/PyGObject.pdf
Para comenzar, crearemos el ejemplo más simple posible, el cual consiste de una ventana vacía.
1 2 3 4 5 6 7 |
|
Explicaremos ahora cada línea del ejemplo.
#!/usr/bin/python
La primera línea de todos los programas en Python debe empezar con #!
seguido del camino al intérprete Python que queremos invocar.
from gi.repository import Gtk
Para poder acceder a las clases y funciones de GTK+, primero debemos importar el módulo Gtk. La próxima línea crea una ventana vacía.
win = Gtk.Window()
Seguidamente, conectamos la ventana a su evento delete para asegurarnos de que la aplicación termine al cliquear en la x de la ventana.
win.connect("delete-event", Gtk.main_quit)
En el próximo paso mostramos la ventana.
win.show_all()
Finalmente, iniciamos el loop de procesamiento de GTK+, del cual saldremos cuando la ventana sea cerrada (ver línea 5).
Gtk.main()
Para ejecutar el programa, abrimos una terminal, cambiamos el directorio hasta donde está el archivo (al cual le llamé ejemplo_simple.py), y ponemos:
$ python ejemplo_simple.py
Alternativamente, podemos darle permisos de ejecución y luego ejecutarlo:
$ chmod +x ejemplo_simple.py
$ ./ejemplo_simple.py
Para algo un poco más útil, aquí está la vesión en PyGObject del clásico programa Hello World.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
|
A diferencia del ejemplo simple, aquí creamos una sub-clase de Gtk.Window
para definir nuestra propia clase MyWindow
.
class MyWindow(Gtk.Window):
En el constructor de la clase, tenemos que llamar al constructor de la super-clase. Además, le diremos que dé el valor de Hello World
a la propiedad title
.
Gtk.Window.__init__(self, title="Hello World")
Las próximas tres líneas son usadas para crear un botón (widget), conectarlo a su señal clicked
, y adicionarlo como hijo a la ventana.
self.button = Gtk.Button(label="Click Here")
self.button.connect("clicked", self.on_button_clicked)
self.add(self.button)
En consecuencia, el método on_button_clicked()
será llamado si cliqueamos en el botón.
def on_button_clicked(self, widget):
print "Hello World"
El último bloque, fuera de la clase, es muy similar al del ejemplo simple de más arriba, pero en lugar de crear una instancia de la cláse genérica Gtk.Window
, creamos una instancia de MyWindow
.
El mismo Leonardo comenzó con una charla llamada “Making things happen: How to contribute to Fedora”, donde nos recordó algunas de las características de Fedora: un proyecto Open Source, enfocado en el desarrollo de nuevas tecnologías, donde las contribuciones al código se hacen directamente upstream, dirigido por una comunidad de voluntarios, donde tiene su lugar la transparencia y la meritocracia. Un poco más adelante, Leo nos cuenta cómo podemos contribuir con Fedora, a saber, como Escritor de Contenidos, Diseñador, Relaciones Públicas, Desarrollador del SO, Traductor, Desarrollador Web o Administrador. Finalmente, nos habla con más detalles sobre los sub-grupos dentro del Proyecto Fedora, principalmente sobre Embajadores, Internacionalización (i18n), Empaquetadores y Pruebas (QA), donde nos explica qué tareas se realizan, cuáles son los requisitos para participar, y qué procedimientos deben llevarse a cabo para unirse a un determinado sub-grupo. Fue una charla muy provechosa y entretenida.
La siguiente charla, llamada “Contributing to Fedora and Upstream ”, estuvo a cargo de Sergio Durigan Jr, empaquetador de Fedora y desarrollador de Red Hat, quien nos habló un poco sobre su experiencia con el GDB, sobre cómo es su día a día dentro de este proyecto, y su contribución upstream. Sergio nos hace saber que él es el mantenedor del GDB en Red Hat, y que dentro de Fedora él es co-mantenedor. Hubo mucha participación por parte del público haciendo preguntas a Sergio, quien nos brindó una charla muy informativa.
La última charla en forma de tutorial, llamado “Fedora Packaging ”, la dio Itamar Reis Peixoto, embajador y empaquetador de Fedora. Haciendo uso del notebook de cada uno, Itamar nos muestra primero cómo crear un programa en C utilizando las herramientas Autotools de GNU, para pasar luego al empaquetamiento del mismo en el formato RPM, siguiendo los lineamientos específicos de Fedora. Una charla muy interactiva y técnica.
Finalmente, quisiera agradecer a Leo por la organización y el recibimiento que nos brindó. Confieso que no conocía la Red Hat de São Paulo y realmente me sentí muy en casa mientras estuve allá. El cansancio de haber salido a las 4 de la mañana y haber llegado en casa a las 10 de la noche valió mucho la pena, no sólo por el encuentro, sino también por las grandes amistades hechas. Para finalizar, un par de fotos.
~/.bashrc
es uno al cual le llamo vless
y tiene las propiedades de ser un paginador (al usar less) con coloreado de sintaxis (al usar vim).
Para que el alias funcione, primero tenemos que tener instalado vim
. Si no lo tenemos, lo hacemos de la siguiente manera:
$ sudo yum install vim-enhanced
Luego, creamos el alias en el archivo ~/.bashrc
, abriéndolo con nuestro editor preferido y adicionando la siguiente línea:
alias vless='/usr/share/vim/vim73/macros/less.sh'
Guardamos los cambios, cerramos el archivo, abrimos un nuevo terminal y hacemos un test para ver si funciona correctamente:
$ vless /usr/share/vim/vim73/macros/less.sh
lo cual nos debería mostrar algo así:
]]>$ sudo yum install cowsay fortune-mod
Para que la cita sea sobre Linux y además sea dicha por Tux, hacemos lo siguiente:
$ cd ~
$ echo "fortune linux | cowsay -f tux" >> .bashrc
Luego abrimos un nuevo terminal y aparecerá algo como esto:
]]>La mayoría de las veces es necesario especificar la dimensión de las imágenes que se colocan en el blog. No sé como harán los demás, pero yo abría la imagen con algún programa e intentaba redimensionar manteniendo las proporciones, después copiaba el nuevo tamaño y listo.
Para no tener que hacer todo eso cada vez que voy a poner una imagen en el blog, escribí el siguiente script de bash, el cual es muy simple y necesita de ImageMagick instalado en el sistema para que funcione:
1 2 3 4 5 6 7 8 9 10 11 12 |
|
El script mantiene las proporciones y funciona especificando el nombre de la imagen y el tamaño en porcentaje (usando 100 nos da el tamaño real):
]]>For more informations, take e look here:
https://admin.fedoraproject.org/pkgdb/acls/name/pekwm
The following screenshot shows PekWM 0.1.17 running under a qemu-kvm virtual machine with Fedora 19 Beta (click to enlarge):
]]>/etc/yum.repos.d/fedora.repo
, utilizamos el siguiente comando:
$ repoquery --disablerepo=\* --enablerepo=fedora -qa --qf='%{SIZE}' | awk '{sum+=$1} END{printf("Total size: %d MB\n", sum/1024/1024)}'
Total size: 33910 MB
Ese es el resultado que obtengo en mi caso usando Fedora 18. Podemos hacerlo con cualquier repositorio que aparezca en /etc/yum.repos.d/
. Inclusive podemos poner más de uno, por ejemplo usando --enablerepo=fedora,updates
sabremos el tamaño total de los repositorios /etc/yum.repos.d/fedora.repo
y /etc/yum.repos.d/fedora-updates.repo
El comando repoquery (perteneciente al paquete yum-utils
), junto con las opciones que le pusimos, nos lista los tamaños de todos los paquetes que contiene.
El comando awk en este caso va sumando todas las líneas, hasta que presentamos el valor final en megabytes (por eso la doble división al final).
]]>Estoy inaugurando mi blog en Github usando Octopress. Más adelante voy a migrar los contenidos del viejo blog en WordPress.
Por ahora voy a seguir aprendiendo a configurar Octopress, y a usar los diferentes plugins, así que el primer post de verdad va a demorar un poco.
Es una delicia poder editar los posts con Vim, y además utilizar la sintaxis de Markdown que es muy simple.
Con el pasar del tiempo iré poniendo cosas relacionadas a Fedora, Astrofísica, programación, comandos útiles, breves tutoriales, etc.
]]>