01.29.12

Zonas horarias, DST, Desplazamientos y otras zarandajas

[ Ir a la parte 1 de 2: “Sobre la Hora Universal y los relojes atómicos (o qué tienen en común el TomTom y unos trigales)” ]

Continuamos desentrañando el misterio de las horas, orientando la explicación principalmente a programadores.

Hemos establecido qué sistemas de medición de la hora existen. También hemos visto que el estandard de facto es UTC, y por buenas razones.

Y ahora vamos a ver como se pueden representar esas horas en una aplicación.

A efectos prácticos, en este artículo voy a llamar “hora” al conjunto de “fecha+hora“.

 

Conceptos básicos

Repaso de UTC

Quedabamos en que UTC es una hora universal, que trata de indicar la hora del planeta Tierra en general. No está ligado a ningún país en concreto, ni a ningún continente, sino al planeta entero: España no tiene horas UTC. Argentina no tiene horas UTC. El planeta Tierra sí que tiene horas UTC.

Si en una hora UTC particular es pleno día en España, entonces en esa misma hora UTC será noche cerrada en sus antípodas; y será el amanecer o el anochecer si nos quedamos a medio camino entre ambos puntos.

UTC no sufre saltos [*], sino que avanza siempre a una velocidad constante. Porque el planeta Tierra tampoco sufre saltos ni rotaciones bruscas en ningún momento (menos mal :-D).
[*] Técnicamente sí (tiene saltos por debajo del segundo), pero se puede ignorar perfectamente para este artículo.

 

Hora Local (Local Time)

Los habitantes de este planeta estamos acostumbrados a hablar en términos locales. Yo, como habitante de Madrid, puedo decir “Me levanto a trabajar a las 07:00”. Un japonés, a su vez, puede decir “Yo también me levanto a trabajar a las 07:00”. Pero obviamente no hablamos de la misma hora UTC, sino de una hora “local”.

Trabajar con horas locales puede ser complicado, por ejemplo cuando el locutor se desplaza de sitio. Si despegas de Madrid a las 10:00 (hora local madrileña), vuelas 10 horas, y aterrizas en Miami, la hora local de Miami no serán las 20:00, sino otra, que hay que calcular en base a unos cuantos factores.

En cambio, si despegas a las 10:00 UTC, sí que aterrizas a las 20:00 UTC.

Desplazamiento (Offset)

El offset es, literalmente, la siguiente resta matemática: hora local – hora UTC.

Por ejemplo: La hora local actual en Madrid es finales de Enero a las 20:00. La hora UTC actual en el planeta es finales de Enero a las 19:00 UTC. Por tanto, 20:00 – 19:00 = 01:00 de offset.

Inciso sobre el Horario de Verano:

El Horario de Verano, como sabeis, tiene como objetivo reducir el consumo eléctrico, tener más luz durante las horas laborales, etc (al margen de que se consigan o no dichos propósitos :-P).

Consiste en mover las manecillas de los relojes locales de un país, para atrasar o adelantar la hora local durante unos meses determinados, cada año.

• Lo típico es atrasar o adelantarlo 1h, pero en algunos paises es 30 minutos.
• Cada país lo puede aplicar durante unos meses diferentes: de marzo a octubre, de abril a septiembre… Los días exactos también pueden variar.
• En muchos países ni siquiera se aplica el Horario de Verano.

En cualquier caso, el offset ya lleva incluído el horario de verano cuando se usa, puesto que el offset se obtiene restando la hora local (que ya lleva aplicado el cambio horario) y la hora UTC.

Otro ejemplo: En Agosto de este año se habrá aplicado el horario de verano en Madrid, por lo que el offset no será 01:00h sino 02:00h.

El offset de una localización geográfica puede variar tanto a lo largo de un mismo año, como hemos visto, pero también a lo largo de varios años. Por ejemplo:

• Antes del 1901, cada provincia española tenía su propia hora local, en base a su meridiano concreto. Ahora ya no.
• En el 1918, en España se decide empezar a aplicar el horario de verano, que nunca antes se había utilizado. El offset ya no es el mismo todo el año, sino que aumenta 1h en verano (como en el presente).
• El 16 de Marzo de 1940, España decide incrementar todos sus relojes en una hora: el offset pasa de 0h a 1h en invierno, y de 1h a 2h en verano. (se ha cambiado la zona horaria, que explico más abajo)
• Si varios paises con diferentes horas locales eliminan sus fronteras políticas para unirse en un solo país, seguramente modifiquen sus horas locales para coincidir en todo el territorio (variando por tanto el offset).

Por tanto, es perfectamente posible que dos países tengan el mismo offset durante algunos meses del año, pero difieran durante otros.

Dicho de otra forma: a partir de un offset, no se puede deducir en qué localización te encuentras, ni por tanto qué otros offsets existirán en otros momentos del año.

Por ejemplo: Si no sabes si tu +01:00h actual es de Madrid o del Congo, no puedes saber si en Agosto será un +02:00h (caso de Madrid), o se mantendrá en +01:00h (caso de Congo, sin horario de verano).

 

Zona horaria (Time Zone, o TZ)

Se dice que varias poblaciones están en una misma Zona Horaria, cuando desde el año 1970 han compartido siempre la misma hora local. La nomenclatura es “Area/Localización”.

No hay que confundir con los husos horarios, meridianos ni offsets. Son conceptos diferentes: “UTC+02:00” no es realmente una Zona Horaria, es un Offset respecto de UTC.

Por ejemplo: En España, desde el 1970 hasta ahora, han existido tres regiones que no siempre han compartido completamente las horas locales en todo momento. Las tres zonas horarias (o TZs) son:

• Europe/Madrid: para la península y baleares principalmente.
• Atlantic/Canary: para el archipiélago canario.
• Africa/Ceuta: para Ceuta y Melilla.

Actualmente, esas 3 timezones usan horario de verano, por lo que actualmente sus offsets respectivos de invierno son 1h, 0h y 1h; y los de verano 2h, 1h y 2h.

Cada TZ ha tenido un pasado diferente: algunos aplicaron el horario de verano durante 20 años, otros no lo aplicaron; unos tenian un offset de 5h, otros de 10h, etc.

Toda esa información se almacena en lo que se llama tz database (en castellano, base de datos de zonas horarias).

La tz database debe ser actualizada constantemente, reflejando los cambios horarios que se pueden producir a lo largo de los años.

 

Empieza el meollo de la cuestión

Una vez que conocemos los conceptos básicos, podemos pasar a la acción:

¿En qué me influye todo eso a la hora de diseñar mi software?

¿Cómo gestiono las horas correctamente?
¿Y si mi usuario vuela de España a la India y cambia el reloj de su portatil?
¿Y si mi usuario quiere introducir la hora local de despegue y la hora local de aterrizaje en mi software de calendario?
¿Y si mi software tiene varios usuarios simultáneos en diferentes zonas del mundo?

Una política habitual en el mundo de la programación es:

“Almacena y procesa globlamente, muestra localmente“.

Dicho de otra forma: elige un formato neutro para almacenar y operar sobre los datos, y preocúpate de las particularidades culturales cuando debas mostrar o recoger los datos de un usuario final.

Recordemos que en este post se usa la palabra “hora” como abreviación de “fecha+hora“.

 

“Almacena y procesa globalmente”

Empecemos con un ejemplo sencillote:

Tenemos una variable tipo entero, cuyo valor es 7 millones.

• El ordenador almacena y opera globalmente. Concretamente, usa el binario: 00000000011010101100111111000000.
• En cambio al mostrarlo en una hoja de cálculo, nos puede mostrar “7.000.000“, o bien “7,000,000“, o tal vez “7e6“, o incluso “######“, según el contexto local (dónde vivimos, tamaño de la celda, formato del número…).

Tenemos una Hora Local, las 15:00 de un día de Enero. Se le quiere sumar casi medio año (24h*180días=4320h) a esa hora. ¿Cuál será la Hora Local resultante?:

1. Las 15:00 hora local, como en la hora de partida.
2. Las 16:00 hora local, porque hay que aplicar el Horario de Verano.
3. Ninguna de las 2 anteriores.
4. Cualquiera de las 3 anteriores.

Y la solución es 4) Cualquiera de las tres anteriores, puesto que depende de la zona horaria:

• En el Moscú actual o el Madrid del año 1910, no hay horario de verano, luego sería 1) Las 15:00.
• En el Madrid actual hay horario de verano, luego sería 2) Las 16:00.
• En la Isla de Lord Howe hay horario de verano de 30m, en vez de la hora típica, luego sería 3) Las 15:30.

Queda claro entonces que la única forma de operar correctamente con horas es pasarlas a UTC, operar sobre ellas y finalmente (si hace falta), convertirlas a la Hora Local de nuestra elección para mostrárselo al usuario final.

 

“Muestra localmente”

Hemos establecido que, para la interfaz con el usuario final, necesitamos conversiones de UTC a Hora Local (al renderizar en pantalla) y viceversa (al aceptar datos del usuario)

Si habéis entendido perfectamente todo lo explicado hasta hora, se pueden deducir cuáles son las posibles conversiones inequívocas que podemos hacer:

Para conseguir esto...:	...puedes usar esto:
Hora Local	UTC con TZ del usuario
Hora Local	UTC con Offset del usuario en esa hora y lugar
UTC	Hora Local con Offset del usuario en esa hora/lugar
UTC	Hora Local con TZ del usuario -- Imposible

a) Almacenar el offset no vale para mucho

b) El usuario debería poder especificar el offset al introducir una hora

 

Ultílogo

 

[ Ir a la parte 1 de 2: “Sobre la Hora Universal y los relojes atómicos (o qué tienen en común el TomTom y unos trigales)” ]

01.25.12

Sobre la Hora Universal y los relojes atómicos (o qué tienen en común el TomTom y unos trigales)

[ Ir a la parte 2 de 2: “Zonas horarias, DST, Desplazamientos y otras zarandajas” ]

Con este ladrillazo de artículo intento esclarecer unos cuantos detalles sobre esos grandes desconocidos que son UTC, GMT y demás acrónimos indescifrables.

 

Obligatory disclaimer: Intento dar una explicación inteligible, no algo 100% tećnicamente correcto. En parte porque… bueno, tampoco soy aquí un experto en la materia ;-). Tanto mis fuentes como mi interpretación pueden ser erróneas. Así que si algo canta, os ruego dejéis un comentario para corregirlo.

 

TAI

TAI es una medición del tiempo, independiente del planeta Tierra, del sistema solar, y de cualquier astro en general. Está basada en relojes atómicos.
Empezó a medirse en el 1972, y es completamente independiente de cualquier otro sistema de medición.

Si el día de mañana cae un meteorito que ralentiza el giro del planeta, haciendo que los días duren 3 minutos extra desde ese momento, al TAI se la trae floja. 😀

Actualmente el TAI lleva un desfase acumulado de más de medio minuto (porque la Tierra ha ido ralentizándose desde 1972).

 

UT

UT es una medición del tiempo, conforme al planeta Tierra. Por tanto, UT varía si el comportamiento de la Tierra varía.

Ejemplos: movimientos de placas tectónicas, terremotos, el susodicho meteorito de los dinosaurios, mareas por la Luna, o por si al Sol, Saturno y Jupiter les toca alinearse, etc.

El UT puede medirse de muchas formas diferentes. Ninguna de ellas se puede dar como Verdadera ™ realmente, porque la Tierra ni siquiera es una esfera, y esto de “la hora del día” es una invención humana al fin y al cabo.

Existen unos cuantos de esos métodos de medición: UT0, UT1, UT1R, UT2, UT2R, y UTC (para más info: UT Versions).

 

UTC

• UTC, en concreto, usa una especie de media entre varios relojes atómicos situados en diferentes puntos del planeta (por efectos relativistas que no vienen al caso)
• UT1, por su parte, usa fuentes “externas” (como cuásares, posiciones de satélites, etc) para intentar medir el UT. Se suele considerar como la mejor técnica de las existentes. Aunque es algo subjetivo, claro está, y dependerá de la aplicación.
• Al offset que acumula UTC respecto a UT1, se le denomina DUT1.

 

Por definición, UTC debe mantener el DUT1 por debajo de 1 segundo.

 

Este año 2012, el DUT1 anda muy cerca del segundo, por lo que en Junio el UTC sufrirá un salto para corregir ese DUT1 excesivo. A eso se le llama leap-second.

Los ordenadores se suelen sincronizar via NTP con un proveeder de UT basado en relojes atómicos (UTC), de ahí que se use tanto el término UTC en computación.

Si quitas todos los leap-seconds que ha habido, UTC se convierte efectivamente en TAI.

GMT

GMT es lo que se usaba antes de establecerse los UTs actuales para medir el tiempo del planeta Tierra. En el 1972, se decidió pasar a llamarlo “UT”, sin más, así en general. A veces GMT se refiere a UTC, a veces a UT1, y a veces a lo que usaban antes del 1972 (observaciones únicamente desde el meridiano de Greenwhich).

Además, GMT es una zona horaria usada como referencia para otras. Por ejemplo, GMT (ó GMT+0), es usada en ciertas épocas del año por UK.

No solo eso, sino que el viejo GMT tuvo varias definiciones: inicialmente se ponía la “hora cero” al mediodía (muy usada por astrónomos, y ahora llamada GMAT), y más tarde, a la noche. El cambio se produjo al pasar del año 1924 al 1925. Ese año Diciembre no tuvo 31 días, sino 31.5 días.

Resumiendo, tenemos unas cuantas acepciones de GMT:

1. Sistema previo al 1924 (basado en mediodía, también llamado GMAT)
2. Sistema entre 1924 y 1972 (basado en medianoche)
3. Sistema posterior al 1972 (UT1).
4. Sistema posterior al 1972 (UT1+DUT1, es decir, UTC).
5. Zona horaria de algunos países.
6. Otras posibles acepciones (cualquier otro UT) en fechas posteriores a 1972.

Efectivamente: al explicarlas, las siglas GMT suelen ir acompañadas de las siglas WTF.

Por todo ello, GMT se puede usar en entornos informales (peliculeros, noticiarios, o lo que sea). Pero en entornos computacionales, militares, médicos, aeronáuticos, y cualquier otro que sea crítico, lo mentalmente saludable es usar siempre algo como UTC.

 

TomTom y los trigales

En realidad esto de los trigales lo había puesto por atraer un poco la atención (¿¿ha funcionado??), pero ya que estamos, habrá que explicarlo…

El GPS como sabéis, utiliza satélites. Concretamente, utilizan muchísimo las mediciones de tiempo para poder estimar la posición y altitud. Es imperioso que todos los GPS funcionen en un marco horario común, o sino los delicados cálculos de vuestro TomTom no valdrían para nada.

Usar UTC no es muy serio, por el tema de los leap-seconds. UT1 tampoco es especialmente útil, porque cambia continuamente, según cambia el planeta Tierra.

Así que los GPS usan su propio sistema, el GPS-Time. GPS-Time es idéntico al TAI mencionado al principio del post, pero tiene un offset constante de unos 19 segundos. Esto se debe a que el GPS-Time coincidía con UTC en el momento de su creación (en 1980), pero no avanza a la velocidad de UTC, sino a la del TAI.

Si el GPS-Time tuviera una velocidad variable como cualquier UT, entonces sería facil que el navegador del coche acabara situándote 100 metros más allá de donde realmente estás, plantándote en medio de una pradera, o en el fondo de un lago.

Así que, por suerte para los conductores, el TomTom y los trigales tienen pocos puntos en común.

 

Zonas horarias, DST

¿Creíais que empezabais a entender el tema?

Pues olvidaos, porque aún falta todo el tema de zonas horarias y DST, que es la verdadera miga del asunto en lo que a programación se refiere.

Y eso que no se han tocao apenas temas tangenciales, como pueden ser los meridianos de referencia, las horas métricas, las horas decimales como la Internet Time de Swatch, el protocolo NTP con sus stratums…

 

Pero lo dejo ahi, porque bastante gordo ha quedado ya el post!

 

[ Ir a la parte 2 de 2: “Zonas horarias, DST, Desplazamientos y otras zarandajas” ]

01.21.12

AwesomeMounter: join plug’n’play drives into a single large directory

Have you ever run out of space, and decided to offload some of the bigger files to a second (or third…) disk? Sometimes even an external drive?
Are you tired of having to look around all disks in order to find that specific file?

Well, you’re in luck!
Because AwesomeMounter is an awesome program that will get you rid of all that mess, without ever needing to know what LVM, RAID, or even filesystem means.

(…probably!)

AwesomeMounter is free and GPLv3. Based on inotify and mhddfs [en], it’s actually a pretty simple bash script (so if you’re interested, you can easily tinker with it).

 

What can AwesomeMounter do?

Here’s an example. You’ve got 3 places where you store music: your Linux home (50 gigs), a Windows partition (100gigs), and an 8 gigs USB pendrive:

1. /home/foo/music/ (has reggae and jazz subdirectories)
2. /mnt/windows/data/mp3/ (has pop and jazz subdirectories)
3. /media/pendrive/songs/ (has hiphop and electro subdirectories)

And you want all the music in a single place. Namely:

• /music/ (will contain all the aforementioned music)

 

With AwesomeMounter, you can access music through the 3 original paths, or through /music/, like this:

• /music/ (total size: 50+100+8 = 158 gigs!)
• /reggae
• /pop
• /jazz
• /hiphop
• /electro

How cool is that?

 

Plug-n-Play!

With AwesomeMounter, you gain the ability to disconnect (or umount) any drive at any time.
Reciprocally, whenever a previously set-up drive is connected or mounted again to your system, the data will automatically reappear where the AwesomeMounter config files tells it to.

This makes it perfect in combination with external drives, such as pendrives, USB hard disks, cellphones, memory cards…

 

Continuing the example: the USB pendrive at /media/pendrive/, can be removed as you normally would (e.g. right click -> unmount drive), and /music/hiphop and /music/electro will automatically disappear from /music.

 

Storage balancing!

(a.k.a. what happens when I write stuff in there?)

Any new file you try to write, will automatically be put in the drive with the most free space.

E.g.: If your pendrive is full, data will be stored somewhere else.

 

If you need to write stuff to a specific drive, you can bypass this awesome automatic storage balancing. by simply using the corresponding original path at /media/pendrive/*, instead of the joined path that AwesomeMounter made available to you at /music/.

 

How do I use it?

First, copy the script anywhere on your disk, and give it execution permissions.

Then, create a configuration file at ~/.awesomemounter/config. Example file:

##########################
# some configured dirs:
/music /home/foo/music,/media/pendrive/songs
/movies /home/foo/videos,/media/bigHDD
/downloads /home/foo/incoming,/mnt/windows/p2p
# you can nest mounts w/out problems
/video /movies,/downloads/series,/home/foo/docus
##########################

Then simply run awesomemounter from command line (you may be prompted for root access):

$ ./awesomemounter.sh

That’s it!

 

Where do I get it?

AwesomeMounter is available at GitHUB:

https://github.com/stenyak/AwesomeMounter

Don’t forget to create the config file!

 

DISCLAIMER: Use at your own risk. If your house burns down because of it, don’t blame me. Instead, call the firefighters and only then don’t blame me.

04.27.11

Crash course in Wave and Apache Wave

This articles tries to give a brief introduction to that ‘Wave‘ thingy everyone used to talk about, explaining the concept, history overview and even how to get it running by yourself.

Quick history lesson

At the Google I/O conference on May 27, 2009, Google announced this new communication concept: “Wave”. Most technical people attending the event “got it” right away and applauded.

Later that year, Wave was open for testing through the typical invite system. Google Wave, however, was still half baked and unusable. Most of the critics dismiss it as yet another unnecessary social network, a solution waiting for a problem, etc.

Nearing the end of 2010, statistical analysis at Google showed the public reception wasn’t as good as expected. Google decides to pull the plug and open source parts of it, deviating resources to other projects.

Before the year 2010 ends, with many parts of it open sourced by Google, the small dev community gathers the pieces, and starts the new Apache Wave project.

Nowadays, in 2011, Apache Wave is actively developed by the open source community, and an alpha version can be easily run in your computer.

 

Cool… what was “wave” again?

For the computer literates, here you have two easy to understand comparison tables, using email as a reference:

Concept description	E-Mail term	Wave term
A piece of information	an email	a wave
The act of sending a piece of information	to email someone	to wave someone
Protocol	SMTP, POP3, IMAP...	Wave Protocol
Interaction between different servers	ability to send email from one @domain to another @domain	wave server federation
Development of the project concepts and reference software	IETF + independent developers?	Apache Wave

Software description	E-Mail software	Wave software
Proprietary server+webclient package	Yahoo! Mail	Google Wave
Open source server+webclient package	Zimbra	Wave In A Box
Open source server	Exim	Google FedOne
Open source client	Thunderbird	Google Wave-Splash
Open source webclient	RoundCube	Micro-Box

What can Wave be used for?

Wave aims to be a common denominator to many other communication forms. An open standard that anyone can use and implement (even in the form of proprietary servers or clients, like Google Wave). Let’s see an example:

 

In a common use case, your internet workflow could involve:

• An email client running on your desktop
• Twitter client
• Facebook tab
• An feed reader
• Receiving messages from two mailing lists
• Manually checking some random movie forums weekly for new posts
• Get notified by email of replies to some blog post comments you wrote

 

In the wave world case, your internet workflow would involve:

• A Wave client
• Or, alternatively, go the old route: keep using the very same specific clients for each of those services, even if they use the Wave Protocol under the hood (just like Facebook Chat and GTalk run on top of Jabber).

 

Most importantly, and this cannot be stressed enough:

You are free to choose which clients to use as interface.

And you are also free to choose which servers to use for storing your data waves.

Now try doing that with Facebook, Twitter, Flickr…

 

Test a WaveInABox demo now

So you want to test the open source Apache Wave software? The wave community runs some test servers and clients on the net. The most common one is located at http://waveinabox.net, and is updated daily.

Disclaimer: WaveInABox server and client are still in very early development stage, so do not rely on them at all, and do not expect everything to work correctly.

Or deploy your own WaveInABox

Maybe you want to test it locally, perhaps play with the code, or even run it privately for personal purposes. In that case, it’s really easy to get it up and running in Linux:

# apt-get install mercurial ant default-jdk eclipse
$ hg clone https://wave-protocol.googlecode.com/hg wave-in-a-box
$ cd wave-in-a-box
$ ant compile-gwt
$ ant dist-server
$ ant -f server-config.xml -Dwave_server_domain=$HOSTNAME -Dsigner_info_store_type=file -Daccount_store_type=file -Ddelta_store_type=file -Dattachment_store_type=disk
$ ./run-server.sh

(there’s instructions for Windows and MacOSX too)

At this point, the server is running, and the web client can be accessed at http://localhost:9898.

Final words

Even if this article is very shallow, I hope it provides a different perspective of the whole subject, and helps people see the actual purpose behind the waves.

By the way, I’m reachable at stenyak@googlewave.com and stenyak@waveinabox.net. Feel free to wave me any time! 😉

03.8.11

Surfing the electromagnetic waves – Debugging IEEE 802.11 with Wi-Spy

Some months ago, when I moved to this house, I found it was pretty difficult to get any WiFi device to connect to my wireless home network. Recently I tried debugging it, and these are the results…

 

Finding a proper WiFi channel

Finding an appropriate WiFi channel is part of the usual initial setup. Some routers and APs can choose channels automatically, but that’s not my case, so I had to resort to third party applications. One of my favourites is Wifi Analyzer for Android, which looks like this:

You can see what channels are used by which networks, and so the less used channels can be easily spotted. In my case, I decided to go for channel 10, which was pretty much free.

 

I tested Wi-Fi networks with 2 different routers, 1 dedicated AP, 2 Android phones, 1 iOS device, 1 laptop and 2 netbooks. Some specific combinations of them seemed to work, but most of them didn’t, sometimes even if they were in the same room as the access point.

How could this be?

 

Extending Wi-Fi range with WDS

First of all, I thought that the thin room walls might be thicker than I initially supposed. Therefore, I decided to put an AP in each of the two rooms I wanted to wirelessly link together.

One of the easiest ways is to use a Wireless Distribution System (WDS). You set up each of the two APs with the other’s MAC address, do some reboots, and off you go.

However, simple ping tests demonstrated I was still having a packet loss as high as 40%. Even if the APs were just a meter and a wall away from each other!

Extending Wi-Fi range with FEC

So the next option was to get a stronger signal in the other room, not with WDS, but using a Freaking Ethernet Cable. Once I got hold of a 10 meters cable, I plugged an AP at the end of the cable, in the other room.

To my dismay, it was barely possible to get a MacBook Pro to connect to the AP. There was a distance of 50 cm between the two!

So apparently, the wireless signal was being lost inside the room, and not due to the wall (this quickly ruled out the possibility of my walls being built of a thin layer of pure lead….).

 

Checking for electromagnetic interferences

Next up, and thinking it could be some sort of EMI, I decided to get help at the mailing list where the local computer geek^H^H^Hurus hang around, the e-ghost. A few emails later, and thanks to the kindness of @txipi, I was holding a USB 2.4GHz spectrum analyzer on my hands.

The Wi-Spy 2.4i is a nice piece of hardware, with a similar functionality to the WiFi Analyzer program mentioned at the beginning of this article. Main difference being, it can detect all kinds of EM signals (not just those identified as wifi networks). For example, it’ll pick up signals coming from bluetooth devices, wireless security cameras, microwave ovens, baby monitors, etc.

There’s some tools for linux, which can be installed with sudo apt-get install spectools, and look like this:

There’s also native software for Windows in the Wi-Spy CD which I sadly had to use, since I couldn’t configure the timescale of the spectrographs on linux spectools.

Once the software was correctly set up, I disabled my 802.11 network completely, and started logging data. Here’s the spectrograph for a period of about 30 non-continuous hours:

Vertical axis is time, horizontal axis is the frequency (wifi channel numbers are shown at the bottom for your convenience), and color axis is the maximum signal power.

Analyzing the 2.4GHz spectral graph

Several interesting patterns emerge from the graph:

First of all, there’s these red-yellow dots all over the spectrograph. They seem to represent network scans made by wifi devices every once in a while. The pattern can be consistently repeated by turning the WiFi of any device OFF and then ON; or by simply trying to refresh the list of networks.

02.5.11

Cliente *libre* de mensajeria en la nube (part 2)

(…continuación de la parte 1)

Bueno, andabamos en las nubes con el tema de mensajería. Para recapitular, el objetivo era:

• Conectividad 24/7
• Acceso a todas nuestras redes de IM con el mínimo esfuerzo
• Software libre por donde se pueda.

En la primera parte, hemos solucionado la papeleta mediante GNU Screen, Finch y una conexión SSH. La solución mola porque es completa, y no hace falta ningún software “raro” en los ordenadores cliente (solamente un cliente ssh). Para hacernos a la idea, quedaba tal que asín:

Pero tiene algunos defectos:

• Hay que usar exclusivamente el teclado (finch + screen + ratón es algo lioso de configurar, yo no lo he conseguido).
• Los enlaces multilínea pueden no ser reconocidos en su totalidad por el emulador de terminal que usemos, así que en esos casos, toca copy-paste de los cachos de enlace que haya en cada línea.
• Puede ser poco responsivo dado que, al fin y al cabo, screen+ssh es como un VNC de texto plano… y se nota cuando escasea el ancho de banda.

Así pues, intentaremos arreglar esos defectos:

Segunda solución: Bitlbee + Quassel IRC

Ahora vamos a ponernos en la piel de un Ubuntero típico de hoy en día: apesta andar con conexiones ssh, y más aún aprenderse que alt+n es para el siguiente tab de finch, o que ctrl+a,F redimensiona los contenidos del screen a nuestra terminal, etc…

Así pues, vamos a intentar tener un cliente de IM gráfico: en el que se pueda hacer copy-paste con el ratón, hacer clicks para hablar con las personas, y ese tipo de cosillas que se vienen haciendo desde hace 2 décadas. Por desgracia, no conozco ninguna solución tan elegante como la primera, por lo que esta vez va tocará instalar una aplicación en cada cliente que usemos, con un mínimo de configuración. Tampoco es mucho pedir, no? 🙂

Pasos a seguir:

1. Instalar Quassel Core en el servidor (ponerlo en un bucle o demonio para que esté siempre rulando)
2. Instalar Bitlbee en el servidor (ponerlo tb a lo demonio)
3. Instalar al menos un cliente de Quassel para hacer la configuración inicial.

Pero vamos por partes.

Quassel IRC es un cliente de IRC que tiene una estructura cliente-servidor para la interfaz gráfica. Es decir, puedes tener o no tener una ventana (Quassel Client) abierta, y puede estar en el mismo o en otro ordenador que el servidor (Quassel Core). Lo mismo que hace MLDonkey y Amule, para entendernos.

Podeis pensar que vaya chorrada, que para eso ya hay otros protocolos estandard como VNC, o el propio SSH con X-Forwarding habilitado para usar unas Xorg remotas. El tema es que el protocolo de Quassel está especializado en… en sus cosas, por lo que es mucho más eficiente, más rapido, y a veces hasta te plancha la ropa. No hay color, vamos… si habeis usado VNC o X remotas, sabeis a qué me refiero.

Bitlbee, por otro lado, es una jartada de software que básicamente hace de pasarela desde diversas redes de IM hacia/desde IRC. Es decir, Bitlbee te permite interactuar con MSN, ICQ, Jabber, incluso Twitter y Facebook, mediante cualquier cliente de IRC. Se puede decir, por tanto, que es literalmente un servidor de IRC (uno muy curioso, sí xD).

Bitlbee utiliza un canal IRC especial, el #&bitlbee, dentro del cual mete como participantes a todos tus contactos de IM (del messenger, gtalk, etc). De esta forma, si coges un cliente IRC para conectarte a ese canal, la lista de participantes es realmente tu lista de contactos multiprotocolo. Obviamente, al usar IRC como pasarela, perdemos features (como los avatares del contacto, las razones de estar /away, etc). Basta tirar un /query a cualquier contacto para iniciar una conversación con esa persona.

Así que la idea es, usar un cliente de IRC (Quassel Client) en cada ordenador que queramos conectar a las redes IM, y conectarnos al servidor IRC Bitlbee que aúna todas ellas en un solo punto centralizado y nuboso.

Existe una posible pega: si nuestro build de Bitlbee no tiene libpurple como backend (sí, el mismo que usa Pidgin y Finch, entre otros), no hay soporte de pasarela para redes IRC, con lo que tenemos que configurar nuestras redes IRC en cada cliente/ordenador que usemos. La cosa quedaría tal que asín:

Si os atrevéis a montar todo este lío, los pasos un poco más detallados de configuración inicial son:

1. Instalar como demonio Bitlbee en el servidor. Si no vamos a usar teléfonos moviles, podemos limitarlos a conexiones en 0.0.0.0 (conexiones del core de Quassel, que está en la misma máquina) para mayor seguridad.
2. Instalar como demonio Quassel Core en el servidor.
3. Instalar un Quassel client en un sobremesa o portatil y conectarlo al core.
4. Una vez conectados al core, le añadimos el servidor IRC de bitlbee en “localhost” (el propio servidor nuboso), con puerto default. Adicionalmente, podemos configurarle nuestras redes de IRC habituales (Freenode, etc), a menos que las vayamos a meter en el propio Bitlbee (solo si tiene libpurple de backend, como ya he mencionado).
   Toda esta configuración se guardará en el core, así que no hay que hacerlo de nuevo nunca más.
5. Al conectarnos al servidor IRC de bitlbee, se unirá al canal #&bitlbee automáticamente. Aquí es donde toqueteamos los settings de Bitlbee (todas las redes de IM, etc).
   Primero, nos registramos en Bitlbee con una contraseña, para poder guardar los settings: register <contraseña>
6. Ahora añadimos las cuentas de IM a Bitblee con unos comandos especiales: account add <parámetros>. Para más información, aquí hay una guía rápida de Bitlbee.
7. Una vez añadidas las cuentas IM, guardamos estos settings en Bitlbee con: save
8. Y ya, si queremos, podemos configurar Quassel para que automáticamente ejecute un /identify <contraseña> al conectar, para que se autentique en Bitlbee y nos cargue toda la configuración del tirón (lo mismo que la autenticación de la mayoría de servers IRC, vamos).

Si a estas alturas seguís despiertos, entonces habéis configurado por fin vuestro molón cliente de IM en la nube! Congratulations! 😀

Y para terminar, así es como pinta la cosa una vez hecho todo:

Una vez escrito el post, veo que al final puede ser o parecer un poquillo más complicado que la primera solución, por lo que si tenéis alguna duda, y yo algo de tiempo libre, podéis preguntarme aki abajo (o en mi buzz, o donde queráis, con tal que sea un sitio público para que el resto del internet se pueda beneficiar de las explicaciones), y os intento echar un cable.

Hasta la próxima, frikomaníacos!

02.3.11

Cliente *libre* de mensajeria en la nube (part 1)

Vamos a darle un poco de caña al blog, que lo tengo abandonao! Voy a explicar como tener un cliente de mensajería instantánea en “la nube”. Antes de nada,  vamos a explicar el concepto.

El Concepto

Tradicionalmente, nuestro usuario Joe tiene:
– Un chat en Facebook
– Un chat en Gmail (Google Talk)
– Un chat en su PC (Microsoft Messenger)
Y algunos frikis tenemos además cuentas de ICQ, Jabber, IRC, y quién sabe qué más.

Tanta nube, tanta nube, pero necesitamos configurar un cliente de IM en cada ordenador (sobremesa, netbook, oficina…). Los clientes multiprotocolo (como Kopete o Pidgin) ayudan un poco. Pero cuidado como intentes conectarte desde varios ordenadores a la misma cuenta de MSN o de ICQ (porque es técnicamente imposible). Y si además quieres buscar algo en tu historial de conversaciones, te hará falta mucho café, algunas aspirinas, conectividad a todos los ordenadores y webs por las que hayas hablado, y una buena dosis de bash-fu para parsear todos los logs.

Lo suyo sería olvidarse de tanto protocolo, y usar Apache Wave, pero como a la gente no le gusta el cambio, voy a presentar no una, sino DOS soluciones a este problema. En ambos casos, nos hace falta una nube, es decir, un servidor que vaya a estar online permanentemente. Ya sea algún hierro viejo encendido en el trastero, o un servidor alquilado a terceros en la vasta red.

Ambas soluciones permiten:

• Estar conectado 24/7 a todas nuestras redes de IM, sin necesitar un solo ordenador encendido en casa.
• Tener el historial de conversaciones en un sitio centralizado.
• Poder acceder a esas redes simultáneamente desde varios ordenadores, sin ningún problema en absoluto.
• No necesitar configurar nuestras redes de IM en cada ordenador que toquemos.
• No depender de software propietario para nada.

Primera solución: ssh + screen + finch

Si eres un frikón como dios manda, conocerás GNU screen. Esta utilidad permite tener sesiones de terminal abiertas “en background“, pudiendo verlas en pantalla u ocultarlas cuando se quiera.

SSH, obviamente, es una forma de conectarte de un ordenador a otro, ya sea con putty, openssh, o el cliente de turno.

Y finalmente, Finch es, para entendernos, un Pidgin portado a la terminal. Es un cliente IM multiprotocolo, que en vez de GTK o QT, usa letras en tu terminal. De hecho, tanto Finch como Pidgin se apoyan internamente en libpurple, una librería de IM multiprotocolo.

Como montamos el tinglado entonces?

1. Instalamos screen y finch en nuestro servidor.
2. Configuramos nuestras cuentas de mensajería en ese finch, una sola vez.
3. Creamos un bucle/demonio/cron que mantenga finch arrancado en un screen todo el rato (por si peta, que se arranque de nuevo él solo).

Una vez hecho esto, basta conectarnos vía SSH al servidor, y acceder al screen donde está finch encendido. Por ejemplo:

$ ssh stenyak@servidor.com
$ screen -x miFinch

Y en pantalla veremos nuestro cliente, con su lista de contactos, sus pestañas para cada conversación, etc.

Por ejemplo, he aquí una sesión de Finch conectado a GTalk, MSN y un canal IRC en Freenode:

(por si alguien se pregunta donde entra Facebook en todo esto, comentar que el chat de Facebook tira desde hace bastantes semanas del protocolo Jabber. No es 100% compliant, pero cualquier cliente de Jabber decente debería poder conectarse a él)

Como podéis comprobar, es una solución solo apta para muy frikis. Los logs están todos legibles en texto plano en ~/.purple/logs.

Segunda solución

Pero a estas alturas de la vida, muchos linuxeros prefieren poder hacer clics y cosas así; por ello existe otra segunda solución, que como es un poco tarde, explicaré en el siguiente post.

Stay tuned!

(continúa en la parte 2…)

12.18.09

The Chuck Norris Facts Bash Script

Pon un Chuck Norris en tu vida! O mejor aun, pon miles de Chuck Facts en tu consola!

Bored STenyaK Productions presents: chuckfacts.sh!

Coming this winter to a console in front of you…

#!/bin/bash

# check for parameters
if [ -z $1 ]
then
    echo "Please specify the destination chuck norris facts file."
    echo "E.g.: $0 ~/.chuckfacts.txt"
    exit
fi
ffile=$1

old=0
if [ -s $ffile ]
then
    old=$(wc -l $ffile |sed "s/\s.*//g")
fi

echo -n "Getting facts pack"
# download the 170 first chuck norris pages of 4q.cc site to disk
for i in $(seq 1 170)
do
    echo -n " $i"
    # only store facts
    wget -qO - \
       "http://4q.cc/index.php?pid=listfacts&person=chuck&page=$i" \
        | grep "index.php?pid=fact&person=chuck" >> $ffile

done
echo ""

echo -n "Post-processing facts..."
# remove unnecessary html code
perl -pi -e "s/.*id=.{32,32}\">//g;s/<\/a>.*//g" $ffile

# replace most common html entities
perl -pi -e "s/&quot;/\"/g" $ffile
perl -pi -e "s/&amp;/&/g" $ffile

# remove empty lines
perl -ni -e "print unless /pid=/" $ffile

# remove redundant lines
cat $ffile |sort |uniq > /tmp/chuckfacts.tmp
mv /tmp/chuckfacts.tmp $ffile
new=$(wc -l $ffile |sed "s/\s.*//g")
echo " OK"
echo "Generated $(($new-$old)) new facts ($new in total) facts."

# show how to add a fortune-like command to bashrc
echo ""
echo "You can add this to your ~/.bashrc file:"
echo 'test -s '$ffile' && cowsay -f $(ls /usr/share/cowsay/cows
      | shuf |head -1) "$(cat '$ffile' |shuf |head -1)"'

Mira que no me aburro a veces ni nada eh…

12.2.09

En defensa de los derechos de los ciudadanos en Internet

Ante la inclusión en el Anteproyecto de Ley de Economía Sostenible de modificaciones legislativas que afectan al libre ejercicio de las libertades de expresión, información y el derecho de acceso a la cultura a través de Internet, los periodistas, bloggers, usuarios, profesionales y creadores de internet manifestamos nuestra firme oposición al proyecto, y declaramos que…

1.- Los derechos de autor no pueden situarse por encima de los derechos fundamentales de los ciudadanos, como el derecho a la privacidad, a la seguridad, a la presunción de inocencia, a la tutela judicial efectiva y a la libertad de expresión.

2.- La suspensión de derechos fundamentales es y debe seguir siendo competencia exclusiva del poder judicial. Ni un cierre sin sentencia. Este anteproyecto, en contra de lo establecido en el artículo 20.5 de la Constitución, pone en manos de un órgano no judicial -un organismo dependiente del ministerio de Cultura-, la potestad de impedir a los ciudadanos españoles el acceso a cualquier página web.

3.- La nueva legislación creará inseguridad jurídica en todo el sector tecnológico español, perjudicando uno de los pocos campos de desarrollo y futuro de nuestra economía, entorpeciendo la creación de empresas, introduciendo trabas a la libre competencia y ralentizando su proyección internacional.

4.- La nueva legislación propuesta amenaza a los nuevos creadores y entorpece la creación cultural. Con Internet y los sucesivos avances tecnológicos se ha democratizado extraordinariamente la creación y emisión de contenidos de todo tipo, que ya no provienen prevalentemente de las industrias culturales tradicionales, sino de multitud de fuentes diferentes.

5.- Los autores, como todos los trabajadores, tienen derecho a vivir de su trabajo con nuevas ideas creativas, modelos de negocio y actividades asociadas a sus creaciones. Intentar sostener con cambios legislativos a una industria obsoleta que no sabe adaptarse a este nuevo entorno no es ni justo ni realista. Si su modelo de negocio se basaba en el control de las copias de las obras y en Internet no es posible sin vulnerar derechos fundamentales, deberían buscar otro modelo.

6.- Consideramos que las industrias culturales necesitan para sobrevivir alternativas modernas, eficaces, creíbles y asequibles y que se adecuen a los nuevos usos sociales, en lugar de limitaciones tan desproporcionadas como ineficaces para el fin que dicen perseguir.

7.- Internet debe funcionar de forma libre y sin interferencias políticas auspiciadas por sectores que pretenden perpetuar obsoletos modelos de negocio e imposibilitar que el saber humano siga siendo libre.

8.- Exigimos que el Gobierno garantice por ley la neutralidad de la Red en España, ante cualquier presión que pueda producirse, como marco para el desarrollo de una economía sostenible y realista de cara al futuro.

9.- Proponemos una verdadera reforma del derecho de propiedad intelectual orientada a su fin: devolver a la sociedad el conocimiento, promover el dominio público y limitar los abusos de las entidades gestoras.

10.- En democracia las leyes y sus modificaciones deben aprobarse tras el oportuno debate público y habiendo consultado previamente a todas las partes implicadas. No es de recibo que se realicen cambios legislativos que afectan a derechos fundamentales en una ley no orgánica y que versa sobre otra materia.

11.12.09

Google’s “go” simple & stupid benchmark (2nd round: memspeed)

Continued from Round 1: I/O

Thanks to Juanval for the suggestion.

$ cat hello.cpp && g++ hello.cpp &&
> time for i in $(seq 10); do ./a.out; done
int main (int argc, char** argv)
{
    const int size = 250;
    int a[size],b[size],c[size];
    for(int i=0;i<size;++i)
        for(int j=0;j<size;++j)
            for(int k=0;k<size;++k)
                c[k]+=a[i]*b[j];
}
real	0m1.041s
user	0m0.944s
sys	0m0.020s

---

$ cat hello.py &&
> time for i in $(seq 10); do python hello.py; done
size = 250
a,b,c = [0]*size, [0]*size, [0]*size
for i in a:
    for j in b:
        for k in range(0,size):
            c[k] += i*j
real	1m7.210s
user	1m4.924s
sys	0m0.084s

---

$ cat hello.go && 8g hello.go && 8l hello.8 &&
> time for i in $(seq 10); do ./8.out; done
package main
func main()
{
    var a,b,c [250]int;
    for i := range a
    {
        for j := range b
        {
            for k := range c
            {
                c[k] += a[i] * b[j];
            }
        }
    }
}
real	0m3.000s
user	0m2.812s
sys	0m0.020s

Follow

Tags

Recent Posts

• Diagnosing and disabling bugged CPU cores
• Track Tour Episode 1: Circuit de Spa-Francorchamps (1967 edition)
• VR Showdown – Quick review of 11 headsets
• Review Oculus Rift CV1, comparación con DK2
• Presentación GIT & GIT-SVN
• Grokking Git in 8 slides (for svn users)
• Hacking the LGA 775 socket
• In defense of unformatted source code – breakindent for vim
• Trick of the day: rendering graphics in your terminal
• Helpful VIM highlighting
• HTML5 + Box2D = Quick’N’Dirty Dakar Rally Sim
• Tramitar baja de ADSL YaCom
• Liberación de recursos en python
• Software steadicam – Or how to fix bad cameramen
• Zonas horarias, DST, Desplazamientos y otras zarandajas