Planeta GNOME Hispano
La actividad Hispana de GNOME 24 x 7

05 de octubre de 2016

Frogr 1.2 released

Of course, just a few hours after releasing frogr 1.1, I’ve noticed that there was actually no good reason to depend on gettext 0.19.8 for the purposes of removing the intltool dependency only, since 0.19.7 would be enough.

So, as raising that requirement up to 0.19.8 was causing trouble to package frogr for some distros still in 0.19.7 (e.g. Ubuntu 16.04 LTS), I’ve decided to do a quick new release and frogr 1.2 is now out with that only change.

One direct consequence is that you can now install the packages for Ubuntu from my PPA if you have Ubuntu Xenial 16.04 LTS or newer, instead of having to wait for Ubuntu Yakkety Yak (yet to be released). Other than that 1.2 is exactly the same than 1.1, so you probably don’t want to package it for your distro if you already did it for 1.1 without trouble. Sorry for the noise.


Frogr 1.1 released

After almost one year, I’ve finally released another small iteration of frogr with a few updates and improvements.

Screenshot of frogr 1.1

Not many things, to be honest, bust just a few as I said:

  • Added support for flatpak: it’s now possible to authenticate frogr from inside the sandbox, as well as open pictures/videos in the appropriate viewer, thanks to the OpenURI portal.
  • Updated translations: as it was noted in the past when I released 1.0, several translations were left out incomplete back then. Hopefully the new version will be much better in that regard.
  • Dropped the build dependency on intltool (requires gettext >= 0.19.8).
  • A few bugfixes too and other maintenance tasks, as usual.

Besides, another significant difference compared to previous releases is related to the way I’m distributing it: in the past, if you used Ubuntu, you could configure my PPA and install it from there even in fairly old versions of the distro. However, this time that’s only possible if you have Ubuntu 16.10 “Yakkety Yak”, as that’s the one that ships gettext >= 0.19.8, which is required now that I removed all trace of intltool (more info in this post).

However, this is also the first time I’m using flatpak to distribute frogr so, regardless of which distribution you have, you can now install and run it as long as you have the org.gnome.Platform/x86_64/3.22 stable runtime installed locally. Not too bad! :-). See more detailed instructions in its web site.

That said, it’s interesting that you also have the portal frontend service and a backend implementation, so that you can authorize your flickr account using the browser outside the sandbox, via the OpenURI portal. If you don’t have that at hand, you can still used the sandboxed version of frogr, but you’d need to copy your configuration files from a non-sandboxed frogr (under ~/.config/frogr) first, right into ~/.var/app/org.gnome.Frogr/config, and then it should be usable again (opening files in external viewers would not work yet, though!).

So this is all, hope it works well and it’s helpful to you. I’ve just finished uploading a few hundreds of pictures a couple of days ago and it seemed to work fine, but you never know… devil is in the detail!


30 de septiembre de 2016

Cross-compiling WebKit2GTK+ for ARM

I haven’t blogged in a while -mostly due to lack of time, as usual- but I thought I’d write something today to let the world know about one of the things I’ve worked on a bit during this week, while remotely attending the Web Engines Hackfest from home:

Setting up an environment for cross-compiling WebKit2GTK+ for ARM

I know this is not new, nor ground-breaking news, but the truth is that I could not find any up-to-date documentation on the topic in a any public forum (the only one I found was this pretty old post from the time WebKitGTK+ used autotools), so I thought I would devote some time to it now, so that I could save more in the future.

Of course, I know for a fact that many people use local recipes to cross-compile WebKit2GTK+ for ARM (or simply build in the target machine, which usually takes a looong time), but those are usually ad-hoc things and hard to reproduce environments locally (or at least hard for me) and, even worse, often bound to downstream projects, so I thought it would be nice to try to have something tested with upstream WebKit2GTK+ and publish it on,

So I spent some time working on this with the idea of producing some step-by-step instructions including how to create a reproducible environment from scratch and, after some inefficient flirting with a VM-based approach (which turned out to be insanely slow), I finally settled on creating a chroot + provisioning it with a simple bootstrap script + using a simple CMake Toolchain file, and that worked quite well for me.

In my fast desktop machine I can now get a full build of WebKit2GTK+ 2.14 (or trunk) in less than 1 hour, which is pretty much a productivity bump if you compare it to the approximately 18h that takes if I build it natively in the target ARM device I have 🙂

Of course, I’ve referenced this documentation in, but if you want to skip that and go directly to it, I’m hosting it in a git repository here:

Note that I’m not a CMake expert (nor even close) so the toolchain file is far from perfect, but it definitely does the job with both the 2.12.x and 2.14.x releases as well as with the trunk, so hopefully it will be useful as well for someone else out there.

Last, I want to thanks the organizers of this event for making it possible once again (and congrats to Igalia, which just turned 15 years old!) as well as to my employer for supporting me attending the hackfest, even if I could not make it in person this time.

Endless Logo

25 de septiembre de 2016

Retrospectiva HackLab Almería 2012-2015 y pico

Este fin de semana tuve el privilegio de ser invitado por GDG Spain y en particular por ALMO para presentar en el Spanish GDG Summit 2016 la experiencia de la actividad en el HackLab Almería:

Aunque llegué muy inseguro porque soy muy crítico con los que considero fracasos míos, al conocer las vicisitudes de los grupos locales del GDG comprobé que a nosotros no nos va tan mal y que tenemos experiencias muy interesantes para terceros.

De paso me ha servido para reconsiderar parte del trabajo hecho y para documentar más claramente nuestras cosas para nuestra propia gente: creo que es buena idea que todos le demos un repaso.

Es posible que haya algún error y alguna carencia. Todas las opiniones son absolutamente personales y no todo el mundo ha de compartirlas. No tengo tanto interés en discutir las afirmaciones como de corregir errores o inconsistencias. Tened presente de que no es una memoria completa de actividades porque eso sería enooorme, sólo una retrospectiva esquemática.

Está escrita en formato de mapa-mental usando Freemind 1.0.1. El formato tal vez os parezca engorroso, pero las restricciones de tiempo y de presentación de la información no me han permitido nada mejor. Lamento las molestias. Podéis descargar el fichero que incluye el mapa desde aquí:

PS: esta misma entrada ha sido publicada en el foro del HackLab Almería.

20 de septiembre de 2016

WebKitGTK+ 2.14

These six months has gone so fast and here we are again excited about the new WebKitGTK+ stable release. This is a release with almost no new API, but with major internal changes that we hope will improve all the applications using WebKitGTK+.

The threaded compositor

This is the most important change introduced in WebKitGTK+ 2.14 and what kept us busy for most of this release cycle. The idea is simple, we still render everything in the web process, but the accelerated compositing (all the OpenGL calls) has been moved to a secondary thread, leaving the main thread free to run all other heavy tasks like layout, JavaScript, etc. The result is a smoother experience in general, since the main thread is no longer busy rendering frames, it can process the JavaScript faster improving the responsiveness significantly. For all the details about the threaded compositor, read Yoon’s post here.

So, the idea is indeed simple, but the implementation required a lot of important changes in the whole graphics stack of WebKitGTK+.

  • Accelerated compositing always enabled: first of all, with the threaded compositor the accelerated mode is always enabled, so we no longer enter/exit the accelerating compositing mode when visiting pages depending on whether the contents require acceleration or not. This was the first challenge because there were several bugs related to accelerating compositing being always enabled, and even missing features like the web view background colors that didn’t work in accelerated mode.
  • Coordinated Graphics: it was introduced in WebKit when other ports switched to do the compositing in the UI process. We are still doing the compositing in the web process, but being in a different thread also needs coordination between the main thread and the compositing thread. We switched to use coordinated graphics too, but with some modifications for the threaded compositor case. This is the major change in the graphics stack compared to the previous one.
  • Adaptation to the new model: finally we had to adapt to the threaded model, mainly due to the fact that some tasks that were expected to be synchronous before became asyncrhonous, like resizing the web view.

This is a big change that we expect will drastically improve the performance of WebKitGTK+, especially in embedded systems with limited resources, but like all big changes it can also introduce new bugs or issues. Please, file a bug report if you notice any regression in your application. If you have any problem running WebKitGTK+ in your system or with your GPU drivers, please let us know. It’s still possible to disable the threaded compositor in two different ways. You can use the environment variable WEBKIT_DISABLE_COMPOSITING_MODE at runtime, but this will disable accelerated compositing support, so websites requiring acceleration might not work. To disable the threaded compositor and bring back the previous model you have to recompile WebKitGTK+ with the option ENABLE_THREADED_COMPOSITOR=OFF.


WebKitGTK+ 2.14 is the first release that we can consider feature complete in Wayland. While previous versions worked in Wayland there were two important features missing that made it quite annoying to use: accelerated compositing and clipboard support.

Accelerated compositing

More and more websites require acceleration to properly work and it’s now a requirement of the threaded compositor too. WebKitGTK+ has supported accelerated compositing for a long time, but the implementation was specific to X11. The main challenge is compositing in the web process and sending the results to the UI process to be rendered on the actual screen. In X11 we use an offscreen redirected XComposite window to render in the web process, sending the XPixmap ID to the UI process that renders the window offscreen contents in the web view and uses XDamage extension to track the repaints happening in the XWindow. In Wayland we use a nested compositor in the UI process that implements the Wayland surface interface and a private WebKitGTK+ protocol interface to associate surfaces in the UI process to the web pages in the web process. The web process connects to the nested Wayland compositor and creates a new surface for the web page that is used to render accelerated contents. On every swap buffers operation in the web process, the nested compositor in the UI process is automatically notified through the Wayland surface protocol, and  new contents are rendered in the web view. The main difference compared to the X11 model, is that Wayland uses EGL in both the web and UI processes, so what we have in the UI process in the end is not a bitmap but a GL texture that can be used to render the contents to the screen using the GPU directly. We use gdk_cairo_draw_from_gl() when available to do that, falling back to using glReadPixels() and a cairo image surface for older versions of GTK+. This can make a huge difference, especially on embedded devices, so we are considering to use the nested Wayland compositor even on X11 in the future if possible.


The WebKitGTK+ clipboard implementation relies on GTK+, and there’s nothing X11 specific in there, however clipboard was read/written directly by the web processes. That doesn’t work in Wayland, even though we use GtkClipboard, because Wayland only allows clipboard operations between compositor clients, and web processes are not Wayland clients. This required to move the clipboard handling from the web process to the UI process. Clipboard handling is now centralized in the UI process and clipboard contents to be read/written are sent to the different WebKit processes using the internal IPC.

Memory pressure handler

The WebKit memory pressure handler is a monitor that watches the system memory (not only the memory used by the web engine processes) and tries to release memory under low memory conditions. This is quite important feature in embedded devices with memory limitations. This has been supported in WebKitGTK+ for some time, but the implementation is based on cgroups and systemd, that is not available in all systems, and requires user configuration. So, in practice nobody was actually using the memory pressure handler. Watching system memory in Linux is a challenge, mainly because /proc/meminfo is not pollable, so you need manual polling. In WebKit, there’s a memory pressure handler on every secondary process (Web, Plugin and Network), so waking up every second to read /proc/meminfo from every web process would not be acceptable. This is not a problem when using cgroups, because the kernel interface provides a way to poll an EventFD to be notified when memory usage is critical.

WebKitGTK+ 2.14 has a new memory monitor, used only when cgroups/systemd is not available or configured, based on polling /proc/meminfo to ensure the memory pressure handler is always available. The monitor lives in the UI process, to ensure there’s only one process doing the polling, and uses a dynamic poll interval based on the last system memory usage to read and parse /proc/meminfo in a secondary thread. Once memory usage is critical all the secondary processes are notified using an EventFD. Using EventFD for this monitor too, not only is more efficient than using a pipe or sending an IPC message, but also allows us to keep almost the same implementation in the secondary processes that either monitor the cgroups EventFD or the UI process one.

Other improvements and bug fixes

Like in all other major releases there are a lot of other improvements, features and bug fixes. The most relevant ones in WebKitGTK+ 2.14 are:

  • The HTTP disk cache implements speculative revalidation of resources.
  • The media backend now supports video orientation.
  • Several bugs have been fixed in the media backend to prevent deadlocks when playing HLS videos.
  • The amount of file descriptors that are kept open has been drastically reduced.
  • Fix the poor performance with the modesetting intel driver and DRI3 enabled.

15 de septiembre de 2016

Acceso VPN a la red de CICA usando Fedora

Esta es una entrada de servicio público. Si eres usuario de la VPN de CICA y usas un linux moderno como Fedora (23 en este caso) puede serte de utilidad esta entrada.

CICA usa OpenVPN. Lo ideal sería poder configurar el acceso con NetworkManager, que dispone de la funcionalidad de openvpn, pero en ninguna de mis pruebas he conseguido una configuración operativa, creo que porque NM espera que el certificado de usuario sea emitido por la misma CA que la configuración de la red en cuestión, que no es el caso. El caso es que tras varias pruebas he conseguido conectar desde la CLI contando con la ayuda del CAU de Sistemas de CICA.

Básicamente necesitas:

dev tun
proto udp
remote 1194
resolv-retry infinite
user nobody
group nobody
ca /home/usuario/cica-vpn/TERENASSL2_PATH.pem
pkcs12 /home/usuario/.X509/FNMTClase2CA.p12
verify-x509-name name
cipher AES-128-CBC
verb 3

Para poder conectar basta lanzar algo parecido a:

sudo /usr/sbin/openvpn --config /home/usuario/cica-vpn/cica-config.ovpn

Entonces openvpn te solicitará tres datos:

  • usuario de la red CICA
  • contraseña asociada
  • contraseña de acceso a tu certificado X509 emitido por FNMT.

Por dejarlo completamente claro

  • /home/usuario/cica-vpn/TERENASSL2_PATH.pem es el certificado que descargas de
  • /home/usuario/.X509/FNMTClase2CA.p12 es tu certificado de la FNMT-RCM exportado probablemente desde tu navegador y protegido por una contraseña.

Que ojalá os sirva.

Publicada la vieja web de TLDP-ES/LuCAS en Github

Desde hace unos buenos años CICA ha tenido la gentileza de alojar el servidor principal del viejo TLDP-ES que los linuxeros más fogueados recordarán como Fue imperativo migrar el servicio desde el momento en el que mantenimiento de los sistemas de Hispalinux empezó a colapsar y tuve suerte de que CICA nos ofreciera una VM pequeñita donde alojar lo que se pudo salvar de la web. Claro que ya no era una web importante, pero me dolía mucho dejar que desapareciera el testigo de toda una época y el fruto del trabajo de muchas personas durante muchísimas horas. Tampoco me gusta ir dejando enlaces rotos en la web si puedo evitarlo.

En este mismo proceso de «arqueología» hace ya tiempo que pensé en publicar otro repositorio que usábamos para el mantenimiento de TLDP-ES, el control de versiones con el que queríamos facilitar el trabajo de los voluntarios. Así creé este repo en Github: Ahora, de la misma manera me he propuesto publicar igualmente el contenido de la web que ahora está disponible también en Github:

Prácticamente no es más que un pequeño ejercicio de nostalgia, pero en fin, ahí queda.

Gracias a todos los que hicisteis posible ese gran servicio que fue TLDP-ES/LuCAS. Definitivamente creo que fue algo grande.

05 de septiembre de 2016

Probando el Subsistema Windows 10 para Linux (Beta)

El 30 de marzo saltaba la noticia: las llamadas al sistema de Linux  se podrán ejecutar en Windows 10 de forma “nativa” (se podrán traducir en tiempo real a llamadas al sistema de Windows, algo así como un WINE a la inversa):

Intenté probarlo en su día, pero no encontraba tiempo. Tampoco creo que estuviera disponible para todos los usuarios… Hoy he recordado la noticia y le he dedicado un rato porque necesito ejecutar algunas funcionalidades de Linux en una máquina Windows (y la opción de Cygwin me parece demasiado “heavy”… y problemática, la he sufrido en alguno de mis cursos, donde he recibido numerosas peticiones de auxilio 😉

Para probar el subsistema Windows para Linux (Windows Subsystem for Linux o WSL) hay que tener la actualización Windows 10 Anniversary Update (se publicó en Agosto de este año). La forma más sencilla es a través de este enlace oficial a la web de Microsoft. Tras la instalación/upgrade, hay que activar el modo programador entrando en Configuración / Para programadores


A continuación, entramos en Panel de Control / Programas / Activar o desactivar las características de Windows . Activamos el Subsistema de Windows para Linux (beta) y reiniciamos las veces que haga falta 😛


Ahora viene lo bueno. Ejecutamos bash desde el menú de inicio (tecleamos bash y pulsamos intro) y al ser la primera vez se lanzará la instalación:


Le costará un rato descargar WSL (al final está descargando una especie de versión de Ubuntu Server) y activarlo. Cuando lo haga, nos pedirá crear un usuario (que por defecto estará en la lista de sudoers)bash2

Le asignamos un pass al nuevo user y tachán, ya estamos en Bash 🙂


Se hace raro poder ejecutar ls, id, pwd, cat, vi ! , apt (sí apt-get!) en Windows sin recibir mensajes de error…bash4

Realmente estamos en Bash dentro de un Ubuntu 14.04 ejecutándose sobre Windows 10. Buf… si me lo llegan a decir hace un tiempo hubiera puesto cara de incrédulo.bash5

Los archivos están donde deben (en un sistema que siga el LSB) y tienen el contenido esperado.


El sistema de archivos del anfitrión Windows está montado en /mnt . Tenemos los repos apt de Ubuntu a nuestra disposición para instalar las aplicaciones que necesitemos.


Otro puntazo a favor es que tenemos un intérprete python y un intéprete perl instalados de serie (los mismos que instala Ubuntu 14.04, claro)


También he visto que hay un servicio ssh lanzado en el puerto 22, pero por lo que he probado NO es openssh (se puede ver el fingerprint del servidor mediante un simple telnet – sí, telnet, para ver el banner del server – al puerto 22), sino un servidor SSH de Windows (yo diría que en alfa, porque aún no he conseguido autenticarme y creedme que he probado de todo). ¿Tal vez sea una implementación en desarrollo del port openssh de Microsoft ?


Leyendo algunos foros comentaban que openssh se puede configurar para que escuche en un puerto distinto al 22 (el 60022, por ejemplo), abrir una regla en el firewall de Windows para ese nuevo puerto y listo. Si no lo tenemos instalado por defecto (en mi caso sí lo estaba) siempre podremos instalarlo con sudo apt-get update && sudo apt-get install openssh 🙂

A continuación, modificamos /etc/ssh/sshd_config y lo dejamos así:

Port 60022
Protocol 2
HostKey /etc/ssh/ssh_host_rsa_key
HostKey /etc/ssh/ssh_host_dsa_key
HostKey /etc/ssh/ssh_host_ecdsa_key
HostKey /etc/ssh/ssh_host_ed25519_key
UsePrivilegeSeparation no
KeyRegenerationInterval 3600
ServerKeyBits 1024
SyslogFacility AUTH
LogLevel INFO
LoginGraceTime 120
PermitRootLogin without-password
StrictModes yes
RSAAuthentication yes
PubkeyAuthentication no
IgnoreRhosts yes
RhostsRSAAuthentication no
HostbasedAuthentication no
PermitEmptyPasswords no
ChallengeResponseAuthentication no
PasswordAuthentication yes
X11Forwarding yes
X11DisplayOffset 10
PrintMotd no
PrintLastLog yes
TCPKeepAlive yes
AcceptEnv LANG LC_*
Subsystem sftp /usr/lib/openssh/sftp-server
UsePAM yes

Si openssh ya estaba instalado, antes de reiniciar el server openssh lo reconfiguramos (si no lo hacemos, arrancará, pero no conseguiremos conectar porque no habrá generado los ficheros necesarios):

$ sudo dpkg-reconfigure openssh-server

Ahora sí, reiniciamos el server openssh:

sudo service ssh restart

Y conectamos desde localhost para probar:


¡Funciona! 🙂

UPDATE (5/09/2016): si en algún momento la liamos parda con la configuración del WSL, siempre podremos desinstalar y volver a instalar con dos sencillos comandos:

C:\> lxrun.exe /uninstall /full
C:\> lxrun.exe /install

UPDATE (6/09/2016): es posible iniciar el servidor openssh de WSL al arrancar el equipo. Para ello, basta con parar el Server SSH de Microsoft (el que viene por defecto) y lanzar OpenSSH con la configuración indicada, salvo que ahora podremos lanzarlo en su puerto natural, el 22. Además, si queremos lanzar el servidor cada vez que iniciemos el equipo, podremos crear un script de arranque.

02 de septiembre de 2016

Cerber edo kode kaltegarriaren negozioa


Ransomware delako kode kaltegarri motakoa da Cerber. Horrelako beste hainbat izen ezagunak etortzen zaizkigu burura: Locky, CryptoWall, Crypt0L0cker, TeslaCrypt… Dakigun bezala, malware mota honek gure disko gogorraren edukia zifratu egingo du eta berreskuratzea ezinezkoa izango da ez badugu erreskate bat ordaintzen. Zifratzeko gako publikoko kriptografia + kriptografia simetrikoa erabiltzen omen dute (RSA+AES). Beste mezu batean hau nola egiten duten azalduko dut, baina Bromium enpresak argitaratutako txosten honetan informazio lagungarria aurkituko duzu gehiago sakondu nahi izanez gero.

Orain interesatzen zaidana da kontu azkar batzuk egitea hemen. Eta soilik ransomware bakar baten inguruan: Cerber. @malwaretechblog ikertzailearen arabera, egunero Cerber-ek 6000 biktima berri kutsatzen ditu. Ez da ausaz asmatutako zenbaki bat, baizik eta bere tracker-sareak egunero antzematen dituena.

Orain kalkulu azkar bat. Demagun 6000 infekzio horietatik soilik %3-ak ordaintzen duela erreskatea. Zenbateko erreskatea da hori? Nola ordaintzen da? Ba 500$ gutxi gorabehera… eta BitCoin-etan ordaintzen da. Lehenengo Tor sarea erabiltzeko nabigatzailea instalatu beharko duzu, gero BitCoin-ak erosi, ordaindu eta zifratzeko erabili zen gakoa berreskuratzearen zain pazientziarekin itxaron. Hainbat gauza daude hemen zehazteko… adibidez, zergatik esan dut gutxi gorabehera? Honegatik:


Azkar ordainduz gero (7 egun baino gutxiagotan), 1.24 bitcoin (521$ gutxi gora behera) izango dira. Erreskatea beranduago ordainduz gero, bikoiztu egingo da isuna: 2.48 BTC = 1043$

Ordaindu ezean, nola berreskuratu? Ez dago modurik. Hasierako bertsioa gaizki programatuta bazegoen ere (beraz, ordaindu gabe bazegoen berreskuratzeko modu bat), gaur egun asko “hobetu” dute Cerber-en kodea eta ez dago ordaindu gabe berreskuratzeko  modurik. Hemen babes-kopien politikaren beharraz arituko nintzen, baina ez da une egokia 😉 Ordaindu edo ez, hori bakoitzaren eskuetan uzten dut.

Baina gatozen harira.  6.000 kutsadura * 0.03 ordainketa * 500$ = 90000$ , EGUNERO.

Nola banatzen da Cerber bezalako kode kaltegarria? Zein dago horren atzetik? Nola kutsatzen gara? Ezin da ezer egin honen aurka? Aztertzeko hainbat galdera interesgarri…

01 de septiembre de 2016

Migration to https

I’ve postponed this for eons but it has been the time to migrate the website to https

Concerned about the privacy, in 2009 the EFF launched the campaign Encrypt the Web aiming all the Web users to migrate to encrypted communications, concerning sysadmins, software programmers and users. Now I did the needed step for my main web server and since there are lots of better documentation on this I’ll just comment briefly some practical details.

First, the tools that helped me with the process:

You should try both if you didn’t yet. And thanks a lot to the Mozilla Foundation for creating them.

Second, the migration issues, because the auditing results are pretty bad: 🙈

results of scan summary

  • I’m not sure if my server changes would have some collateral effects in the other hosted webs. I’m not the best sysadmin. Let’s see.
  • One of the biggest problem of this migration is how old this server is: a CentOS 5 server which should have been migrated years ago. Still in my ToDo. I think the most negative points of the auditing are consequence of this.
  • The other one is the CA of my X509 certificates. For some years I’ve been a promoter of CACert and I’m using this certificates for other services in my server but at this moment the CACert hasn’t been able to get accepted their root certificate with the WebTrust Principles and Criteria for Certification Authorities and the internal crisis of the organization breaks all my hopes for a community driven certification authority X509 compatible. In practice this mean my current X509 certificate is not trustable for everybody who has not added the CACert root certificate by hand. Not a fun thing.

If you are reading these lines then is very probable you know about Letscencrypt which I really love too. This time I have two concerns with Letscrypt: the first this server is too old that should be migrated soon, the second is Letsencrypt is not designed to verify identities. The alternative seems to be to find a free (as beer) or paid CA providing hte verification service.

Well, I know this entry is not very useful for the most of the users, but I’m trying now to write more regularly and to document my routine technical progresses. And as the song says, «que ojalá os sirva».

PD: Finally I deactivated the apache redirection from http to https because using a CACert certificate broke my RPM repository and complicated the access to my web for some users. This is sad.

30 de agosto de 2016

Guía de Linux para el usuario en epub

Hoy mi amigo Eduardo me ha pedido bibliografía elemental en formato digitla para empezar en serio con Linux. Mi primera idea ha sido ir a revisar o que teníamos publicado en TLDP-ES/LuCAS y lo primero que he pensado es en hacerle llegar una copia de la vieja G.L.U.P. - Guía de Linux Para el Usuario que debería atender la mayor parte de las dudas básicas del recién llegado. Como la mejor forma de leer un documento, sea en tableta, teléfono o en un lector de ebook es ePub he pensado cómo apañarlo. He aprovechado para refrescar sobre las herramientas disponibles a partir de los formatos que publicamos en su momento que son básicamente PDF y HTML. Aunque El odioso PDF es manejable por estos dispositivos, no es tan acomodable a la pantalla como puedan serlo HTML y ePub.

Hoy mi amigo Eduardo me ha pedido bibliografía elemental para empezar en serio con Linux y he decidido hacerle llegar una copia manejable de la vieja G.L.U.P. - Guía de Linux Para el Usuario en formato ePub. Así he descargado una copia en HTML de la misma, y he cambiado el archivado tar.gz por uno zip y he creado el ebook con el conversor de Calibre:

ebook-convert glup_0.6-1.1-html-1.1.epub

y listo: pantallazo de GLUP en ebook-viewer.

Después he aprovechado para hacer un poquito de control de calidad con otra utilidad de Calibre: ebook-edit.

Podéis descargar esta versión del libro desde este enlace glup_0.6-1.1-html-1.1.epub. Y como dice la canción: «que ojalá os sirva».

19 de agosto de 2016

Cambios en mi web

Después de postergarlo por mucho tiempo y tras haber adquirido algo de experiencia al crear con Jekyll las web de HackLab Almería y Club de Cacharreo me he animado a descartar al viejo Lameblog y ponerme manos a la obra. Si se nota alguna inconsistencia en mi web tened la seguridad de que es culpa mía. Y no me refiero al diseño, que es algo que ya doy por perdido.

Algo fantástico de Jekyll es que puedes migrar un blog al menos a través del fichero RSS del antiguo. Y por ahora parece funcionar divinamente.

Una inconsistencia a la que tristemente renuncio a corregir son las URI/permalinks originales, que además son las que usa Disqus para recuperar los comentarios. Como Lameblog se hacía algo de lío al generar las URIs con la localización ES pues se ha quedado todo un poco guarro y ahora me parece un lío arreglarlo. Por otro lado voy a procurar a no eliminar contenido de las URIs antiguas por los (pocos) enlaces externos que pudiera haber. Perderé los comentarios, sí, en las versiones nuevas de las entradas pero realmente no son demasiados y deberían seguir accesibles en las antiguas.

PD: Finalmente me he puesto a migrar los comentarios del blog alojados en Disqus. Afortunadamente parece que el proceso está bastante bien implementado Migration console y en mi caso, ya que no me he atrevido a especificar unas reglas que indiquen la transformación de las URIs antiguas a las modernas he seguido el procedimiento manual en el que descargas un fichero CSV con las entradas (URIs) que Disqus ha registrado en la columna A para añadir en la B la nueva. En mi caso han sido más de 500 pero, OjO, 500 URIs no significan 500 comentarios ni por asomo. De hecho una de las cosas que he verificado es el poco interés que despierta mi blog por los pocos comentarios o recomendaciones recibidos :_( En fin.

El caso es que he querido verificar cada una de las URIs si eran dignas de ser migradas y sólo se me ha ocurrido un procedimiento manual que básicamente he gestionado con esta línea de bash:

 for a in `cat olea-2016-08-21T20-27-31.368505-links.csv ` ; do chrome "$a" && read -p  "pulsa Enter" ;done

Donde olea-2016-08-21T20-27-31.368505-links.csv es el fichero CSV descargado. El porqué del read es para evitar que se abran 500 solapas en el navegador.

En la práctica han sido muy pocas las URIs que he indicado migrar (20 o 30 máximo) porque no había más comentarios ni recomendaciones. A continuación, siguiendo las instrucciones de Disqus he subido el fichero CSV revisado y he esperado a que fuera procesado. Y listo.

En realidad me ha costado un poquito más porque ha cambiado el código que Disqus proporciona para integración y al final he encontrado este precioso código jekyll de Joshua Cox que ha terminado por resolver toda esta parte.

Ale, a disfrutarlo con salud.

PS: Igual hasta hacemos otro tallercín en el HackLab Almería para compartir la experiencia con los compis.

11 de agosto de 2016

Going to GUADEC 2016

I am at the airport getting ready to board beginning my trip to Karlsruhe for GUADEC 2016. I’ll be there with my colleague Michael Catanzaro.Please talk to us if you are interested in browsers or Igalia.

22 de julio de 2016

Padding con Vim

Tenemos la siguiente imagen ASCII:

Captura de pantalla 2016-07-22 a las 20.06.50

Si nos fijamos, hay líneas de distintas longitudes (las más largas son de 80 caracteres). Queremos hacer padding (rellenar) con el carácter ‘#’ para que todas las líneas sean de la misma longitud (80). Podemos hacerlo con un pequeño script en cualquier lenguaje de programación, pero la idea es: ¿se puede hacer con una única línea que use inteligentemente expresiones regulares y funciones en Vim? Sí 🙂

:%s/\v^.*$/\= submatch(0) . repeat("#", 80 - len(submatch(0)))

\v : magia, literal (ver la ayuda). Todos los caracteres que aparezcan tras este patrón se tomarán como caracteres especiales (no es necesario escaparlos). Efectivamente, olvídate de poner \(.*\) para hacer agrupaciones, basta con \v(.*)

^.*$ : desde el comienzo hasta el final de línea

\=  : comienzo de función

submatch(0) : primer match de la expresión regular (es la línea completa)

.  : concatenar con lo siguiente

repeat(“#”, 80 – len(submatch(0)))  : repetir el carácter #  x veces, donde x = 80 – longitud de línea

Éste es el resultado:

Captura de pantalla 2016-07-22 a las 20.19.27

16 de julio de 2016

14 de julio de 2016

Advanced Natural Language Processing Tools for Bot Makers – LUIS,,

12 de julio de 2016

Novedades en la equivalencia internacional de títulos superiores españoles

Para empezar reconoceré que no tengo bien estudiada la regulación de las titulaciones universitarias en España. El caso es que he recibido el aviso de que se han publicado por fin las equivalencias internacionales de los títulos españoles. Por algún motivo tradicional, la estructura de las titulaciones superiores en España ha tenido poco que ver con las del resto del mundo. Se supone que ya todos sabemos cuáles han sido las transformaciones obligadas por «el plan Bolonia», que entre otras cosas pretende la movilidad de estudiantes y trabajadores y la interoperabilidad automática de los títulos superiores entre los paises comunitarios (creo que estrictamente va más allá de la UE pero hoy no es mi objetivo ser exhaustivo). Al parecer esa transformación de los títulos no era suficiente para saber cómo equivalen en el extranjero nuestros títulos. Y peor aún, cuáles son las equivalencias de los títulos superiores pre-Bolonia, que con frecuencia siguen siendo un lío al cambiar de universidad sin salir del país. La novedad es que parece que esa información ya ha quedado resuelta.

Siendo muy esquemático: el sistema de interoperabilidad de las titulaciones superiores en España se establece en el Marco Español de Cualificaciones para la Educación Superior (MECES), que, si yo no lo entiendo mal, sirve para establecer las equivalencias con el Marco Europeo de Cualificaciones para el Aprendizaje Permanente (EQF en inglés), que es la piedra de Rosetta para todo este sistema.

Pues bien, desde el 1 de junio de 2016 ya están publicadas oficialmente las equivalencias, como indican en el original: «correspondence between the Spanish Qualifications Framework for Higher Education and the European Qualifications Framework».

Cuadro MECES / EQF de equivalencias de títulos superiores españoles

¿Cuáles son las consecuencias? Probablemente algunas más, pero entiendo que al menos a partir de ahora, por ejemplo, puedes matricularte en cualquier universidad que implemente el EQF sin tener que pasar por el desesperante proceso de convalidación de tus títulos.

Dejo esta entrada a modo de recordatorio personal y con la esperanza de que sea de utilidad. Si alguien detecta algún error que por favor lo indique en los comentarios.


11 de mayo de 2016

Algunos recursos de investigación sobre calidad del software aplicada a proyectos de software libre

Con la excusa de responder a una solicitud de información sobre este tema he preparado un repaso, informal e incompleto, OjO, de recursos relacionados que tenía en mente. Y ya puestos lo cuelgo en el blog. Aquí está.

04 de mayo de 2016

Plataformas MOOC comparadas (III)

Progreso del alumno

En MiríadaX no han dejado de lado esta característica fundamental, pero creo que puede mejorarse significativamente. Para ello, compararemos la zona de progreso de edX con la de MiríadaX.

En edX, el alumno puede ver de un sólo vistazo, sin necesidad de hacer scroll cuántas tareas ha completado hasta el momento, cuántas le quedan por completar, cuál es la nota de corte para dar por aprobado el curso y el porcentaje actual de completamiento del curso:


De forma sucinta, se indica el resultado de cada prueba y la fecha en la que se realizó.

Para ver el progreso de un alumno en MiríadaX, debemos pulsar en “Notas”. ¿Notas? Inicialmente entendí que era una zona para anotaciones relacionadas con el curso. ¿Por qué no “Progreso”? O de forma alternativa, “Calificaciones”. En fin, esto puede ser un detalle sin importancia. Lo importante es otra cosa:

Captura de pantalla 2016-04-26 a las 22.52.18

Lo primero es la falta de claridad. Ya hablamos de este “pecado” en otras entradas de esta serie. Pero en este caso se hace otra vez evidente. ¿Cuántos puntos (porcentaje) llevo en total? ¿Cuántos debo alcanzar para “aprobar” (nota de corte)? ¿Cuál es la calificación (o nota, siguiendo con la nomenclatura de MiríadaX) del módulo 1? Este curso tiene 10 módulos… Para ver el resultado de cada módulo debo desplazarme hasta el infinito en vertical…

Más aún, en la última entrega obligatoria del módulo 3, vemos un “No aprobado”.


Sin embargo, estoy totalmente seguro de que entregué la tarea y la tengo bien calificada por mis compañeros/as del curso. ¿Qué ocurre? No es evidente, pero el problema es que yo aún no he evaluado el trabajo de 3 de mis colegas. El estado no debería ser “No aprobada”, sino “En progreso”. De hecho, tengo hasta el 30 de mayo para hacer esas evaluaciones. Por cierto, no puedo acceder directamente a esa tarea para ver la razón de ese “No aprobada”. De hecho, si pulso en “Detalle”, se abre una ventana modal:

Captura de pantalla 2016-04-26 a las 23.00.20

Pero no hay enlaces para ver el enunciado de la tarea o las tareas de mis compañeros que me quedan por evaluar.

Tengo que pulsar en “Inicio”, desplazarme al “Módulo 3”, pulsar en “Acceder”, buscar la entrega obligatoria, pulsar en ella y ahí, por fin, ver la causa de mis males:


Evalúo los dos trabajos que me quedan y ¡premio! ¿Era intuitivo? Yo creo que no.


03 de mayo de 2016

Plataformas MOOC comparadas (II)

Enunciado de los ejercicios 

Lo primero que podemos decir es que el interfaz gráfico, diseño y presentación de la sección de presentación de los ejercicios es muy mejorable. Me limitaré a mostrar una captura de pantalla:

Captura de pantalla 2016-04-25 a las 22.55.36

Desde luego, es de todo menos atractiva. Enormes cantidades de texto, sin gráficos ni separaciones evidentes. Ojo, no creo que sea un error del creador (creadores) del curso. Creo que es un error de diseño de la plataforma. Definitivamente no está preparada para impartir cursos MOOC. Veamos algo similar para el caso de Coursera:


En la parte superior hay 3 cajas que dividen claramente las fases de un Ejercicio evaluado entre pares. En la parte central hay espacio para el enunciado del ejercicio y para aceptar el código de conducta. En la parte inferior hay una caja de texto para editar la respuesta o indicar mediante un enlace dónde encontrar la solución detallada. También permite guardar borradores (Save Draft), aspecto éste que brilla por su ausencia en MiriadaX.

En Coursera, también se especifica mediante colores (gris, verde, rojo) en que estado nos encontramos dentro de cada fase:


En MiriadaX no existe este tipo de indicadores. Tampoco podemos auto-evaluarnos:

Captura de pantalla 2016-04-25 a las 23.23.16

Rúbricas (o la ausencia de ellas)

En MiriadaX, el interfaz para evaluar el trabajo de un compañero/a no dispone de una rúbrica de ayuda. No hay criterios, se limita a mostrar una caja de texto y una única puntuación, de 0 a 100:


Esto es tremendamente incómodo. Al final, lo que hacen los alumnos es limitarse a escribir “Muy bien” o “Sigue así”. Dos o tres palabras y una nota de 100. Algo rápido y sin críticas constructivas de ningún tipo. En Coursera, sin embargo, el interfaz es más rico, se dispone de rúbricas de evaluación y cada criterio puede ser evaluado de forma independiente. Además, existe también una caja de texto donde, en algún curso, se pide cumplimentar al menos 20 palabras:


Además, el alumno siempre tiene disponibles los criterios de evaluación de la rúbrica cuando está respondiendo a las preguntas/trabajos, lo que facilita la labor de respuesta:


02 de mayo de 2016

Plataformas MOOC comparadas (I)


A lo largo de esta semana iré publicando mis impresiones sobre las plataformas MOOC que he ido probando como alumno. Compararé aspectos relacionados con la docencia: herramientas para la presentación de contenidos, para el seguimiento del alumno, para la evaluación (autoevaluación, co-evaluación, hetero-evaluación), usabilidad, gestión de certificados, interacción entre usuarios (foros, chats) y también aspectos relacionados con el propio software que sustenta las plataformas (cómo están desarrolladas internamente, qué subsistemas usan, política de licencias).

Las plataformas que traeré a colación son edX, Coursera y MiríadaX,  porque son en éstas donde he trabajado como alumno, y edX y Moodle como plataformas en las que puedo decir algo sobre los aspectos de software, gracias a su licencia abierta.

Antes de nada, quería presentarme, haciendo especial hincapié en los aspectos relacionados con la enseñanza online que he trabajado, bien como alumno o bien como profesor.

También quiero dejar claro que todas las plataformas MOOC que tienen como objetivo expandir el conocimiento y lo hacen de forma gratuita y con materiales de calidad me merecen el mayor de los respetos. Me quito el sombrero ante el trabajo que han realizado (y siguen realizando) edX, Coursera, MiríadaX, Udacity, FutureLearn, P2P University y demás entidades. Lo que viene a continuación son una serie de posts sobre mi experiencia como usuario, como alumno o como desarrollador en todas estas plataformas, indicando los puntos buenos y malos y sugiriendo mejoras mediante análisis comparados.

Empezaremos comparando el sistema de MiríadaX con los de edX y Coursera, dado que son las plataformas sobre la que he estado trabajando más recientemente. MiríadaX usa internamente el CMS Liferay. No es una plataforma preparada ad-hoc para impartir MOOCs  (como podría ser Open-edX o la plataforma de Coursera) y eso se nota en multitud de detalles.  Veamos algunos de ellos, aspectos que no se han cuidado lo suficiente, no se han tenido en cuenta o son mejorables.

Variables sin valores asignados

Si nos fijamos en el mensaje de entrega de una tarea, veremos lo siguiente:entrega1

“La asignación de tareas para evaluar se realizará a las {4} del día {5}, fecha de la zona horaria {6}, que es la establecida en tu perfil.” No es algo que ocurra una vez en una pantalla, ni siquiera algo que ocurrió una vez o dos. Ocurre siempre, desde hace meses.

Incoherencia en la forma de dirigirse al alumno

¿Cómo nos dirigimos al alumno? ¿Debemos usar el tratamiento de usted o el de tú? Entiendo el trato de usted y me parece correcto. Pero en mi caso, me resulta muy artificial. Agradecería una opción que permitiera elegir entre una forma u otra de dirigirse al alumno. No obstante, eso no sería un error: basta con elegir el tratamiento. Sin embargo, lo que sí es un error es “bailar” en el uso de usted y tú.  Si nos fijamos en la ventana anterior, veremos un tratamiento de tú: “Próximamente recibirás…”, “Recuerda realizar…”. Sin embargo, en otras pantallas, vemos el tratamiento de usted, como en la siguiente: “Piensen bien su evaluación…”, “El objetivo de este curso es sacar el máximo provecho al trabajo que están realizando…”


Imposibilidad de reintentar la entrega antes de que finalice el plazo

Una de las aportaciones interesantes de un MOOC es que el alumno puede trabajar por su cuenta, a su ritmo, e ir mejorando sus conocimientos mediante iteraciones: construye una solución y la guarda como posible envío. Esta primera solución seguramente no sea óptima. El alumno puede darse cuenta estudiando algo más, o comentando los problemas encontrados con sus compañeros en el foro. Esta retroalimentación le permitirá mejorar su solución y grabarla como una entrega mejorada. En cualquier caso, es muy conveniente que el sistema que da soporte al MOOC permita la grabación de soluciones. No digo que mantenga un histórico, bastaría con que nos deje guardar un único trabajo, pero que éste se pueda subir tantas veces como se quiera, siempre dentro del plazo de entrega. Cada vez que el alumno envíe, la nueva entrega sustituirá a la anterior (lo ideal, como digo, sería un histórico, pero esta solución parcial de “nos quedamos con la última”, valdría). Lo que no es de recibo es limitar a un único envío, tal y como hace MiríadaX. Avisan por activa y por pasiva que el envío, único, es final. No importa que aún queden días para el “deadline”. No podrás cambiar ni reenviar mejoras a tu trabajo, está prohibido mejorar 🙁 Este es un aspecto que ninguna plataforma MOOC (edX, Coursera, Udacity, FutureLearn, Google CourseBuilder) ha descuidado. Es un error de libro, sin embargo, ahí está.


No entiendo esta restricción. Es muy probable que una vez entregada la tarea, y el alumno esté más relajado, se le ocurran mejoras a la entrega realizada. O simplemente, quiere enviar una versión preliminar – digna, pero no excelente – por si acaso no le da tiempo a completar la versión final, de mayor calidad. Tal cuál está planteada la entrega, esto no puede hacerse. Una entrega evaluada entre pares no es razón para este comportamiento. Puede alegarse que se hace para que los alumnos dispongan rápidamente de ejercicios para evaluar, pero no hay razón para hacerlo así. Se puede dejar un período de evaluación de una semana a partir del momento de la entrega. Por ejemplo,en edX y en Coursera, el alumno puede enviar tantas versiones de su tarea mientras no haya terminado el plazo de entrega.

Por otro lado, se recomienda adjuntar una versión del archivo html con la solución, pero si ya está online… no le veo mucho sentido. Entiendo que pueda ser una medida de seguridad (por si la versión online cae), pero implica nuevos problemas: si la versión online y el archivo (versión offline) varían, ¿cuál evaluar? si la versión offline no incluye referencias a gráficos o vídeos porque están enlazados, ¿qué hacer? y si las incluyen (¿un vídeo?), ¿para qué ofrecer dos versiones?.

13 de abril de 2016

Chromium Browser on xdg-app

Last week I had the chance to attend for 3 days the GNOME Software Hackfest, organized by Richard Hughes and hosted at the brand new Red Hat’s London office.

And besides meeting new people and some old friends (which I admit to be one of my favourite aspects about attending these kind of events), and discovering what it’s now my new favourite place for fast-food near London bridge, I happened to learn quite a few new things while working on my particular personal quest: getting Chromium browser to run as an xdg-app.

While this might not seem to be an immediate need for Endless right now (we currently ship a Chromium-based browser as part of our OSTree based system), this was definitely something worth exploring as we are now implementing the next version of our App Center (which will be based on GNOME Software and xdg-app). Chromium updates very frequently with fixes and new features, and so being able to update it separately and more quickly than the OS is very valuable.

Endless OS App Center
Screenshot of Endless OS’s current App Center

So, while Joaquim and Rob were working on the GNOME Software related bits and discussing aspects related to Continuous Integration with the rest of the crowd, I spent some time learning about xdg-app and trying to get Chromium to build that way which, unsurprisingly, was not an easy task.

Fortunately, the base documentation about xdg-app together with Alex Larsson’s blog post series about this topic (which I wholeheartedly recommend reading) and some experimentation from my side was enough to get started with the whole thing, and I was quickly on my way to fixing build issues, adding missing deps and the like.

Note that my goal at this time was not to get a fully featured Chromium browser running, but to get something running based on the version that we use use in Endless (Chromium 48.0.2564.82), with a couple of things disabled for now (e.g. chromium’s own sandbox, udev integration…) and putting, of course, some holes in the xdg-app configuration so that Chromium can access the system’s parts that are needed for it to function (e.g. network, X11, shared memory, pulseaudio…).

Of course, the long term goal is to close as many of those holes as possible using Portals instead, as well as not giving up on Chromium’s own sandbox right away (some work will be needed here, since `setuid` binaries are a no-go in xdg-app’s world), but for the time being I’m pretty satisfied (and kind of surprised, even) that I managed to get the whole beast built and running after 4 days of work since I started :-).

But, as Alberto usually says… “screencast or it didn’t happen!”, so I recorded a video yesterday to properly share my excitement with the world. Here you have it:

[VIDEO: Chromium Browser running as an xdg-app]

As mentioned above, this is work-in-progress stuff, so please hold your horses and manage your expectations wisely. It’s not quite there yet in terms of what I’d like to see, but definitely a step forward in the right direction, and something I hope will be useful not only for us, but for the entire Linux community as a whole. Should you were curious about the current status of the whole thing, feel free to check the relevant files at its git repository here.

Last, I would like to finish this blog post saying thanks specially to Richard Hughes for organizing this event, as well as the GNOME Foundation and Red Hat for their support in the development of GNOME Software and xdg-app. Finally, I’d also like to thank my employer Endless for supporting me to attend this hackfest. It’s been a terrific week indeed… thank you all!

Credit to Georges Stavracas

Credit to Georges Stavracas

04 de abril de 2016

Mala semana para la seguridad de las extensiones en Firefox y Chrome

Investigadores de seguridad presentaron la semana pasada, en la Black Hat Asia 2016, bajo la ponencia “Automated Detection of Firefox Extension-Reuse Vulnerabilities” una extensión que reutiliza código de otras ya instaladas con fines maliciosos. Es una técnica nueva (extension-reuse) interesante.

En febrero presentaron un artículo sobre la misma vulnerabilidad (CrossFire: An Analysis of Firefox Extension-Reuse Vulnerabilities) en el simposium “The Network and Distributed System Security Symposium 2016” organizado por la Internet Society.

Y siguiendo con los ataques de seguridad a las extensiones, hoy se publica una noticia sobre una empresa que en febrero compró una extensión bastante popular (Better History) para inyectarle código malicioso que hace que los navegadores de sus usuarios sean redirigidos, a través de un enlace, a páginas con banners -al parecer a la página que más pague a la empresa- cada vez que pinchan en un enlace (realmente el 50% de la veces y no es una redirección simple, sino que la página original a la que el usuario se dirigía también se abre). El comportamiento no es maligno únicamente por esto, sino porque la empresa de esta extensión está recogiendo datos privados sobre las URL que los usuarios visitan. Para más inri, el código fuente de Better History en GitHub no refleja los añadidos maliciosos que la compañía ha introducido.

Google ha eliminado la extensión de la Chrome Store, pero los usuarios han advertido de que este comportamiento se repite en otras extensiones populares como Chrome Currency Converter, Web Timer, User-Agent Switcher, Better History, 4chan Plus, and Hide My Adblocker.

Google ha eliminado también User-Agent Switcher, pero el resto sigue online.

25 de marzo de 2016

Instalando mod_wsgi en OSX El Capitan

Receta rápida:

$ git clone
$ cd mod_wsgi
$ ./configure
$ make
$ sudo make install
$ sudo vim /etc/apache2/httpd.conf

Añadir las siguientes dos líneas:

LoadModule wsgi_module libexec/apache2/
WSGIScriptAlias / /Library/WebServer/Documents/

Reiniciar Apache y comprobar:

$ sudo apachectl restart
$ apachectl -M | grep wsgi
 wsgi_module (shared)

Podemos probar con este Hello World ( Copiarlo en /Library/WebServer/Documents y abrirlo desde el navegador con http://localhost/ :

import os, sys
def application(environ, start_response):
    status = '200 OK'
    output = 'Hello world!!\n'
    response_headers = [('Content-type', 'text/plain'),
        ('Content-Length', str(len(output)))]
    start_response(status, response_headers)
    return [output]


22 de marzo de 2016

WebKitGTK+ 2.12

We did it again, the Igalia WebKit team is pleased to announce a new stable release of WebKitGTK+, with a bunch of bugs fixed, some new API bits and many other improvements. I’m going to talk here about some of the most important changes, but as usual you have more information in the NEWS file.


FTL JIT is a JavaScriptCore optimizing compiler that was developed using LLVM to do low-level optimizations. It’s been used by the Mac port since 2014 but we hadn’t been able to use it because it required some patches for LLVM to work on x86-64 that were not included in any official LLVM release, and there were also some crashes that only happened in Linux. At the beginning of this release cycle we already had LLVM 3.7 with all the required patches and the crashes had been fixed as well, so we finally enabled FTL for the GTK+ port. But in the middle of the release cycle Apple surprised us announcing that they had the new FTL B3 backend ready. B3 replaces LLVM and it’s entirely developed inside WebKit, so it doesn’t require any external dependency. JavaScriptCore developers quickly managed to make B3 work on Linux based ports and we decided to switch to B3 as soon as possible to avoid making a new release with LLVM to remove it in the next one. I’m not going to enter into the technical details of FTL and B3, because they are very well documented and it’s probably too boring for most of the people, the key point is that it improves the overall JavaScript performance in terms of speed.

Persistent GLib main loop sources

Another performance improvement introduced in WebKitGTK+ 2.12 has to do with main loop sources. WebKitGTK+ makes an extensive use the GLib main loop, it has its own RunLoop abstraction on top of GLib main loop that is used by all secondary processes and most of the secondary threads as well, scheduling main loop sources to send tasks between threads. JavaScript timers, animations, multimedia, the garbage collector, and many other features are based on scheduling main loop sources. In most of the cases we are actually scheduling the same callback all the time, but creating and destroying the GSource each time. We realized that creating and destroying main loop sources caused an overhead with an important impact in the performance. In WebKitGTK+ 2.12 all main loop sources were replaced by persistent sources, which are normal GSources that are never destroyed (unless they are not going to be scheduled anymore). We simply use the GSource ready time to make them active/inactive when we want to schedule/stop them.

Overlay scrollbars

GNOME designers have requested us to implement overlay scrollbars since they were introduced in GTK+, because WebKitGTK+ based applications didn’t look consistent with all other GTK+ applications. Since WebKit2, the web view is no longer a GtkScrollable, but it’s scrollable by itself using native scrollbars appearance or the one defined in the CSS. This means we have our own scrollbars implementation that we try to render as close as possible to the native ones, and that’s why it took us so long to find the time to implement overlay scrollbars. But WebKitGTK+ 2.12 finally implements them and are, of course, enabled by default. There’s no API to disable them, but we honor the GTK_OVERLAY_SCROLLING environment variable, so they can be disabled at runtime.

But the appearance was not the only thing that made our scrollbars inconsistent with the rest of the GTK+ applications, we also had a different behavior regarding the actions performed for mouse buttons, and some other bugs that are all fixed in 2.12.

The NetworkProcess is now mandatory

The network process was introduced in WebKitGTK+ since version 2.4 to be able to use multiple web processes. We had two different paths for loading resources depending on the process model being used. When using the shared secondary process model, resources were loaded by the web process directly, while when using the multiple web process model, the web processes sent the requests to the network process for being loaded. The maintenance of this two different paths was not easy, with some bugs happening only when using one model or the other, and also the network process gained features like the disk cache that were not available in the web process. In WebKitGTK+ 2.12 the non network process path has been removed, and the shared single process model has become the multiple web process model with a limit of 1. In practice it means that a single web process is still used, but the network happens in the network process.

NPAPI plugins in Wayland

I read it in many bug reports and mailing lists that NPAPI plugins will not be supported in wayland, so things like will not work. That’s not entirely true. NPAPI plugins can be windowed or windowless. Windowed plugins are those that use their own native window for rendering and handling events, implemented in X11 based systems using XEmbed protocol. Since Wayland doesn’t support XEmbed and doesn’t provide an alternative either, it’s true that windowed plugins will not be supported in Wayland. Windowless plugins don’t require any native window, they use the browser window for rendering and events are handled by the browser as well, using X11 drawable and X events in X11 based systems. So, it’s also true that windowless plugins having a UI will not be supported by Wayland either. However, not all windowless plugins have a UI, and there’s nothing X11 specific in the rest of the NPAPI plugins API, so there’s no reason why those can’t work in Wayland. And that’s exactly the case of, for example. In WebKitGTK+ 2.12 the X11 implementation of NPAPI plugins has been factored out, leaving the rest of the API implementation common and available to any window system used. That made it possible to support windowless NPAPI plugins with no UI in Wayland, and any other non X11 system, of course.


And as usual we have completed our API with some new additions:


07 de marzo de 2016

Transmission, torrents, OSX y malware KeRanger

Captura de pantalla 2016-03-07 a las 22.49.09 Cuando necesito descargar torrents, uso Transmission en Linux y uTorrent en OSX. No es que uTorrent esté libre de pecado (Spigot -PUP-,  EpicScale -mining de bitcoin no deseado, y demás basura), pero la semana pasada (4 de marzo) Transmission para OSX llevaba de regalo  KeRanger, ransomware. Sí, malware que cifra el contenido de tu disco duro y te pide un rescate – pagado en bitcoin, por supuesto- para obtener la clave que lo descifra. Parece ser el primer caso de ransomware dirigido específicamente a usuarios de OSX. Fue la gente de Palo Alto Networks fueron los primeros en dar el aviso, indicando que la web de Transmission había sido comprometida, dejando un fichero de instalación .dmg(la versión 2.90 de Transmission) infectado con KeRanger. Lo “bonito” del asunto es que esta versión de KeRanger había sido firmada con un certificado válido de desarrollador de aplicaciones para OSX, saltándose el control básico de Apple Gatekeeper que impide a un usuario básico instalar una aplicación que no venga firmada (se salta abriendo el binario con el menú contextual mientras pulsas Control, pero es una primera barrera de seguridad). Si el usuario instaló la versión infectada de Transmission, esta ejecutará una versión incrustada de KeRanger, esperará 3 días (suele ser habitual esperar a ejecutar el castigo, para ocultar al usuario el origen de la infección) y se comunicará con un servidor C&C (Command & Control) sobre la red Tor. A partir de ahí, cifrado del disco y petición de rescate (400 dólares).

Apple ha actuado rápido. Lo primero, invalidar el certificado con el que se firmó la aplicación en cuestión. Lo segundo, añadir una regla a XProtect, el sistema de lista negra que usa OSX por defecto. Puedes consultar los bichos que pululan por Internet en este fichero de tu OSX: /System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/XProtect.plist. ¿El primero de la lista? Nuestro amigo KeRanger:

Captura de pantalla 2016-03-07 a las 23.21.41

El análisis técnico del bicho en la página de Palo Alto Networks merece mucho la pena. Verás que el desarrollador está preparando funciones específicas para buscar y cifrar backups de Time Machine (qué angelito…). Verás también que usa tanto cifrado asimétrico (RSA) para cifrar un número elegido al azar junto a un IV dependiente del contenido del fichero, con lo que formará la clave que usará para cifrar el contenido del fichero usando cifrado simétrico (AES).

El 5 de marzo la gente de Transmission eliminó el ejecutable infectado de su web. Apple también ha hecho su trabajo. Pero el secuestro de webs para implantar malware parece que está de moda. Hace un par de semanas fue el turno de Linux Mint. Esta semana ha caído Transmission. ¿Quién será el siguiente?

Formateo y validación de objetos JSON

En esta ocasión, aprovechando que esta semana se estudia el formato JSON en una de mis clases, os quería recomendar un par de utilidades que utilizo a menudo: la herramienta jq y el plugin JSONView.

jq es una utilidad de la línea de comandos disponible para Linux, OS X y Windows que permite validar y visualizar de forma muy agradable objetos JSON. La mejor forma de apreciar el uso de jq es por medio de un ejemplo. En la siguiente figura, muestro un objeto JSON en la terminal sin usar jq. A continuación lo vuelvo a mostrar, esta vez filtrándolo con jq. Mucho mejor, ¿no?

Captura de pantalla 2016-03-07 a las 21.29.34


jq también detecta objetos JSON inválidos, marcando dónde se encuentra el error:

Captura de pantalla 2016-03-07 a las 22.00.40

JSONView es similar a jq, pero funciona como plugin o extensión, tanto de Google Chrome como de Mozilla Firefox. Veamos un ejemplo con el resultado de una llamada al API de OpenWeatherMap.

Sin usar JSONView:

Captura de pantalla 2016-03-07 a las 21.44.06

Con la extensión JSONView instalada:

Captura de pantalla 2016-03-07 a las 21.43.51

Sí, representan exactamente el mismo resultado. Pero uno es legible por humanos y el otro no 🙂

¿Conocíais estas utilidades? ¿Qué extensiones usáis en vuestros desarrollos? (HTML5, JS, PHP, whatever…)

05 de marzo de 2016

Demasiadas conexiones a MySQL desde R

Estoy desarrollando una nueva aplicación en R+Shiny. Entre otras cosas, el servidor Shiny necesita acceder a los datos de una BBDD en MySQL. Tengo código en R que accede a MySQL sin problemas, abre y cierra las conexiones bien, sin leaks  por dejar conexiones abiertas. Bueno, eso es lo que creía… cuando por alguna razón la aplicación fallaba, podían darse casos en los que alguna conexión se quedaba abierta. Por una o dos, no pasaba “nada”. Pero probando y probando, llegué a este error:

“cannot allocate a new connection — maximum of 16 connections  already opened”

Vaya… el primer problema es: ¿cómo desconecto las conexiones abiertas? La respuesta a esto en la lista de distribución de R:

cons <- dbListConnections(MySQL()) 
 for(con in cons) 

Y ahora, ¿cómo evitar el error? Lo ideal sería establecer una especie de conexión singleton que se reutilizara desde todo el código. La respuesta a esto, en StackOverflow (cómo no ;-))

getConnection <- function(group) {
  if (!exists('.connection', where=.GlobalEnv)) {
    .connection <<- dbConnect(MySQL(), group=group)
  } else if (class(try(dbGetQuery(.connection, "SELECT 1"))) == "try-error") {
    .connection <<- dbConnect(MySQL(), group=group)

Este código comprueba si existe una conexión en el entorno global. Si no existe, la crea y la devuelve.
Si existe, comprueba que se pueda usar. Si no se puede usar, desconecta y vuelve a crear la conexión, para devolverla.
Es decir, funciona como una caché (o puede verse también como un objeto singleton de tipo connection).
Podríamos ignorar el parámetro group de la función getConnection y en su lugar, usar:

dbConnect(MySQL(), user=login, password=pass, db=database, host=host)

allí donde fuera necesario.

Configuración de WordPress

Después de varios días por fin saco tiempo para continuar la entrada del otro día donde os comentaba las bondades de WordPress. Hoy voy a daros algunos consejos sobre como configurarlo:

1. Estructura Permalink

Lo primero que debes cambiar es la estructura de enlaces permanentes. Se encuentran en Configuración → Enlaces permanentes. El enlace permanente por defecto es <postid>, pero yo prefiero utilizar el nombre de la entrada:



2. ¿SSL o no SSL?

En 2014 Google anunció que las webs corriendo bajo https tendrían mejor valoración de cara al posicionamiento por este motivo muchas web han cambiado a SSL. Todo depende de nuestro presupuesto, los SSL cuestan $$$.

3. ¿WWW vs no-WWW?

Aquí es cuestión de gustos, si quieres que tu blog aparezca en el navegador como como o simplemente Asegúrate de que en Configuración → General, la versión que deseas aparece correctamente.

4. Optimiza las descripciones

Los webmaster suelen centrarse en los títulos pero nunca hay que dejar de lado las descripciones. La descripción muestra una parte de información muy importante en los resultados de búsqueda y podemos incluir en ella las palabras clave (keywords) que queremos resaltar.

5. Limpiar el código

Reduce al mínimo posible los Javascript y CSS que pueda tener tu plantilla. Google valora la rapidez de carga de tu web, de hecho hay un test específico para ello que mide tanto la versión normal como la móvil (responsive):

Test de velocidad de carga de Google

6. SEO y contenido duplicado

Debes huir siempre del contenido duplicado ya que es una de las cosas que más penalizan a la hora de posicionar tu blog. Google tiene avanzados algoritmos que analizan el texto (densidad keywords, frases, párrafos, incluso el conjunto!) para ver si son copiados de otros existentes.

7. Encabezamientos (headers)

Aunque cada vez tienen menor peso en el SEO aún sigue siendo una buena idea poner algunos textos con encabezamientos, por ejemplo el de mayor tamaño <h1> para el nombre de la entrada. Puedes poner también algún <h2> y <h3> para slogan o títulos secundarios.


02 de marzo de 2016

De a

Llevo mucho tiempo intentando escribir este post. Incluso creo que lo llegué a hacer, pero perdí el fichero donde lo guardaba. No recuerdo si lo hice en un documento de Google Drive, en Keep, en un fichero de texto plano, en un borrador de post, en un mensaje de correo a mí mismo… o si lo soñé, que también puede ser. El mero hecho de perderlo o de no saber a ciencia cierta si lo llegué a crear, me da que pensar. Vivimos una época en la que las conversaciones se llevan a cabo en redes sociales (Facebook, Twitter) y programas de mensajería instantánea (WhatsApp, Telegram). Todo es rápido, al momento, todo se consume de manera inmediata. No queda tiempo para sentarse a reflexionar y menos para escribir posts largos.

Antes no era así. Recuerdo una época en la que escribía largos mensajes varias veces a la semana. Eran posts con enjundia, donde compartía conocimiento práctico que había probado con calma. Eran posts sobre temas relacionados con Linux y el software libre. Era lo que me movía. Era un bonito “trabajo”, que me llevó de 2001 a 2014. En los últimos dos años (2014-2015) dejé de escribir en el blog. Sucumbí a las redes sociales. En especial, a Twitter. Sucumbí al software privativo, en especial al sistema OSX.

Abandoné DiarioLinux, pero no abandoné Linux. Sigo usándolo, pero no en el escritorio. Me cansé de pelear con drivers, configuraciones, aplicaciones y entornos. Quería seguir trabajando con un sistema Unix. Pero también quería las últimas aplicaciones. Y sucumbí a la manzana. Es curioso, esa historia de la manzana ya ocurrió hace miles de años 😉

La cuestión es que tengo ganas de tomarme las cosas con más calma. Y de escribir de forma más pausada y pensada de lo  que escribo en Twitter. ¿Quiere esto decir que dejaré de tuitear? No, seguiré haciéndolo, aunque probablemente bajando la frecuencia. Sigo creyendo que Twitter aporta mucha información de calidad (aparte de montañas de ruido). Gran parte de esta información la tengo marcada con un “favorito” (ahora, con un corazón, cursi, rojo). Hasta ahora, marcaba así los tuits en los que me interesaba profundizar. “Cuando tenga tiempo”. “Este enlace quiero leerlo con calma”. Autoengaños. Ahí siguen, marcados pero sin leer. Como los cientos de libros técnicos en formato digital que acumulo (casi 300, y subiendo) para leer algún día (será imposible hacerlo).

Así que toca simplificar. No preocuparse tanto por acumular, sino por soltar lastre. No preocuparse tanto por las novedades, sino por profundizar en alguna de ellas o en alguna de las que, en su día, fue novedad marcada como “favorita” e interesante, pero de la que nunca más supe. Eso es lo que pretendo hacer, pararme a inspeccionar con más detalle aquellos temas que piquen mi curiosidad. Temas técnicos en su mayor parte, pero también sobre docencia, idiomas, running, series, cine o libros. Como veis, temas que no estarán ceñidos sólo a Linux o al Software Libre. Temas, en general, sobre los que querría aprender más. De ahí el cierre de DiarioLinux y el comienzo de este nuevo blog, /Aprendiendo/.

Espero que estas reflexiones no se queden sólo en eso o que, al menos, pasen a formar parte de una buena colección de posts al respecto 🙂

PD: cerrará, pero no se perderá el contenido. Todos los posts, comentarios e imágenes adjuntas han sido copiadas a dentro del subdominio Por el momento, estará unos meses redirigiendo el tráfico (con cabeceras 301 Redirect). En 2017 cerrará definitivamente.

26 de febrero de 2016

Über latest Media Source Extensions improvements in WebKit with GStreamer

In this post I am going to talk about the implementation of the Media Source Extensions (known as MSE) in the WebKit ports that use GStreamer. These ports are WebKitGTK+, WebKitEFL and WebKitForWayland, though only the latter has the latest work-in-progress implementation. Of course we hope to upstream WebKitForWayland soon and with it, this backend for MSE and the one for EME.

My colleague Enrique at Igalia wrote a post about this about a week ago. I recommend you read it before continuing with mine to understand the general picture and the some of the issues that I managed to fix on that implementation. Come on, go and read it, I’ll wait.

One of the challenges here is something a bit unnatural in the GStreamer world. We have to process the stream information and then make some metadata available to the JavaScript app before playing instead of just pushing everything to a playing pipeline and being happy. For this we created the AppendPipeline, which processes the data and extracts that information and keeps it under control for the playback later.

The idea of the our AppendPipeline is to put a data stream into it and get it processed at the other side. It has an appsrc, a demuxer (qtdemux currently

) and an appsink to pick up the processed data. Something tricky of the spec is that when you append data into the SourceBuffer, that operation has to block it and prevent with errors any other append operation while the current is ongoing, and when it finishes, signal it. Our main issue with this is that the the appends can contain any amount of data from headers and buffers to only headers or just partial headers. Basically, the information can be partial.

First I’ll present again Enrique’s AppendPipeline internal state diagram:

First let me explain the easiest case, which is headers and buffers being appended. As soon as the process is triggered, we move from Not started to Ongoing, then as the headers are processed we get the pads at the demuxer and begin to receive buffers, which makes us move to Sampling. Then we have to detect that the operation has ended and move to Last sample and then again to Not started. If we have received only headers we will not move to Sampling cause we will not receive any buffers but we still have to detect this situation and be able to move to Data starve and then again to Not started.

Our first approach was using two different timeouts, one to detect that we should move from Ongoing to Data starve if we did not receive any buffer and another to move from Sampling to Last sample if we stopped receiving buffers. This solution worked but it was a bit racy and we tried to find a less error prone solution.

We tried then to use custom downstream events injected from the source and at the moment they were received at the sink we could move from Sampling to Last sample or if only headers were injected, the pads were created and we could move from Ongoing to Data starve. It took some time and several iterations to fine tune this but we managed to solve almost all cases but one, which was receiving only partial headers and no buffers.

If the demuxer received partial headers and no buffers it stalled and we were not receiving any pads or any event at the output so we could not tell when the append operation had ended. Tim-Philipp gave me the idea of using the need-data signal on the source that would be fired when the demuxer ran out of useful data. I realized then that the events were not needed anymore and that we could handle all with that signal.

The need-signal is fired sometimes when the pipeline is linked and also when the the demuxer finishes processing data, regardless the stream contains partial headers, complete headers or headers and buffers. It works perfectly once we are able to disregard that first signal we receive sometimes. To solve that we just ensure that at least one buffer left the appsrc with a pad probe so if we receive the signal before any buffer was detected at the probe, it shall be disregarded to consider that the append has finished. Otherwise, if we have seen already a buffer at the probe we can consider already than any need-data signal means that the processing has ended and we can tell the JavaScript app that the append process has ended.

Both need-data signal and probe information come in GStreamer internal threads so we could use mutexes to overcome any race conditions. We thought though that deferring the operations to the main thread through the pipeline bus was a better idea that would create less issues with race conditions or deadlocks.

To finish I prefer to give some good news about performance. We use mainly the YouTube conformance tests to ensure our implementation works and I can proudly say that these changes reduced the time of execution in half!

That’s all folks!

08 de febrero de 2016

WordPress SEO

Con la invención de Internet y el marketing digital el alcance de la optimización de motores de búsqueda (SEO) se ha convertido en uno de los métodos preferidos de promoción web. Por este motivo en la entrada de hoy quiero hablaros de como utilizar el software de blogs más conocido del mundo (WordPress) para mejorar el SEO de vuestras webs.

SEO, en términos generales se denomina como la optimización de motores de búsqueda. A diario millones de personas utilizan los buscadores para acceder a la información que necesitan. Aparecer en las primeras posiciones de las palabras clave (keywords) es imprescindible para el éxito de nuestro proyecto en Internet. Por este motivo la mayoría de los webmasters han optado por la promoción basada en SEO para poder llegar a su público objetivo.

Con el paso de los años (incluso meses) las técnicas de optimización en buscadores se actualizan por lo que hay que estar atentos y en constante evolución ante los cambios del algoritmo de Google.

Recientemente la empresa donde alojo ACS (podeis ver su banner al pie del blog) ha lanzado un VPS específico para el SEO basado en WordPress.

¿Y por qué han elegido WordPress?

WordPress es uno de los mejores sistemas de gestión de contenido cuando se trata de SEO, teniendo en cuenta que casi una cuarta parte de las webs de internet están hechas con este CMS tantos webmasters no han podido equivocarse!.

Ahora al grano, lo que proponen con este VPS SEO es poder levantar en pocos minutos hasta 4 hosting WordPress cada uno con una dirección IP clase C propia (IPs españolas).

WordPress es un software muy bien optimizado y permite que cada página sea indexada rapidamente por los buscadores, por este motivo es muy sencillo crear un blog, añadir buen contenido y enlazar a nuestras webs para mejorar sus rankings.

04 de febrero de 2016

Puente Johnson de noche

Puente Johnson Puente Johnson de noche. Victoria, British Columbia, Canadá.

01 de febrero de 2016

Web Engines Hackfest according to me

And once again, in December we celebrated the hackfest. This year happened between Dec 7-9 at the Igalia premises and the scope was much broader than WebKitGTK+, that’s why it was renamed as Web Engines Hackfest. We wanted to gather people working on all open source web engines and we succeeded as we had people working on WebKit, Chromium/Blink and Servo.

The edition before this I was working with Youenn Fablet (from Canon) on the Streams API implementation in WebKit and we spent our time on the same thing again. We have to say that things are much more mature now. During the hackfest we spent our time in fixing the JavaScriptCore built-ins inside WebCore and we advanced on the automatic importation of the specification web platform tests, which are based on our prior test implementation. Since now they are managed there, it does not make sense to maintain them inside WebKit too, we just import them. I must say that our implementation is fairly complete since we support the current version of the spec and have almost all tests passing, including ReadableStream, WritableStream and the built-in strategy classes. What is missing now is making Streams work together with other APIs, such as Media Source Extensions, Fetch or XMLHttpRequest.

There were some talks during the hackfest and we did not want to be less, so we had our own about Streams. You can enjoy it here:

You can see all hackfest talks in this YouTube playlist. The ones I liked most were the ones by Michael Catanzaro about HTTP security, which is always interesting given the current clumsy political movements against cryptography and the one by Dominik Röttsches about font rendering. It is really amazing what a browser has to do just to get some letters painted on the screen (and look good).

As usual, the environment was amazing and we had a great time, including the traditional Street Fighter‘s match, where Gustavo found a worthy challenger in Changseok 🙂

Of course, I would like to thank Collabora and Igalia for sponsoring the event!

And by the way, quite shortly after that, I became a WebKit reviewer!

19 de enero de 2016

Ruby On Rails

Según me han comentado Ruby es una especie de Perl simplificado con una buena orientación a objetos, algo como Python pero con una sintaxis más similar a la de Perl.

Supongo que lo primero será instalar en mi servidor Ruby On Rails que supongo que consistirá en el lenguaje de programación Ruby junto con un entorno de ejecución (librerías, ficheros de configuración, componentes …).

En Debian tenemos el paquete rails que diría tiene todo lo necesario: «Rails is a full-stack, open-source web framework in Ruby for writing real-world applications.». El paquete no parece estar disponible en Debian Sarge así que haremos un paquete desde la versión inestable de Debian (backport). Ha sido realmente sencillo: ruby y las librerías de Debian Sarge valen para rails. Sólo he tenido que instalar una versión más moderna de rake con respecto a la que viene en Debian Sarge (haciendo un backport) y tras ello, he podido hacer el paquete de rails para Debian Sarge.

Como me ocurre siempre, el vídeo en Totem no se ve. Utilicemos mplayer. El vídeo es un poco grande y ha sido grabado en un escritorio MacOS X. Para poderlo ver de forma cómoda voy a reproducirlo a pantalla completa en 1024×768.

acs@delito:~$ mplayer -fs

Será esencial la tecla de pausa para irlo siguiendo paso a paso. Las primeras impresiones es que al crearte una aplicación rails por defecto, se crean un montón de ficheros que serán la infraestrutura de la aplicación y que son los que nos ahorrarán el escribir mucho código. De momento no nos ha tocado tener que escribir Ruby, pero seguro que algo nos tocará ;-)

Para crear el esqueleto básico de una aplicación rails:

acs@macito:~/devel/rails$ rails testRails
      create  app/controllers
      create  app/helpers
acs@macito:~/devel/rails$ sloccount testRails/
WARNING! File /home/acs/devel/rails/testRails/script/plugin has unknown start: #!/usr/bin/env ruby
SLOC    Directory       SLOC-by-Language (Sorted)
36      config          ruby=36
7       test            ruby=7
4       app             ruby=4
4       public          ruby=4
Totals grouped by language (dominant language first):
ruby:            51 (100.00%)

Vemos que tampoco se generá mucho código Ruby de forma automática, algo que sin duda es bueno (aunque sloccount ha fallado al contar en varios directorios, pero tras mirar a mano, parecen sólo unas 30 líneas de Ruby).

Por defecto dentro de cada aplicación Rails existe el fichero “README” que cuenta lo básico sobre como poner en marcha la aplicación y una descripción de los contenidos. Y también se incluye un servidor de web que ejecuta la aplicación rails. Para iniciarlo basta con:

acs@macito:~/devel/rails$ testRails/script/server
=> Booting WEBrick...
=> Rails application started on
=> Ctrl-C to shutdown server; call with --help for options
[2006-02-20 05:41:51] INFO  WEBrick 1.3.1

En el puerto 3000 de la máquina donde estamos ejecutando el servidor tenemos ya el servidor de rails funcionando. Pero aún no hemos hecho nada así que no hay gran cosa aún en él, salvo documentación de más pasos en el camino. En general da la impresión de que está todo rails muy trabajado para llevar de la mano al desarrollador durante todo el proceso.

Los siguientes pasos siguiendo la página web por defecto son los de crear la base de datos, configurarla en nuestra aplicación rails y utilizar el programa “script/generate” para generar los modelos y controladores de los datos en la base de datos, justo el proceso que se sigue durante el vídeo.

17 de enero de 2016

¿Usas código de StackOverflow? Debes citar la fuente

Leí la noticia en Slashdot hace unos días.  La gente de StackExchange (SE, madre nodriza de otras tantas, donde destaca quería discutir con la comunidad un cambio en la licencia de uso de los trozos de código de esta web.  La cuestión es que la nueva licencia, que entraría en vigor el 1 de marzo de 2016, proponía que:

* Las aportaciones que no fueran de código y estuvieran disponibles en alguna de las webs de la red StackExchange seguirían gobernadas por los términos de la licencia CC-BY-SA

* Las aportaciones de código estarían gobernadas por los términos de la licencia MIT (sin necesidad de tener que incluir todos los términos de la licencia en tu proyecto, basta con atribuir el origen.

Realmente esto sólo cambia con respecto a la licencia anterior de la red SE en que antes la atribución era bajo petición del usuario creador de dicho código (poseedor del copyright de dicho código) o de SE en representación o en nombre de dicho usuario.

Se lió una buena discusión con estos términos. Hay cientos de comentarios al respecto, muchos de ellos en contra de esta decisión.

Llevo tiempo usando StackOverflow, tanto de forma profesional como programador, analista de datos, para mis clases de docencia e incluso como elemento de investigación. En mi faceta de programador, siempre que recojo algún trozo de código de SO intento incluir una referencia al post original a través de un comentario en el código. No sólo por cortesía, que también, sino sobre todo porque me interesa documentar las fuentes en las que me baso a la hora de programar. Si he tenido que acudir a SO a buscar esta solución, seguro que en el futuro alguien que lea mi código (yo mismo, probablemente) tendrá la misma duda y querrá saber más al respecto, o simplemente, ese trozo de código le puede parecer interesante y puede querer seguir profundizando en el tema. El enlace al post original en SO seguro que le/nos ayuda.

Con respecto a la docencia, atribuir el origen del código es lo mínimo que deberíamos hacer los profesores. Y predicar al alumnado con el ejemplo: al César lo que es del César, give credit where credit is due. Aprender a citar correctamente cuesta, y pequeños gestos como éste no cuestan nada y van formando al alumno.

En definitiva, yo estoy a favor de tener que citar la fuente de los trozos de código que obtengamos de la red SE. De hecho, como he indicado, es algo que nos beneficia a todos.

Sin embargo, la gran discusión suscitada ha hecho que la gente de SE haya decidido, a fecha de 15 de enero de 2016, aplazar la decisión.

30 de diciembre de 2015

Frogr 1.0 released

I’ve just released frogr 1.0. I can’t believe it took me 6 years to move from the 0.x series to the 1.0 release, but here it is finally. For good or bad.

Screenshot of frogr 1.0This release is again a small increment on top of the previous one that fixes a few bugs, should make the UI look a bit more consistent and “modern”, and includes some cleanups at the code level that I’ve been wanting to do for some time, like using G_DECLARE_FINAL_TYPE, which helped me get rid of ~1.7K LoC.

Last, I’ve created a few packages for Ubuntu in my PPA that you can use now already if you’re in Vivid or later while it does not get packaged by the distro itself, although I’d expect it to be eventually available via the usual means in different distros, hopefully soon. For extra information, just take a look to frogr’s website at

Now remember to take lots of pictures so that you can upload them with frogr 🙂

Happy new year!

28 de diciembre de 2015

Sonic Pi packaged for Fedora

Maybe you know about Sonic Pi, the system to learn programming playing with music. Now I want to give it a try in my system (Fedora 23) and my sysadmin-TOC syndrome obligues me first to package it into RPM. Now I have good and bad news. The good news are I have a testing release of Sonic Pi for Fedora 23. It includes a desktop file too. The bad news are... it doesn't work yet. Sonic Pi uses jackd while a common Fedora Workstation uses pulseaudio and both try to manage the sound device by themselves.

After a quick googling seems possible to get a procedure for using some working configuration for puleaudio+jackd but I didn't have the time to find and check them. Meanwhile, if the RPM package is useful for someone here it is.

This package depends of Supercollider as provided by Planet CCRMA package repository. To use this Sonic Pi maybe you'll want to add the repository to your system.

Please feedback here if you know how to make sound to work.

PD: Post edited to add references to Planet CCRMA repositorie.

27 de diciembre de 2015

Running EPF (Eclipse Process Framework) in Linux

For many time I wanted to learn to use EPF but technical reasons always stoped me. Blame me because I'm not an Eclipse guy and I'm not into its eclipse-isms but until today I have not been able to launch it. Now, wirth this really simple recipe you'll be able to run it.

Initial technical scenario:

Then unzip the file and execute:

$ unzip
$ cd epf-composer
[epf-composer]$ ./epf
Java HotSpot(TM) 64-Bit Server VM warning: You have loaded library /home/olea/epf-composer/plugins/org.eclipse.equinox.launcher.gtk.linux.x86_1.1.2.R36x_v20101019_1345/ which might have disabled stack guard. The VM will try to fix the stack guard now.
It's highly recommended that you fix the library with 'execstack -c <libfile>', or link it with '-z noexecstack'.
(Epf:27092): Gtk-WARNING **: Unable to locate theme engine in module_path: "adwaita",
(Epf:27092): Gtk-WARNING **: Unable to locate theme engine in module_path: "adwaita",
Gtk-Message: Failed to load module "pk-gtk-module"
Gtk-Message: Failed to load module "canberra-gtk-module"

If you, like me, don't know nothing about Eclipse maybe you are doomed because the real problem is everything but clear. What you are having is the EPF application asking for a 32 bits java VM runtime. Nothing more, nothing less. But now is very easy to fix:
  1. just get a 32 bits java VM
  2. adjust epf-composer/epf.ini to use it
In my case I've installed a Java 1.7 (in my case from the same Russian Fedora repo):

$ sudo dnf install
and then change ~/epf-composer/epf.ini from this:


to this:


Please note the precise path may be different in your system but in any case it should point to a 32 bit java binary.

Then you just need to launch EPF and you are ready:

$ epf-composer/epf

24 de diciembre de 2015


Ahora mismo queda ya bastante claro de la FAQ de OpenJDK, la comunidad formada por SUN para desarrollar las versiones libre de Java, que casi todo JDK 6 es ya software libre aunque quedan algunas partes que aún están pendientes.

Presentación del estado de OpenJDK en Fosdem 2008 que muestra las partes que aún no son libres de JDK y que coinciden con las que se mencionan en la FAQ:

Graphics rasterizer
Font rasterizer
Imaging APIs
Sound engine
Crypto providers
Some SNMP code

 Fully buildable != fully free
     25,169 source files
894 (4%) binary only (“plugs”)


Las partes que aún no son software libre quedan claras en la FAQ:

What are the encumbered components in the JDK (Java SE)?
The larger encumbered components requiring binary files for a full build include the font rasterizer, the graphics rasterizer, and the sound engine. Smaller components include some cryptographic algorithms, some SNMP code, and some of the imaging APIs.


y las presentaron el equipo de SUN dentro del FOSDEM en la sala de Free Java. Son las partes de JDK que están calificadas como “encumbered” y que tienen problemas para ser publicadas con licencia GPLv2.

Imaging APIs van a dejar de ser problema en breve (Marzo 2008).

Módulos que ya son software libre

Las partes de JDK (Java SM) que ya son software libre son:

In November 2006, Sun open sourced the Java programming language compiler ("javac"), and the Java HotSpot virtual machine. In addition, Sun open sourced the JavaHelp 2.0 extensible help system, Sun's reference implementation of JSR 97.

The following components are newly open sourced under GPL version 2 plus the Classpath Exception:

    * Core libraries
    * Networking libraries
    * Security libraries
    * Serviceability libraries
    * Internationalization libraries
    * 2D graphics subsystem
    * AWT, the Abstract Windowing Toolkit
    * Swing GUI toolkit
    * Sound subsystem
    * Various tools, including JConsole and javadoc

the exception of a few encumbered components that we hope, with the community's help, can be re-implemented so that 100% of the OpenJDK code commons is available as free software.


Guía del Desarrollador de OpenJDK

Guía para el que quiere ser desarrollador de OpenJDK

Comunidad OpenJDK 6 (objetivo similar a Iced Tea, OpenJDK 6 totalmente libre)

Construyendo OpenJDK desde las fuentes

Una de las actividades que quiero llevar a cabo es construir todo JDK desde las fuentes. Para ello lo mejor parece ser comenzar con NetBeans aunque intentaré hacerlo todo desde un terminal a la vieja usanza.

El IDE para Java

De momento tengo idea de seguir con mis terminales y vi/emacs para editar en Java. Pero quizá en el medio plazo acabe utilizando Eclipse, NetBeans o quien sabe, Monodevelop y su extensión para Java. El IDE comercial mejor considerado en Liferay es IntelliJ IDEA pero haré lo posible por huir de tecnologías privativas.

El proyecto Iced Tea

En Red Hat han lanzado el proyecto Iced Tea para «que el software OpenJDK publicado por Sun Microsystems como software libre en 2007 sea usable sin que sea necesario ningún otro software que no sea software libre». En SUN tiene un objetivo similar en OpenJDK así que no sé cuanto de sentido tiene este proyecto. Aunque siempre está bien que haya diversas comunidades con diversos intereses cuidando de la libertad de las cosas. En Iced Tea se puede ver bien las partes no libres que quedan en JDK (Java SE), como un 4%.

«IcedTea is not a fork, and is not meant to be a permanent project – just a stopgap measure to create a fully FOSS OpenJDK. »

Utilizando Javascript en Java

Con el motor de Javascript Rhino se pude integrar en desarrollos Java partes hechas en Javascript fácilmente. Javascript está en auge con la llegada de la Web 2.0 y futuras evoluciones, así que podría ser un lenguaje de scripting muy adecuado para los programas en Java.

Tecnologías Java

Dentro de las tecnologías Java que hay que manejar en Liferay tenemos Spring, Struts, Hibernate, Java Faces, jQeury o Velocity. A parte de profundizar en todas ellas me interesa a día de hoy explorar en profundidad el uso de genéricos en Java, un diseño que también se utiliza en C#.


Generics está disponible desde la versión Java SE 5.0. En C++ se conocen como “Templates” y la idea básica es definir tipos de datos, clases, que reciben como variables los tipos de datos con los que trabajan. En vez de tener contenedores genéricos de objetos (Object) en los que se puede meter cualquier tipo de clase pero que obliga a hacer un “casting” luego de sacar el objeto genérico a la clase que metismo, los genéricos permiten especificar que estamos creando una lista para guardar un determinado tipo de datos.

List myIntList = new LinkedList(); // 1
myIntList.add(new Integer(0)); // 2
Integer x = (Integer) myIntList.iterator().next(); // 3

pasa a ser

List<Integer> myIntList = new LinkedList<Integer>(); // 1’
myIntList.add(new Integer(0)); //2’
Integer x = myIntList.iterator().next(); // 3’


Máquinas virtuales en el servidor


Mi principal motivación a la hora de montar máquinas virtuales en mi servidor de casa es la de aprender a trabajar con los nuevos entornos virtuales, que aportan mayor seguridad (puedes dar por ejemplo clave de root en una máquina virtual de pruebas sin problemas), son más flexibles (puedes tener diferentes sistemas corriendo en el mismo hardware) y diría que hasta más sostenibles (menos hardware necesario). Además, es un campo de avance de la tecnología que abre posibilidades muy interesantes en sistemas distribuidos (migración de máquinas virtuales entre máquinas físicas, balanceo de carga, recuperación rápida ante fallos …).

En resumen, que son múltiples las ventajas de usar máquinas virtuales y merece la pena invertir un poco de esfuerzo en terminar de aprenderlas bien.

Nos referimos a máquinas virtuales a nivel de sistema que emulan por completo el hardware y permiten ejecutar sobre ellas sistemas operativos completos sin modificar, y no las máquinas virtuales de aplicaciones como por ejemplo Java.

Tecnologías de virtualización

No voy de momento a realizar un estudio de las diferentes alternativas que hay para la virtualización. De momento voy a tirar por Xen que es lo que ya conozco y una de las tecnologías libres más pujantes. A día de hoy ya hay otras opciones, tanto privativas como libres. Una de las que se oye hablar bastante últimamente es Virtual Box que en su versión básica es GPL.

Instalación de Xen en micro con soporte VT

Tras leer con detenimiento la información sobre máquinas virtuales en la Wikipedia, el objetivo es lograr explotar las capacidades que tienen los micros de Intel a nivel de hardware con la Virtualization Technology. Esta se puede explotar a partir de Xen 3.0 y permite correr diferentes sistemas operativos sobre el mismo hardware con un soporte más completo. Anterior a esto Xen era tecnología de paravirtualización, en la que se corrían diferentes sistemas operativos sobre el mismo hardware, pero con limitaciones. Con Xen 3.0 e Intel VT ya se puede correr por ejemplo Windows en Xen como sistema invitado. Como sistema hypervisor (virtual machine monitor) en nuestro caso usaremos una versión modificada de Linux, que será el domain0 en terminología Xen. Los sistemas invitados que corren sobre el hypervisor (dom0) se conocen como domain U (domU).

Por lo tanto, en mi portátil con soporte VT y Xen 3.0, podré tener como dom0 a Ubuntu y como uno de los domU a Windows, u otros Linux. En este sentido gracias a VT, Xen pasa a estar al nivel de emulación que VMWare. Anteriormente los domU sólo podían ser sistemas Linux y no sé si algún que otro Unix.

Nada mejor que utilizar la información de Xen del Wiki de Ubuntu. Aunque como suele pasar, está un poco anticuada (información para 8.04) y por ejemplo, no hace referencia a VT para nada. Pero sigamos lo que dice para tener nuestro sistema base corriendo como dom0 de Xen.

apt-get install ubuntu-xen-server
Se instalarán los siguientes paquetes NUEVOS:
  bridge-utils debootstrap libc6-xen libconfig-inifiles-perl libtext-template-perl libxen3 linux-image-2.6.24-19-xen linux-image-xen linux-restricted-modules-2.6.24-19-xen
  linux-restricted-modules-xen linux-ubuntu-modules-2.6.24-19-xen linux-xen python-dev python-xen-3.2 python2.5-dev ubuntu-xen-server xen-docs-3.2 xen-hypervisor-3.2 xen-tools

Con esto nos instala un nuevo núcleo (linux-image-2.6.24-19-xen) que incluye el hypervisor y que pasará a ser el dom0 de Xen. Se instala la versión Xen 3.2. Lo instalamos … y reiniciamos el sistema con este nuevo núcleo de Linux. Ya estamos dentro del dom0 de Xen. En realidad el dom0 debería de ser un sistema mínimo sobre el que correr los sistemas invitados, pero en mi caso de momento es todo el sistema completo com el escritorio GNOME y demás. Si veo que todo va muy bien, quizá piense en una reinstalación.

Después de reinicar el núcleo no funciona en el arranque dando un error que por suerte ya está estudiado en launchpad. El problema diría que es hald ya que lo da con el proceso hald-runner, que interactúa a bajo nivel con el hardware (hardware abstraction layer). He puesto un comentario y de momento no hay solución al bug. Y lleva ya varios meses. Diría que es la combinación con SMP, Xen y VT. De momento dejo un poco parado todo aquí :(

Montando todo sobre un Mac Mini

La idea de montar virtualización sobre un mac mini para utilizarlo como servidor ya ha ha sido cubierta en la red utilizando Xen. Vamos a partir de ella.

Como hacerlo bien

  • Instalar como dom0 un sistema mínimo con sólo ssh para poder acceder a él.

Puntos de trabajo

  • Virtualización software o completa con soporte del hardware (Xen 3.0 y extensiones del micro)

22 de diciembre de 2015



Bienvenido a este viaje apasionante por las entrañas de GNU/Linux. A lo largo de este artículo vas a aprender como funciona el corazón de GNU/Linux, y como has de configurarlo para que se adapte lo mejor posible a lo que tú quieres y necesitas, para obtener lo mejor de tú máquina.

Y todo lo haremos pensado que en estos momentos aún no eres ningún experto, por lo que te contaremos las cosas lo más claras posibles, guiandote para que en ningún momento te encuentres perdido. Y sabes que si en algún momento hay algo que te sorprende o no captas su significado, puedes acudir a las referencias que iremos citándote a lo largo de todo el artículo.

Ha llegado el momento de que busques un rato lipe, en el que no te molesten, y te lances a la lectura de este artículo que esperamos que te permita entender mejor lo que pasa en el interior de tú máquina

Seguro que si has comprado esta revista ya sapás que es GNU/Linux y posiblemente lo tendrás ya instalado en tú ordenador. Y si no es así quizás sea un buen momento para hacerlo, ya que será indispensable para que puedes comprender y seguir lo que te vamos a contar en este artículo.

Antes de que apareciera GNU/Linux no era tan común oir la palapa “kernel” (cuya traducción al español es núcleo). Al usuario final de la máquina se le daba el sistema operativo de tal forma que, la existencia de este componente muchas veces solo se reflejaba cuando se colgaba la máquina (el famoso fallo de protección general en kernel.dll). Era un elemento común a todos los usuarios y sólo se podía adaptar a cada tipo de hardware a través de los conocidos drivers (manejadores de dispositivos)

Con la llegada de GNU/Linux y su expansión (somos ya entre 8 y 9 millones de usuarios y subiendo a un ritmo anual superior al 20%) es común que se hable de este componente.

El kernel del sistema operativo es la parte fundamental del mismo ya que, se encarga de controlar todas las piezas de nuestra máquina, haciendo que dichas piezas formen un equipo que proporciona al usuario una máquina útil con la puede hacer muchas cosas diferentes: gestionar su negocio, navegar por todo el mundo a través de Internet, grabar sus maquetas de música, editar sus grabaciones de video …

Es el kernel el que se encarga de abstraer las comunicaciones con los dispositivos (la tarjeta de video o de sonido, la controladora del disco duro, la unidad ZIP enchufada al puerto paralelo …), la gestión de interrupciones, la coordinación para compartir los recursos entre diferentes aplicaciones que se ejecutan a la vez …

Esperamos que ya te hayas hecho una idea de la importancia del kernel y de su enorme complejidad, y posiblemente hapás podido llegar a una conclusión nada alejada de la realidad: “el kernel es el sistema operativo”.

El kernel es realmente lo que hace que tú maquina sea algo operativo y funcional, aunque ciertas compañías nos intenten hacer creer que los navegadores de Internet son también parte del sistema operativo.

Dejando a un lado esta discusión, la cual hoy por hoy no tiene ninguna conclusión clara y compartida por todo el mundo informático, vamos a continuar con nuestro viaje. Hapás podido observar pues que el kernel es lo que ha permitido a los desarrolladores software olvidarse del hardware en el que van a funcionar sus programas, al menos del 99% de dicho hardware, y centrarse en hacer aplicaciones cada día más complejas y potentes. Son este tipo de abstracciones las que permiten que las tecnologías avancen.

Rogamos al lector que piense por ejemplo en la abstracción de las comunicaciones que ha supuesto HTTP (el protocolo que se utiliza en el WWW) y el lenguaje HTML. Los desarrolladores se han podido olvidar, de nuevo en el 99% de los casos, de como se comunican los clientes y servidores. Esta abstracción ha llevado a una situación el la que es trivial desarrollar aplicaciones cliente/servidor, presentar información en Internet … y es esta sencillez la que ha permitido la explosión de Internet.

Por lo tanto podemos decir que: “el kernel permite al desarrolador olvidarse de como se gestionan los recursos hardware y centrarse en resolver los problemas que se presentan a su aplicación.”.

Y quizás haya llegado el momento de plantearse: ¿ cómo un software tan complejo y que require tanto trabajo ha podido ser desarrollado en el tiempo de lipe de programadores ?. Y quizás una pregunta que aún nos pueda sorprender más: ¿ cómo se ha logrado una calidad tan elevada que permite un funcionamiento del sistema durante años ?.

Las respuestas a estas preguntas son complejas y han llevado a ensayos de todo tipo, incluso socilógicos, sope este fenómeno. El lector interesado puede consultar las referencias sope dos documentos escritos por Eric S. Raymon que profundizan mucho sope las respuestas a estas preguntas: “La Catedral y el Bazar” (el método de desarrollo del software lipe) y “Homesteading the Noosphere (parcelando la Noospehere)” (las motivaciones de los desarrolladores de software lipe). Recomiendo fervientemente al lector ambas lecturas si es que quiere llegar a sentirse parte de esta comunidad tan utópica y fascinante, y quiere comprenderla.

Quizás sorprenda al lector que constantemente nos refiramos a lo que hasta ahora el conocia como Linux con la denominación GNU/Linux. Y en estos momentos ya sabe lo suficiente como para entender el motivo. Linux en realidad es solo el kernel de un conjunto software mucho más amplio.

Este kernel es lo que comenzó a desarrollar Linus Torvalds para aprender el modo protegido del microprocesador de Intel 386. Y fué este kernel lo que presentó en las noticias en Internet, retando a los programadores a que lo utilizarán y desarrollarán drivers para él. Y es este kernel lo que Linus Torvalds sigue manteniendo en la actualidad, con ayudas tam importantes como la de Alan Cox y una larga lista de colaboradores.

Todas las demás herramientas que rodean al kernel como son las diferentes shells (conchas: bash, ksh, csh …), editores como el vi o el emacs, los entornos de ventanas y las miles de utilidades que acompañan a un sistema Unix, no fueron desarrolladas por Linus y sus colaboradores y es más, la mayoría de ellas ya existían antes de que apareciera el kernel.

La mayor parte de estas herramientas fueran desarrolladas por la FSF (Free Software Foundation) dentro del proyecto GNU (GNU is not Unix), proyecto liderado por Richard Stallman.

Llegando más lejos, el kernel Linux será sustituido dentro del proyecto GNU por un kernel conocido por el nompe de Hurd, cuyo diseño es más avanzado tecnológicamente que el de Linux, y que ya se puede encontrar en distribuciones como Debian.

Vamos a buscar ahora el núcleo, y en particular sus fuentes, dentro de tú sistema.

El núcleo de Linux se suele instalar en el directorio /usr/src/linux. Dependiendo de que distribución de Linux tengas instalada lo tendrás allí o hapá que instalar algún paquete en el que estén dichas fuentes. Si lo tienes en ese directorio, o en alguno con el nompe kernel kernel-source-x.x.x pueden pasar al siguiente apartado.

En caso contrario intenta instalar un paquete que tenga un nombre del estilo kernel-source-x (en Debian se llama kernel-source-2.0.34).

Una última opción es conectarse por internet y bajar la última versión de algún ftp que este situado cerca de nosotros, por ejemplo en el espejo español de que está situado en

Al día de hoy (Marzo de 1999) puede ser esta la más recomendable ya que acaba de salir la versión 2.2 del núcleo y es muy recomendable obtener dicha versión.

Podemos conectarnos para ello a y de allí bajar linux-2.2.2.tar.gz (12804Kb). Con un poco de suerte dentro del cdrom que acompañará a este número de la revista estará incluido dicho núcleo. Así que te ahorrarás las 2 o 3 horas que puede costar bajarlo.

Una vez con el núcleo en tú poder lo mejor es que lo descomprimas dentro del directorio /usr/src (para ello tendrás que ser superusuario) utilizando el comando tar xvfz linux-2.2.2.tar.gz.

Descripción del kernel

Si has seguido con atención el anterior apartado dentro del directorio /usr/src/kernel-source-x.x.x estarán las fuentes del núcleo de Linux. Dentro de ese directorio encontrarás una estructura de directorios que reflejan los distintos cometidos que tiene que llevar a cabo el núcleo del sistema operativo, así como un directorio con abundante información sope el núcleo, sus diferentes partes, como compilarlo, como aplicarle parches … (mira dentro del directorio Documentation y encontrarás información muy detallada de muchos aspectos del núcleo).

Vamos a explicar a un nivel introductorio que es lo que hay dentro de los directorios más improtantes, sin descender en demasiados detalles que pudieran asustar a nuestros lectores.

Dentro de este directorio están las fuentes del núcleo que son necesarias adaptar a cada arquitectura en las que corre el núcleo.

Si entras aquí podrás ver los diferentes microprocesadores para los que está disponible el núcleo y dentro de cada directorio hay partes específicas de temas como la gestión de memoria, el arranque del sistema, la gestión de interrupciones … que son especifícos de cada arquitectura.

La idea es que sea solo este parte la que sea necesaria implementar para cada nueva arquitectura que se quiera incorporar, reutilizando la inmensa mayoría del código del núcleo.

Este directorio quizás sea más familiar para el lector. En el se encuentran las fuentes que se encargan implementar las comunicaciones son los distintos dispositivos del sistema: discos duros, cdroms, tarjetas de sonido, tarjetas de red, buses pci … Si por ejemplo nos metemos dentro del directorio sound, tenemos la mejor información de como funcionan las tripas de nuestra tarjeta de sonido: el código fuente en C que se encarga de controlarla.

Quizás sea bueno resaltar que la amplia mayoría de estos drivers no han sido hechos por el fapicante del hardware que controlan, si no por la comunidad de desarrolladores del núcleo que, a partir de la información del fapicante del hardware (cuando han podido disponer de ella y no han tenido que hacer ingeniería inversa) han implementado el controlador (driver) del dispositivo.

Hoy por hoy y gracias a la difusión que ha tenido Linux, fapicantes como Creative Labs ya están desarrollando sus propios drivers para Linux. Aunque aún hay casos como los de Toshiba que inicialmente se negaron a dar la información de como funcionaban sus puertos IrDA (infrarrojos), ante lo que se recomendó a la comunidad Linux no comprar sus portátiles. Poco más de una semana después Toshiba reconsideró su postura y decidió proporcionar dicha información. El poder que comienza a tener Linux es importante.

fs (file system)
Dentro de este directorio se encuentran las distintas implementaciones de los sistemas de ficheros que soporta Linux, entre ellos el propio de Linux (ext2) de MS-DOS (msdos), Windows 95 (vfat), … En la nueva versión 2.2.2 del núcleo también hay soporte para Windows NT.

Para que el lector se haga una idea, el que Linux soporte todos estos tipos de sistemas de ficheros significa que puede leer de ellos y escribir.

En este directorio se encuentra el código encargado de arrancar el sistema y realizar la configuración inicial de los diferentes sistemas del núcleo.

ipc (inter process communication)
Aquí podemos encontrar los diferentes mecanismos disponibles para comunicar los procesos que concurren concurrentemente en la máquina.

En este caso nos encontramos las implementaciones de muchas de las llamadas al núcleo (temporizadores, fork, …).

Mucho de este código es dependiente de la arquitectura en la que se ejecute el núcleo, por lo que parte de esta funcionalidad será específica de cada arquitectura y residirá en el directorio arch.

También reside aquí el algorítmo que se encarga de controlar que proceso debe ejecutarse en cada momento (planificador, sched.c)

Aquí reside código de utilidad general para otras partes del núcleo.

mm (memory management)
Este código se encarga de controlar la gestión de memoria del sistema, uno de los aspectos fundamentales dentro del sistema.

Entre sus funciones encontramos: reserva y liberación de memoria. paginación, gestión de memoria swap …

El núcleo de Linux soporta que partes que no hayan sido introducidas dentro del mismo a la hora de compilarlo, se puedan añadir a posteriori utilizando los módulos adecuados.

Esto permite tener un núcleo más reducido en el funcionamiento normal, y sólo incluir soporte para determinado harware en los momentos puntuales que lo necesitemos.

Otra utilidad de este sistema es para probar el funcionamiento de algún dispositivo (tarjeta de sonido o de red p.e.), del que podemos desconer la interrupción que utiliza, o si lleva un tipo de chip u otro. Gracias a los módulos podemos probar sin tener que recompilar el núcleo completo, algo que puede ser muy tedioso.

En este directorio es donde se almacenan los módulos que hayamos seleccionado en el proceso de compilación.

En este directorio se implementa todo lo que tenga relación con las comunicaciones entre diferentes máquinas. Por ello aquí está la implementación de protocolos como TCP/IP (v4 y v6), IPX, APPLETALK … o la implementación del uso de los sockets.

En este último directorio residen los programas que nos van a facilitar la configuración del núcleo, algo que vamos a analizar en el próximo apartado.

Configuración del núcleo

Si el lector ha llegado hasta aquí está a punto de recibir la recompensa a su paciencia. Vas a poder construir tú propio núcleo a partir de las fuentes que hemos descrito y de una forma sencilla, gracias a que al núcleo le acompañan unas utilidades que facilitan mucho su configuración.

Antes de configurar el núcleo hay que ejecutar “make mrproper” para limpiar posibles “restos” de configuraciones anteriores que pueden hacer que la generación no sea correcta.

Existen dos posibilidades básicas de configurar el núcleo: una desde un terminal utilizando el comando make menuconfig y otra desde el entorno de ventanas utilizando el comando make xconfig.

Solo en casos extremos podemos utilizar la opción make config, que nos hará ir paso por paso contestando a diferentes preguntas y como nos equivoquemos en uno de ellos … debemos volver a empezar. Un proceso horrible, os lo digo desde la experiencia.

En ambas interfaces, modo terminal y modo entorno de ventanas, la funcionalidad y modo de configuración es idéntica por lo que me voy a centrar el la opción de modo terminal, ya que si el sistema en el que se va a compilar el núcleo no tiene muchos recursos, el compilar el núcleo con el entorno de ventanas arrancado puede alargar mucho el proceso.

Ha llegado el momento de que te sientes delante del ordenador Linux y te dispongas a configurar tú kernel. Para ello adquiere la personalidad del superusuario (con el comando “su” por ejemplo) y vete al directorio /usr/src/kernel-source-x.x.x.

Una vez allí ejecuta el comando: make menuconfig.

Si todo va como debe (y el único incoveniente que podría surgir es que no tuvieras la lipería ncurses instalada en cuyo caso deberás instalarla y seguir el proceso) te aparecerá una pantalla con fondo azul y una ventana con fondo blanco con diferentes opciones. Como será una de las primeras veces que utilices este programa procura ir leyendo las instrucciones que aparecen, normalmente situadas en la parte superior de cada ventana.

Desde este programa vamos a poder ir entrando en diferentes menús que nos permitirán ir seleccionando que partes queremos meter en nuestro núcleo, en función del sistema con el que estemos trabajando.

No vamos a ir cupiendo de forma exhaustiva todas las posibles opciones pero si que vamos a detallar las principales, así como detallar en profundidad el funcionamiento de la interfaz de configuración.

La primera opción en la lista es “Code maturity level options”. El título de cada sección hace referencia a que parte del núcleo se configura dentro de ella. En este caso como su nompe indica, vamos a poder configurar si vamos a poder incluir en el núcleo partes que aún no son 100% estables. Pulsando la tecla “enter” entramos en dicha opción. En este caso sólo hay una opción, seleccionar o no seleccionar dicha opción. Para seleccionar/deseleccionar la opción utilizamos la barra de espacio. Podemos obtener ayuda sope cada una de las opciones seleccionando la opción de ayuda que está en la parte inferior de la ventana.

El sistema de ayuda que acompaña a la herramienta es muy completo por lo que ante la duda, es muy útil su consulta. Quizás en algunos momentos puede ser un tanto avanzado, pero al fin y al cabo estamos configurando el núcleo, y para ello hay que investigar, al menos las primeras veces.

Una vez que ya estemos de acuerdo con la selección de opciones, nos salimos del menú de selección y volvemos a la ventana principal, con todas las opciones del núcleo.

Si lugar a dudas lo más duro de configurar el núcleo son todas las opciones que están disponibles, por lo que las primeras veces es mejor entrar solo en aquellas en las que sepamos que vamos a hacer, aunque el núcleo que luego generemos no se adaptará totalmente a nuestro sistema y puede tener parte “inútiles” en nuestro sistema.

Continuando con la configuración, la siguiente opción es “Loadable module support” donde se puede activar la función del núcleo para el uso de módulos, tema que ya tratamos a la hora de describir el núcleo.

La siguiente opción “General setup” en la que se configuran opciones generales del núcleo, aplicables en todos los casos, por lo que siempre es bueno adaptarlas. Por ejemplo aquí seleccionaremos nuestro microprocesadores, si necesitamos que el coprocesador se emule por software (para los antiguos 286 y 386 SX), si queremos soporte para red …

El lector puede aprender mucho si profundiza en cada uno de los aspectos por lo que, debe vencer esa primera angustía por tantas opciones desconocidas, ya que en todo momento va a estar acompañado de una ayuda muy completa dentro de la herramienta de configuración, que incluso le dará punteros a documentos que podrán ampliar dicha información. En linux todo lo que se necesita para llegar a ser un “guru” es tiempo e ilusión.

En la opción “Floppy, IDE, and other block devices” nos hay que seleccionar mucho, tan sólo seleccionar el soporte para floppy y el soporte para IDE mejorado, que es se controlan nuestros discos duros (si no son scsi). También es habitual tener un CDROM IDE por lo que es bueno seleccionar esta opción.

Muchas veces las opciones que aparecen ya seleccionadas por defecto nos valen a nosotros, por lo que en estos casos la seleccion de opciones es sencilla.

La opción “Networking options” nos permite activar el soporte TCP/IP, algo que hoy en día es indispensable aunque nuestra máquina no este conectada a ninguna red, y también podemos configurar aspectos avanzados de dicho protocolo. En este caso es mejor no tocar nada si no sabemos lo que hacemos, ya que este es uno de los apartados más complejos, y hay que ser casi un experto en comunicaciones para utilizar algunas de las opciones.

La gestión de red que hace el núcleo de Linux de las comunicaciones es sin lugar a dudas uno de sus apartados más potentes. Permite controlar infinidad de cosas y es uno de los motivos que ha llevado a Linux a ser adapatado por una gran parte de los ISP (Internet Service Provider) de muchas partes del mundo.

“SCSI support” contiene las opciones para configurar el sistema SCSI. Dicho sistema suele estar dentro de una controladora a la que se pueden enchufar hasta sietes dispositivos, normalmente discos duros. Pero que te voy a contar, si tú máquina tiene soporte SCSI y tú lo pediste (con el consiguiente aumento de precio), sabes muy bien sus ventajas. Linux tiene soporte para SCSI desde sus inicios, por lo que en la actualidad es una de las partes más robustas del núcleo.

Por cierto, si tienes una unidad ZIP por el puerto paralelo, debes saber que esta para el sistema aparece como una unidad SCSI por lo que es aquí donde debes activar su soporte.

Dentro de “Network device support” debemos seleccionar como nos queremos conectar a las redes. Es aquí donde activaremos en nuestro núcleo el soporte PPP para conectarnos a Internet a través de nuestro proveedor, o el soporte para conectar ordenadores a través de los puerto serie o paralelo. Si tenemos una tarjeta de red también es aquí donde activaremos el controlador de la tarjeta dentro del núcleo.

En “ISDN subsystem” se configura el soporte para RDSI del núcleo. Decirte que este soporte ha avanzado mucho en los últimos núcleos de Linux, por lo que si tienes una tarjeta RDSI es muy recomendable que utilices la última versión del núcleo que ha ampliado mucho las tarjetas que están soportadas.

Si tienes un CDROM que no es IDE en la opción “CD-ROM drivers” quizás la encuentres y puedas trabajar con ella sin problemas, aunque es raro en los ordenadores nuevos ver este tipo de unidades de CDROM. Pero como Linux intenta soportar la más amplia gama de hardware, aquí tienes el soporte para esos casos extraños.

La opción “Filesystems” es una de las más interesantes. En ella se activan soportes como el de cuotas (limitar cuando espacio de disco puede ocupar cada usuario), o el de los diferentes sistemas de ficheros. A parte del soporte para “ext2”, el sistema de ficheros nativo de Linux, es recomendable que actives el de “fat”, “msdos” y “vfat” para poder ver las particiones Windows 3.x, 95 que a lo mejor viven en tú ordenador.

Verás una opción para dar soporte NLS (Native Language Support). Es importante que la actives ya que te permitirá montar los CDROM en formato Joliet que cada vez van a ser más usuales, y que dan soporte para el uso de UNICODE (permite utilizar en los nompes de ficheros caracteres de cualquier idioma).

Si estas instalando Linux en un Mac también querras activar el soporte para sus sistema de ficheros.

La opción “Character devices” es donde se configuran los puertos serie, el puerto paralelo, los ratones ps2 cada vez más usuales y en definitiva, todos los dispositivos que sus comunicaciones son de tipo caracter, es decir, que su unidad mínima de envío de datos es un caracter.

Si tienes alguna unidad de cinta para hacer copias de seguridad, es aquí donde deberás activar su soporte dentro del núcleo de Linux.

La penúltima opción es la de “Sound”. Como te podrás imaginar en ella se configura la tarjeta de sonido. El soporte para el sonido en Linux a mejorado mucho en los nuevos núcleos 2.2.x, por lo que te recomiendo que utilices dicho núcleo si quieres no tener muchos problemas a la hora de configurar dicho soporte.

La útima opción en nuestro camino de la configuración del núcleo es llama “Kernel hacking” y como te puede imaginar, el 99.9% de los usuarios se puede olvidar de su existencia, ya que no se suelen dedicar a desarrollar el núcleo. Bueno, tras este viaje a través de las diferentes opciones del núcleo, ha llegado el momento de salvar nuestra nueva configuración del núcleo, algo para lo que se nos solicitará confirmación tras seleccionar la opción de salir, y pasamos a compilar el núcleo que hemos configurado, proceso mucho más sencillo que su configuración.

Compilación e instalación

La compilación e instalación del núcleo tiene un conjunto de pasos que son siempre los mismos, y que haremos de forma mecánica una vez que los hayamos seguidos dos o tres veces.

Antes de configurar el núcle orecuerda que hay que ejecutar “make mrproper” para limpiar posibles “restos” (ficheros .o y dependencias) de compilaciones anteriores.

Con el núcleo configurado a nuestro gusto, ejecutamos dentro del directorio donde están las fuentes el comando: “make depend”.

Este comando actualiza las dependencias entre las diferentes partes, de forma que el orden de compilación sea correcto.

Con el comando “make zImage” es con el que se lanza la compilación. Ante él se pondrá el compilador gcc a compilar todas las partes del núcleo, un proceso que puede tardar desde varias horas (386 com 4 Mb de RAM) hasta 5 minutos (Pentium II o K6-2 con 32 Mb de RAM).

Una vez terminado este proceso tenemos ya la imagen de núcleo preparada para ser cargada y controlar el sistema. Dicha imagen se deja tras la compilación en el fichero “/usr/src/kernel-source-2.x.x/arch/i386/boot/zImage”, si la arquitectura es Intel.

Dicha imagen está comprimida por lo que verás que su tamaño es pequeño, entre 400 y 500 Kb si no has metido muchas opciones dentro del núcleo. Si el núcleo generado supera estas cantidades fallará la generación del nuevo núcleo. Debes utilizar make “bzImage” en esos casos.

Una vez generada la imagen se han de generar los módulos, aquellas partes de l núcleo que cargaremos cuando nos hagan falta. Para ello hay que ejecutar las ordenes: “make modules”, “make modules_install”.

Estas ordenes compilan los módulos y los dejan en el directorio adecuado para sus carga.

Para que nuestro ordenador utilice este nuevo núcleo, en el caso de utilizar LILO, debemos copiar la nueva imagen del núcleo al directorio donde guardemos los núcleos, normalmente la imagen del núcleo será /boot/zImage, y añadimos una nueva opción al fichero “/etc/lilo.conf” para que sepa como arrancar este nuevo núcleo. Tras ello ejecutamos “lilo” para que se actualice el arranque del ordenador y reincinamos el ordenador con “reboot”. Al arrancar, elegimos dentro del LILO el nuevo núcleo y con ello, nuestro GNU/Linux utilizará nuestro nuevo núcleo.

Una vez arrancado el sistema, si quieres insertar dentro del núcleo uno de los módulos que compilaste, basta con ejecutar “insmod ” y el núcleo ya podrá trabajar como si hubieras compilado soporte para ese módulo dentro del propio núcleo.

Evolución del núcleo

El núcleo de Linux está en constante evolución y hoy por hoy, no existe ningún otro sistema operativo que se adapte, actualice y corrige como Linux.

A finales de Enero de 1999 apareció la versión 2.2 del núcleo, un acontecimiento muy importante dentro de la comunidad Linux, y que lleva a Linux a soportar nuevas tecnologías como Video, USB …

Dentro del presente artículo no se ha tocado en profundidad todas las mejoras que introduce este nuevo núcleo, pero desde aquí os damos la URL a un excelente artículo en el que se describe este nuevo núcleo:


El núcleo de los sistema operativos constituyen la parte más compleja de los mismos, al tener controlar el uso de todos los recursos del sistema.

Linux poseé uno de los núcleos mejor desarrollados dentro de los sistemas operativos. Su eficiencia y robustez han logrado llevar a Linux a obtener una cuota importante dentro del mercado de los servidores, y a ser el sistema preferido dentro del mundo de los desarrolladores.

Su constante evolución y la rapidez con la que solucionan los problemas que se detectan están logrando que los sistemas Unix vuelvan a recuperar terreno frente al pujante Windows NT.

Su desarrollo abierto y la disponibilidad de las fuentes hacen que Linux sea el sistema ideal para aprender, por lo que su implantación dentro de las Universidades está siendo masiva.

Esperamos que este artículo te haya acercado un poco a este software y haya despertado tu interés de cara a profundizar más en su funcionamiento.


    “La catedral y el bazar” y “Homesteading the Noosphere”
    Pagina web de Linus Torvalds: http://www.cs.Helsinki.FI/~torvalds/
    Página web de Alan Cox:
    Página web de Eric S. Raymon:
    Free software Foundation:

26 de noviembre de 2015

Attending the Web Engines Hackfest

webkitgtk-hackfest-bannerIt’s certainly been a while since I attended this event for the last time, 2 years ago, when it was a WebKitGTK+ only oriented hackfest, so I guess it was a matter of time it happened again…

It will be different for me this time, though, as now my main focus won’t be on accessibility (yet I’m happy to help with that, too), but on fixing a few issues related to the WebKit2GTK+ API layer that I found while working on our platform (Endless OS), mostly related to its implementation of accelerated compositing.

Besides that, I’m particularly curious about seeing how the hackfest looks like now that it has broaden its scope to include other web engines, and I’m also quite happy to know that I’ll be visiting my home town and meeting my old colleagues and friends from Igalia for a few days, once again.

Endless Mobile logoLast, I’d like to thank my employer for sponsoring this trip, as well as Igalia for organizing this event, one more time.

See you in Coruña!

20 de noviembre de 2015

De visita en Madrid

Con la excusa de participar en el Taller de nanotecnología casera organizado por MediaLab Prado, de la última visita en Madrid me traigo entre otras varias cosas: 

  • conocer los trabajos de En-Te Hwu que han llevado a la creación de un microscopio de fuerza atómica de bajo coste y una alternativa OSS en desarrollo: OpenAFM;
  • descubrir el alucinante proyecto de microscopio de barrido láser opensource de Raquel López, del cual espero ansioso novedades de las versiones más avanzadas;
  • participar en la fundación del grupo de trabajo de Microscopía DIY creado en MediaLab Prado a consecuencia y por los participantes del taller impartido por En-Te;
  • visitar por primera vez a los amigos del Makespace en Madrid, que es otro punto de encuentro de potencial BESTIAL;
  • descubrir a la gente del BivosLab/Biocore, que están haciendo cosas que tal vez podamos aplicar también en el Club de Cacharreo;
  • el agradable reencuentro con los amigos de MediaLab Prado, de los cuales cada vez soy más admirador y que utilizo como inspiración para construir el HackLab Almería;
  • más equipos para la colección del museo de retroinformática (gracias Kix);
  • tratos con la realeza (sí, realmente estoy en esa foto, con mi camiseta celeste) ZOMG;
  • y hasta la petición de Jesús Cea de escribir mis experiencias «pastoreando los procomunes».

Un viaje preñado de... TODO.

10 de noviembre de 2015

Xuxen 5 instalatu eta hala ere LibreOfficek ez ditu zuzenketak egiten?

Xuxen 5 LibreOfficen instalatu duzu , argibideak jarraituz. Dena ondo dagoela dirudi, LibreOffice berrabiarazi duzu eta hala ere, euskaraz idatzitako testuetan zuzentzailea ez dabil?


Beno, ez zara bakarra! Arazoa nola konpondu daiteke? LibreOffice-n Basque Language Pack instalatu beharko duzu. Aukeratu Basque, instalatu pakete hori, berrabiarazi LibreOffice, eta orain bai, badabil 🙂



07 de noviembre de 2015

Importing include paths in Eclipse

First of all, let me be clear: no, I’m not trying to leave Emacs again, already got over that stage. Emacs is and will be my main editor for the foreseeable future, as it’s clear to me that there’s no other editor I feel more comfortable with, which is why I spent some time cleaning up my .emacs.d and making it more “manageable”.

But as much as like Emacs as my main “weapon”, I sometimes appreciate the advantages of using a different kind of beast for specific purposes. And, believe me or not, in the past 2 years I learned to love Eclipse/CDT as the best work-mate I know when I need some extra help to get deep inside of the two monster C++ projects that WebKit and Chromium are. And yes, I know Eclipse is resource hungry, slow, bloated… and whatnot; but I’m lucky enough to have fast SSDs and lots of RAM in my laptop & desktop machines, so that’s not really a big concern anymore for me (even though I reckon that indexing chromium in the laptop takes “quite some time”), so let’s move on 🙂

However, there’s this one little thing that still bothers quite me a lot of Eclipse: you need to manually setup the include paths for the external dependencies not in a standard location that a C/C++ project uses, so that you can get certain features properly working such as code auto-completion, automatic error-checking features, call hierarchies… and so forth.

And yes, I know there is an Eclipse plugin adding support for pkg-config which should do the job quite well. But for some reason I can’t get it to work with Eclipse Mars, even though others apparently can use it there for some reason (and I remember using it with Eclipse Juno, so it’s definitely not a myth).

Anyway, I did not feel like fighting with that (broken?) plugin, and in the other hand I was actually quite inclined to play a bit with Python so… my quick and dirty solution to get over this problem was to write a small script that takes a list of package names (as you would pass them to pkg-config) and generates the XML content that you can use to import in Eclipse. And surprisingly, that worked quite well for me, so I’m sharing it here in case someone else finds it useful.

Using frogr as an example, I generate the XML file for Eclipse doing this:

  $ pkg-config-to-eclipse glib-2.0 libsoup-2.4 libexif libxml-2.0 \
        json-glib-1.0 gtk+-3.0 gstreamer-1.0 > frogr-eclipse.xml

…and then I simply import frogr-eclipse.xml from the project’s properties, inside the C/C++ General > Paths and Symbols section.

After doing that I get rid of all the brokenness caused by so many missing symbols and header files, I get code auto-completion nicely working back again and all those perks you would expect from this little big IDE. And all that without having to go through the pain of defining all of them one by one from the settings dialog, thank goodness!

Now you can quickly see how it works in the video below:

VIDEO: Setting up a C/C++ project in Eclipse with pkg-config-to-eclipse

This has been very helpful for me, hope it will be helpful to someone else too!

17 de octubre de 2015

Sí, pienso seguir bloqueando anuncios (II)

Hace una semana que expliqué por qué sigo bloqueando anuncios. Pero siempre hay alguna vez que, sin querer, navegamos sin el bloqueo activado. Como me ha sucedido hace un momento al intentar consultar desde el móvil una noticia publicada en el, probablemente, diario más importante del Perú (El Comercio), que hizo que el navegador del móvil me mostrase este fraude:

Un intento de fraude capturado en El Comercio (Perú)

Segundos después, me apareció una página de la que es imposible salir sin cerrar el navegador:

La página de fraude de El Comercio (Perú) que impide continuar navegando

El resultado: cerrar el navegador y buscar la noticia en otro medio de comunicación. Adiós visita a El Comercio.

Este es uno de los muchos ejemplos que surgen diariamente: páginas que permiten publicidad fraudulenta que, además, nos impiden acceder a la información solicitada. La página es doblemente fraudulenta: no solo por mentir acerca de un supuesto virus en el móvil (y vender una app que seguramente nos lo infecte de verdad), sino además porque estaría contabilizando un hit en el anuncio, que no se ha producido voluntariamente por parte del usuario.

Al hilo de lo que comentaba el otro día: ¿qué pasará cuando anunciantes y demás afectados, vean todo el humo (y fraude) que hay detrás la publicidad on-line? Pues de momento ya se ha demostrado el fraude en algunos portales de vídeo on-line que cobran por visitas falsas.

Así que, gracias por seguir usando adblock, ublock o lo que se tercie.

09 de octubre de 2015

Sí, pienso seguir bloqueando anuncios

Empieza a ponerse de moda entre sitios web diversos, el anuncio para los que bloqueamos anuncios dejemos de hacerlo. Lo disfrazan con un gracias por no usar adblock plus con nosotros y ayuda a sostener este sitio y cosas por el estilo.


Y todo ello, al calor de la polémica sobre si adblock plus vende o no su lista blanca, que viene de largo, como si los expertos en publicidad animasen a reavivarla periódicamente.

Pero vamos a ver: lo primero de todo es que hace mucho tiempo que vengo usando ublock y ublock origin, alternativas independientes a adblock plus. Más que nada porque son técnicamente mejores y encima son software libre (github de ublock, github de ublock origin). Y si las listas blancas son mejor gestionadas, pues miel sobre hojuelas. Pero claro, no pueden o no son capaces de detectar que realmente no uso el susodicho plugin.


Lo segundo de todo, ¿verdaderamente esperan que dejemos de bloquear anuncios mientras a las plataformas más usadas le siguen colando anuncios con malware o simplemente muy molestos que te impiden acceder a la información que deseas ver? (especialmente desde los dispositivos móviles).

Y bueno, los anuncios en la web serán todo los efectivos que quieras. Eso dirán los publicistas. Pero me temo que en eso hay tanto humo, que el día que se den cuenta los anunciantes se va a producir una crisis peor que la de las punto-com y el ladrillo juntas… el fin del mundo, vamos.

04 de octubre de 2015

Los sueldos en el mundo de la informática

Sólo como referencia, he encontrado esta publicación del ministerio de trabajo de los EEUU: May 2014 National Occupational Employment and Wage Estimates con las estadísticas de sueldos de las profesiones informáticas en ese país:

Occupation code Occupation title (click on the occupation title to view its profile) Level Employment Employment RSE Employment per 1,000 jobs Median hourly wage Mean hourly wage Annual mean wage Mean wage RSE
11-3021 Computer and Information Systems Managers detail 330360 0.8% 2,445 $61.37 $65.52 $136,280 0.4%
15-0000 Computer and Mathematical Occupations major 3834180 0.5% 28,374 $38.18 $40.37 $83,970 0.5%
15-1100 Computer Occupations minor 3692980 0.5% 27,329 $38.17 $40.31 $83,840 0.5%
15-1111 Computer and Information Research Scientists detail 24210 4.2% 0,179 $52.09 $54.42 $113,190 1.4%
15-1120 Computer and Information Analysts broad 608500 0.9% 4,503 $40.13 $42.25 $87,890 0.3%
15-1121 Computer Systems Analysts detail 528320 0.9% 3,910 $39.76 $41.98 $87,320 0.4%
15-1122 Information Security Analysts detail 80180 2.0% 0,593 $42.74 $44.04 $91,600 0.6%
15-1130 Software Developers and Programmers broad 1492040 0.8% 11,042 $43.90 $45.81 $95,280 0.8%
15-1131 Computer Programmers detail 302150 1.4% 2,236 $37.28 $39.75 $82,690 1.3%
15-1132 Software Developers, Applications detail 686470 1.2% 5,080 $45.92 $47.85 $99,530 1.1%
15-1133 Software Developers, Systems Software detail 382400 1.6% 2,830 $49.46 $50.98 $106,050 0.6%
15-1134 Web Developers detail 121020 1.5% 0,896 $30.52 $33.02 $68,670 0.7%
15-1140 Database and Systems Administrators and Network Architects broad 617680 0.6% 4,571 $38.87 $40.85 $84,970 0.2%
15-1141 Database Administrators detail 112170 1.0% 0,830 $38.60 $39.56 $82,280 0.3%
15-1142 Network and Computer Systems Administrators detail 365430 0.8% 2,704 $36.44 $38.35 $79,770 0.3%
15-1143 Computer Network Architects detail 140080 1.4% 1,037 $47.32 $48.42 $100,710 0.4%
15-1150 Computer Support Specialists broad 738030 0.7% 5,462 $24.22 $26.42 $54,960 0.3%
15-1151 Computer User Support Specialists detail 563540 0.8% 4,170 $22.89 $24.76 $51,500 0.3%
15-1152 Computer Network Support Specialists detail 174490 1.3% 1,291 $29.72 $31.80 $66,140 0.5%
15-1199 Computer Occupations, All Other detail 212510 1.0% 1,573 $40.10 $41.12 $85,520 1.0%

Ojalá os sirvan.

23 de septiembre de 2015

WebKit Contributors Meeting 2015 (late, I know)

After writing my last post I realized that I needed to write a bit more about what I had been doing at the WebKit Contributors Meeting.

First thing to say is that it happened in March at Apple campus in Cupertino and I atteded as part of the Igalia gang.

My goal when I went there was to discuss with Youenn Fablet about Streams API and we are implementing and see how we could bootstrap the reviews and being to get the code reviewed and landed efficiently. Youenn and I also made a presentation (mainly him) about it. At that moment we got some comments and help from Benjamin Poulain and nowadays we are also working with Darin Adler and Geoffrey Garen so the work is ongoing.

WebRTC was also a hot topic and we talked a bit about how to deal with the promises as they seem to be involved in the WebRTC standard was well. My Igalian partner Philippe was missed in this regard as he is involved in the development of WebRTC in WebKit, but he unfortunately couldn’t make it because of personal reasons.

I also had an interesting talk with Jer Noble and Eric Carlson about Media Source and Encrypted Media Extensions. I told them about the several downstream implementations that we are or were working on, specially the WebKit4Wayland one and that we expect to begin to upstream soon. They commented that they still have doubts about the abstractions they made for them and of course I promised to get back to them when we begin with the job. Actually I already discussed some issues with Quique, another fellow Igalian.

Among the other interesting discussions, I found very necessary the migration of Mac port to CMake. Actually, I am experiencing now the painbenefits of using XCode to add files, specially the generated ones to the compilation. I hope that Alex succeeds with the task and soon we have a common build system for all main ports.

21 de septiembre de 2015

WebKitGTK+ 2.10

HTTP Disk Cache

WebKitGTK+ already had an HTTP disk cache implementation, simply using SoupCache, but Apple introduced a new cross-platform implementation to WebKit (just a few bits needed a platform specific implementation), so we decided to switch to it. This new cache has a lot of advantages over the SoupCache approach:

  • It’s fully integrated in the WebKit loading process, sharing some logic with the memory cache too.
  • It’s more efficient in terms of speed (the cache is in the NetworkProcess, but only the file descriptor is sent to the Web Process that mmaps the file) and disk usage (resource body and headers are stored in separate files in disk, using hard links for the body so that difference resources with the exactly same contents are only stored once).
  • It’s also more robust thanks to the lack of index. The synchronization between the index and the actual contents has always been a headache in SoupCache, with many resources leaked in disk, resources that are cache twice, etc.

The new disk cache is only used by the Network Process, so in case of using the shared secondary process model the SoupCache will still be used in the Web Process.

New inspector UI

The Web Inspector UI has been redesigned, you can see some of the differences in this screenshot:


For more details see this post in the Safari blog


This was one the few regressions we still had compared to WebKit1. When we switched to WebKit2 we lost IndexedDB support, but It’s now back in 2.10. It uses its own new process, the DatabaseProcess, to perform all database operations.


WebKitGTK+ 2.8 improved the overall performance thanks to the use of the bmalloc memory allocator. In 2.10 the overall performance has also improved, this time thanks to a new implementation of the locking primitives. All uses of mutex/condition have been replaced by a new implementation. You can see more details in the email Filip sent to webkit-dev or in the so detailed commit messages.

Screen Saver inhibitor

It’s more and more common to use the web browser to watch large videos in fullscreen mode, and quite annoying when the screen saver decides to “save” your screen every x minutes during the whole video. WebKitGTK+ 2.10 uses the ScreenSaver DBus service to inhibit the screen saver while a video is playing in fullscreen mode.

Font matching for strong aliases

WebKit’s font matching algorithm has improved, and now allows replacing fonts with metric-compatible equivalents. For example, sites that specify Arial will now get Liberation Sans, rather than your system’s default sans font (usually DejaVu). This makes text appear better on many pages, since some fonts require more space than others. The new algorithm is based on code from Skia that we expect will be used by Chrome in the future.

Improve image quality when using newer versions of cairo/pixman

The poor downscaling quality of cairo/pixman is a well known issue that was finally fixed in Cairo 1.14, however we were not taking advantage of it in WebKit even when using a recent enough version of cairo. The reason is that we were using CAIRO_FILTER_BILINEAR filter that was not affected by the cairo changes. So, we just switched to use CAIRO_FILTER_GOOD, that will use the BILINEAR filter in previous versions of Cairo (keeping the backwards compatibility), and a box filter for downscaling in newer versions. This drastically improves the image quality of downscaled images with a minim impact in performance.


Editor API

The lack of editor capabilities from the API point of view was blocking the migration to WebKit2 for some applications like Evolution. In 2.10 we have started to add the required API to ensure not only that the migration is possible for any application using a WebView in editable mode, but also that it will be more convenient to use.

So, for example, to monitor the state of the editor associated to a WebView, 2.10 provides a new class WebKitEditorState, that for now allows to monitor the typing attributestyping attributes. With WebKit1 you had to connect to the selection-changed signal and use the DOM bindings API to manually query the typing attributes. This is quite useful for updating the state of the editing buttons in the editor toolbar, for example. You just need to connect to WebKitEditorState::notify::typying-attributes and update the UI accordingly. For now typing attributes is the only thing you can monitor from the UI process API, but we will add more information when needed like the current cursor position, for example.

Having WebKitEditorState doesn’t mean we don’t need a selection-changed signal that we can monitor to query the DOM ourselves. But since in WebKit2 the DOM lives in the Web Process, the selection-changed signal has been added to the Web Extensions API. A new class WebKitWebEditor has been added, to represent the web editor associated to a WebKitWebPage, and can be obtained with webkit_web_page_get_editor(). And is this new class the one providing the selection-changed signal. So, you can connect to the signal and use the DOM API the same way it was done in WebKit1.

Some of the editor commands require an argument, like for example, the command to insert an image requires the image source URL. But both the WebKit1 and WebKit2 APIs only provided methods to run editor commands without any argument. This means that, once again, to implement something like insert-image or insert link, you had to use the DOM bindings to create and insert the new elements in the correct place. WebKitGTK+ 2.10 provides webkit_web_view_execute_editing_command_with_argument() to make this a lot more convenient.

You can test all this features using the new editor mode of MiniBrowser, simply run it with -e command line option and no arguments.


Website data

When browsing the web, websites are allowed to store data at the client side. It could be a cache, like the HTTP disk cache, or data required by web features like offline applications, local storage, IndexedDB, WebSQL, etc. All that data is currently stored in different directories and not all of those could be configured by the user. The new WebKitWebsiteDataManager class in 2.10 allows you to configure all those directories, either using a common base cache/data directory or providing a specific directory for every kind of data stored. It’s not mandatory to use it though, the default values are compatible with the ones previously used.

This gives the user more control over the browsing data stored in the client side, but in the future versions we plan to add support for actually handling the data, so that you will be able to query and delete the data stored by a particular security domain.

Web Processes limit

WebKitGTK+ currently supports two process models, the single shared secondary process and the multiple secondary processes. When using the latter, a new web process is created for every new web view. When there are a lot of web views created at the same time, the resources required to create all those processes could be too much in some systems. To improve that a bit 2.10 adds webkit_web_context_set_web_process_count_limit(), to set the maximum number of web process that can be created a the same time.

This new API can also be used to implement a slightly different version of the shared single process model. By using the multiple secondary process model with a limit of 1 web process, you still have a single shared web process, but using the multi-process mechanism, which means the network will happen in the Network Process, among other things. So, if you use the shared secondary process model in your application, unless your application only loads local resources, we recommend you to switch to multiple process model and use the limit to benefit from all the Network Process feature like the new disk cache, for example. Epiphany already does this for the secondary process model and web apps.

Missing media plugins installation permission request

When you try to play media, and the media backend doesn’t find the plugins/codecs required to play it, the missing plugin installation mechanism starts the package installer to allow the user to find and install the required plugins/codecs. This used to happen in the Web Process and without any way for the user to avoid it. WebKitGTK+ 2.10 provides a new WebKitPermissionRequest implementation that allows the user to block the request and prevent the installer from being invoked.

18 de septiembre de 2015

How after an upgrade my /etc/sysconfig/docker-storage got me mad

I have a running docker service in a Fedora 21 system for a while. Recently I got some disgusting erros preventing restart docker:

device-mapper: table: 253:7: thin: Couldn't open thin
internal device 

I am a docker newbie so I lost a lot of time thinking if my thin device got corrupt or whatever. Indeed I openened an issue (#16341) to the docker project to report it. But now I conclude is not an upstream error but a Fedora's packaging one.

The problem was caused in this regular update:

which did this:
+DOCKER_STORAGE_OPTIONS=--storage-driver devicemapper --storage-opt
-dm.fs=xfs --storage-opt dm.thinpooldev=/dev/mapper/vg_patxuko-docker--pool

And after the next system reboot the docker service was unable to restart. Removing the DOCKER_STORAGE_OPTIONS value returned system to service.

More details at this comment.

Hope it helps


24 de agosto de 2015

Bienvenida, Lucía Killari

Bienvenida, Lucía-Killari, a ese mundo que ahora te parecerá enorme. Ese mundo que tú te vas a comer.

Lucía Killari

23 de julio de 2015

ReadableStream almost ready

Hello dear readers! Long time no see! You might thing that I have been lazy, and I was in blog posting but I was coding like mad.

First remarkable thing is that I attended the WebKit Contributors Meeting that happened in March at Apple campus in Cupertino as part of the Igalia gang. There we discussed of course about Streams API, its state and different implementation possibilities. Another very interesting point which would make me very happy would be the movement of Mac to CMake.

In a previous post I already introduced the concepts of the Streams API and some of its possible use cases so I’ll save you that part now. The news is that ReadableStream has its basic funcionality complete. And what does it mean? It means that you can create a ReadableStream by providing the constructor with the underlying source and the strategy objects and read from it with its reader and all the internal mechanisms of backpresure and so on will work according to the spec. Yay!

Nevertheless, there’s still quite some work to do to complete the implementation of Streams API, like the implementation of byte streams, writable and transform streams, piping operations and built-in strategies (which is what I am on right now).I don’t know either when Streams API will be activated by default in the next builds of Safari, WebKitGTK+ or WebKit for Wayland, but we’ll make it at some point!

Code suffered already lots of changes because we were still figuring out which architecture was the best and Youenn did an awesome job in refactoring some things and providing support for promises in the bindings to make the implementation of ReadableStream more straitghforward and less “custom”.

Implementation could still suffer quite some important changes as, as part of my work implementing the strategies, some reviewers raised their concerns of having Streams API implemented inside WebCore in terms of IDL interfaces. I have already a proof of concept of CountQueuingStrategy and ByteLengthQueuingStrategy implemented inside JavaScriptCore, even a case where we use built-in JavaScript functions, which might help to keep closer to the spec if we can just include JavaScript code directly. We’ll see how we end up!

Last and not least I would like to thank Igalia for sponsoring me to attend the WebKit Contributors Meeting in Cupertino and also Adenilson for being so nice and taking us to very nice places for dinner and drinks that we wouldn’t be able to find ourselves (I owe you, promise to return the favor at the Web Engines Hackfest). It was also really nice to have the oportunity of quickly visiting New York City for some hours because of the long connection there which usually would be a PITA, but it was very enjoyable this time.

14 de julio de 2015

Cómo buscar stickers para Telegram

Telegram, ese chat que le da bastantes vueltas a Whatsapp y a Line (por ahí dejan caer que en el último ataque DDOS, pudo Line tener algo que ver…), reinventó el concepto de Sticker de forma bastante más abierta (o neutral) que sus competidores. Y sin embargo, viene con un pequeño defecto: no hay una página oficial para buscarlos.

Se han intentado mantener directorios más o menos actualizados, como este de Reddit. Sin embargo, la guía definitiva es: ¡usa tu buscador!

Por ejemplo, si en tu móvil (o tu equipo) buscas algo como meme te saldrán enlaces de (el sitio web donde se publican los stickers) que tienen la palabra clave “meme”:

Buscando stickers

Ya está. Solo queda pulsar en el que más te guste y lo verás en tu Telegram, listo para instalar. Sencillo, ¿no? Por cierto, que si tu buscador no es Google también te vale. Duckduckgo, cómo no.

Instalando stickers

07 de julio de 2015

Hacking Team: el cazador cazado

hackinteamSegún un informe de Reporteros sin Fronteras, Hacking Team es una empresa con base en Milán que vende herramientas software de intrusión y vigilancia a gobiernos y agencias de seguridad gubernamentales. Sus sistemas de control remoto permiten a los gobiernos monitorizar las comunicacones de los usuarios de Internet, descifrar sus ficheros y mensajes de correo cifrados, grabar conversaciones de Skype y otras comunicaciones de VoIP activar remotamente micrófonos y cámaras en los ordenadores bajo control.

No debemos creernos todo lo que se dice 😉 (eso de descifrar ficheros y mensajes cifrados no termina de cuadrarme), pero claramente, la empresa Hacking Team no era precisamente una empresa bien vista en los círculos de seguridad informática. Entre otras cosas ha sido criticada varias veces por vender sus servicios a gobiernos bajo sospecha de violación de derechos humanos (Sudán).

Hace un par de días (el 5 de julio), Hacking Team fue hackeada (el cazador cazado). Su cuenta en Twitter fue secuestrada y se publicó un torrent con unos 400GB de datos (incluyendo emails, facturas, código fuente de los exploits y herramientas usadas…).

Uno de los exploits era un 0day para Flash, aunque entre las herramientas se encuentran también herramientas para monitorizar Windows Phone, exploits para Win32, Android, etc.

Curiosamente, ayer mismo alguien clonó los repos git (tras extraerlos del torrent de 400GB) en GitHub,, pero hoy – como siempre ocurre en estos casos – ya no está disponible. Sin embargo, Internet se mueve a un ritmo endiablado, y hubo gente que no sólo hizo un mirror de los repos Git, sino de todo el material publicado en el torrent

La cuenta Twitter de Christian Pozzi (, uno de los miembros del Hacking Team, indicó ayer que el material contenido en el torrent contenía un virus e información falsa. Poco tiempo después, la cuenta de Pozzi fue (tras ser supuestamente crackeada, yo no lo llegué a ver) cerrada.

También Anonymous (@YourAnonGlobal) hace su trabajo, y ya ha detectado, dentro del módulo RCS (Remote Control System, el módulo principal de la empresa Hacking Team) código que parece implantar “evidencias” ilegales en el ordenador bajo control.

La cuenta Twitter de la Confederación de Partidos Pirata (@partidos_pirata) informa sobre una hoja de cálculo dentro de los archivos del torrent donde se pueden ver supuestos clientes de la empresa: Policía Nacional y CNI (ES) entre ellos.

Al Hacking Team, lógicamente, no le gustaba el proyecto Tor. Desde allí le dedican un mensaje.

03 de julio de 2015

On Linux32 chrooted environments

I have a chrooted environment in my 64bit Fedora 22 machine that I use every now and then to work on a debian-like 32bit system where I might want to do all sorts of things, such as building software for the target system or creating debian packages. More specifically, today I was trying to build WebKitGTK+ 2.8.3 in there and something weird was happening:

The following CMake snippet was not properly recognizing my 32bit chroot:

endif ()

After some investigation, I found out that CMAKE_HOST_SYSTEM_PROCESSOR relies on the output of uname to determine the type of the CPU, and this what I was getting if I ran it myself:

(debian32-chroot)mario:~ $ uname -a
Linux moucho 4.0.6-300.fc22.x86_64 #1 SMP Tue Jun 23 13:58:53 UTC 2015
x86_64 x86_64 x86_64 GNU/Linux

Let’s avoid nasty comments about the stupid name of my machine (I’m sure everyone else uses clever names instead), and see what was there: x86_64.

That looked wrong to me, so I googled a bit to see what others did about this and, besides finding all sorts of crazy hacks around, I found that in my case the solution was pretty simple just because I am using schroot, a great tool that makes life easier when working with chrooted environments.

Because of that, all I would have to do would be to specify personality=linux32 in the configuration file for my chrooted environment and that’s it. Just by doing that and re-entering in the “jail”, the output would be much saner now:

(debian32-chroot)mario:~ $ uname -a
Linux moucho 4.0.6-300.fc22.x86_64 #1 SMP Tue Jun 23 13:58:53 UTC 2015
i686 i686 i686 GNU/Linux

And of course, WebKitGTK+ would now recognize and use the right CPU type in the snippet above and I could “relax” again while seeing WebKit building again.

Now, for extra reference, this is the content of my schroot configuration file:

$ cat /etc/schroot/chroot.d/00debian32-chroot
description=Debian-like chroot (32 bit) 

That is all, hope somebody else will find this useful. It certainly saved my day!

17 de junio de 2015

¡Enhorabuena, wikipedistas!

09 de junio de 2015

Apple licenciará como software libre uno de sus productos

Ayer Apple anunció en uno de sus habitualmente pomposos eventos, que la próxima versión del lenguaje de programación Swift será open source.


La amplia comunidad de fanboys por un lado, y la de haters por otro, se lanzaron en masa a comentarlo. La verdad, si me enteré de la noticia fue porque open source llegó a ser tendencia en Twitter y, lo que más me sorprendió, que fuera por noticias relacionadas con Apple.

Las opiniones, para todos los gustos, muchas denotando gran entusiasmo (como suele pasar con cualquier anuncio de Apple) y algunas curiosas como esta de @phobophille:

Con Apple anunciando que Swift será Open Source es pertinente recordar que Open Source no significa necesariamente Software Libre #ojoCuidao

Veamos: Lo que Apple ha anunciado concretamente es que la versión 2.0 de Swift se liberará (esta vez sí, se libera) con una licencia permisiva aprobada por la OSI. ¿Qué significa esto? En primer lugar, significa que cumple la definición de Open Source disponible aquí. Esto es importante. Como lo es el hecho de que elijan una licencia permisiva, es decir, que permite cerrar el código fuente de los trabajos derivados. Esto es lo que la diferencia de las licencias de software libre copyleft, como la GPL. Y Apple, como tantas otras compañías, elige este modelo permisivo.

Pero también hay grandes proyectos de las comunidades que eligen licencias permisivas. Por ejemplo, FreeBSD o Apache. ¿Alguien duda de que son software libre? Pues lo son. Pero tampoco tienen licencia copyleft. Así que, pese a quien pese, Swift 2.0 sí, se libera y será software libre (mientras Apple no cambie de opinión).

¿Es la primera vez que Apple hace software libre? Pues tampoco. De hecho, Apple cuenta desde hace tiempo con una licencia permisiva, aprobada en OSI y considerada como de software libre: la Apple Public Source License. Esta licencia es la utilizada por Apple para liberar, por ejemplo, partes de su sistema operativo OSX.

Otra cosa es, cuántas veces más Apple decidirá liberar código con una licencia OSI. En esta ocasión, a Apple le conviene liberar, quizás para conseguir que más desarrolladores adopten este nuevo lenguaje de programación. Para que la gente use otros productos de software de Apple, como iOS, solo necesitan venderles un iPhone. Pero para que los desarrolladores adopten masivamente un nuevo lenguaje de programación, necesitan todo tipo de mimos. Recordemos también, que hay otras compañías que publican de vez en cuando software libre, sin que por ello estén muy comprometidas con la comunidad, que digamos.

27 de mayo de 2015

Google Calendar dejará de enviar SMS

De acuerdo a un correo que estamos recibiendo, Google Calendar dejará de enviar notificaciones por SMS. La justificación es que la mayoría de los usuarios tiene smartphones con aplicación de calendario, capaces de notificar a su usuario de forma más flexible.

Fin de SMS en Calendar

Quizás dentro de unos años eliminen los SMS en otros tipos de notificaciones. Por ejemplo, en la doble autenticación, obligando a utilizar la app Google Authenticator. Yo, personalmente, vengo usando estas notificaciones del calendario desde el principio y aunque poca falta me hacen ya, no las desactivé por dejadez.

Pero, ¿se muere el SMS? Pues no sé yo: por un lado, los 140 caracteres del SMS representan, desde siempre, los paquetes de datos más caros del mundo. Por otro lado, las operadoras y ciertos clientes con pocos escrúpulos tienen un buen negocio montado con los SMS premium. Tal vez, pronto queden relegados a este tipo de usos y a sus usuarios incautos.