Planeta GULTij

alwayslast.bash

2016-06-22T00:31:58+00:00

Este script permite poner en un archivo las últimas N líneas de una salida. Por ejemplo, ping [...] | alwayslast.bash FILE 10 permitiría que FILE tuviera las últimas 10 líneas de la salida de ping.

This script allows for a file to have the las N lines of an output. For example, ping [...] | alwayslast.bash FILE 10 would make FILE always have the last 10 lines from the output of ping.

#!/bin/bash

if [ "$#" -ne 2 ]; then
 echo "Usage: $0 output_file maxlines"
 exit 2
fi

FILE="$1"
MAXLINES="$2"

START=0
LINES=1

while IFS= read -r NEWLINE; do
 BUFFER[START]="$NEWLINE"

 TEMPFILE=$(mktemp)
 trap -- 'rm "$TEMPFILE"' EXIT INT TERM

 for INDEX in $(seq "$((START+1))" "$((LINES-1))") $(seq 0 "$START"); do
 printf '%s\n' "${BUFFER[$INDEX]}"
 done > "$TEMPFILE"

 chmod --reference="$FILE" "$TEMPFILE"
 mv "$TEMPFILE" "$FILE"
 trap -- EXIT INT TERM

 LINES="$((LINES+1))"
 if [ "$LINES" -gt "$MAXLINES" ]; then
 LINES="$MAXLINES"
 fi
 START="$(((START + 1) % MAXLINES))"
done

Gracias a Eduardo Bustamante por sus correcciones.

Feed al podcast Dr. IPv6

2016-06-03T23:49:57+00:00

LAC-TF es la Fuerza de Trabajo de IPv6 en la región de Latinoamérica y el Caribe

Dr. IPv6 es un podcast en español preparado por LAC-TF y dirigido por Alejandro Acosta en el que se busca a especialistas para contestar preguntas que tenga la comunidad sobre IPv6. Puedes enviar tus preguntas a dr.ipv6@lacnic.net.

Debido a que el podcast aún no tiene un feed RSS, sólo los audios, decidí hacer un feed para poder agregar este útil e intersante podcast a mi Rhythmbox y AntennaPod.

Aquí lo comparto con ustedes. Se actualiza cada hora según lo que se publique en la página oficial de Dr. IPv6, extrayendo los metadatos y convirtiéndola en formato RSS. Siéntete en la libertad de usarlo para agregar Dr. IPv6 al “podcatcher” de tu preferencia.

La dirección de los feeds:

Dr. IPv6 en formato Ogg: http://blog.alvarezp.org/dripv6/feed-ogg/feed.xml

Dr. IPv6 en formato MP3: http://blog.alvarezp.org/dripv6/feed-mp3/feed.xml

Actualización sobre cointoss en Bash para evitar azar cargado

2016-05-17T00:40:28+00:00

Hace unas 3 semanas publiqué una nota personal para implementar “cosstoin” en Bash:

cointoss() {
    # Probability is $1/$2, for example, cointoss 3 5
    # will hit 60% of the time. Defaults to 1/2 if no
    # arguments are supplied.
    [ $((RANDOM % ${2-2})) -lt ${1-1} ];
}

Actualización

Sin embargo, como bien me lo indica dualbus, este volado está cargado cuando la cantidad de caras en la moneda, el denominador (indicado por $2), no es múltiplo de 2. Y me hace llegar la implementación para azar balanceado que greybot recomienda en #bash en Freenode:

rand() {
    local max=$((32768 / $1 * $1)) r
    while (( (r=$RANDOM) >= max ))
    do
        :
    done
    echo $(( r % $1 ))
} ## Returns unbiased random number from 0 to ($1-1) inclusive, $1 <= 32768

La razón es sencilla: cuando se invoca la variable RANDOM en Bash, regresa un valor entero entre 0 y 32,767. Estos 32,768 posibles valores no se pueden dividir exactamente en N grupos cuando N no es múltiplo de 2; siempre quedan algunos grupos con más valores posibles. La “carga” cambia según el denominador.

La única manera de evitar este efecto es que si RANDOM cae en valores sobrantes, se repita la invocación a la variable RANDOM. De esta manera se garantiza el balanceo de la distribución probabilística, aunque no sea posible garantizar que el resultado se logre siempre en menos de K intentos.

Ejemplo cuando el denominador es 3

Si queremos dividir los 32,768 valores en 3 grupos:

X mod 3 == 0 lo cumplen 10,923 valores: 0, 3, 6… 32,763 y 32,766.
X mod 3 == 1 lo cumplen 10,923 valores: 1, 4, 7… 32,764 y 32,767.
X mod 3 == 2 lo cumplen sólo 10,922 valores: 2, 5, 8… y 32,765.

El 32,768 ya no forma parte del conjunto de resultados de RANDOM. Esto significa que hay una desventaja para X mod 3:

X mod 3 == 0: 33.3343506%
X mod 3 == 1: 33.3343506%
X mod 3 == 2: 33.3312988%

La diferencia es de 0.0030518% entre extremos, un incremento de 0.009156%.

Si ejecutamos 1,000,000 de veces cointoss 1 3, espero un hit 33.3…% de las veces (más/menos el error causado por el azar). El resultado medido 5 veces cae entre 33.27% y 33.38%. El valor esperado cae dentro de lo medido.

Ejemplo cuando el denominador es 24,576 (forzando el bug)

¿Qué pasa si llamamos cointoss 16384 24576?

X mod 24576 == 0 lo cumplen 2 valores: 0 y 24,576.
X mod 24576 == 1 lo cumplen 2 valores: 1 y 24,577.
X mod 24576 == 2 lo cumplen 2 valores: 2 y 24,578.
…
X mod 24576 == 8190 lo cumplen 2 valores: 8190, 32766.
X mod 24576 == 8191 lo cumplen 2 valores: 8191, 32767.
X mod 24576 == 8192 lo cumple 1 valor: 8192.
X mod 24576 == 8193 lo cumple 1 valor: 8193.
…
X mod 24576 == 24573 lo cumple 1 valor: 24573.
X mod 24576 == 24574 lo cumple 1 valor: 24574.
X mod 24576 == 24575 lo cumple 1 valor: 24575.

Entonces, para los grupos de 2 valores, la probabilidad de salir es de 0.0061035%, mientras que para los grupos de 1 valor, la probabilidad de salir es de 0.0030518, una diferencia de 0.0030518%, ¡pero un incremento de 200%!

Si ejecutamos 1,000,000 de veces cointoss 16384 24576, espero un hit 66.6…% de las veces (más/menos el error causado por el azar). El resultado medido 5 veces cae entre 74.95% y 75.07%. ¡El valor esperado no cae dentro de lo medido!

De nuevo, gracias a dualbus por el apunte.

Cointoss en Bash

2016-04-22T21:56:53+00:00

cointoss() {
    # Probability is $1/$2, for example, cointoss 3 5
    # will hit 60% of the time. Defaults to 1/2 if no
    # arguments are supplied.
    [ $((RANDOM % ${2-2})) -lt ${1-1} ];
}

Ayúdanos a ayudarte

2016-03-30T21:05:30+00:00

Estimado compañero de chat:

Alguien te ha enviado a esta publicación porque consideró que necesitabas una guía para preguntar más eficazmente en nuestro canal de chat. No creas que no queremos ayudarte sino que hay ciertas explicaciones que nos toca repetir frecuentemente para facilitar la participación de los usuarios que nos visitan por primera vez o sólo ocasionalmente.

Antes, un poco de contexto

Por algún motivo algunos usuarios perciben el canal como un lugar dedicado al soporte, pero este no es el caso. Las recomendaciones que presentamos a continuación se comprenderán mejor si enfatizamos la distinción entre sala de charla y departamento de soporte:

En un departamento de soporte se pueden atender solicitudes en todo momento porque hay roles y horarios dedicados con sueldo a la atención al usuario. Directa o indirectamente, el usuario paga y mantiene ese soporte y por eso existe. Esto permite una atención expedita y personalizada. Son personas cuyo trabajo diario es guiar usuarios pacientemente a la resolución de problemas.

En cambio, el propósito de nuestro canal es la charla casual. El soporte es sólo uno de los diversos temas aceptables. Quienes platicamos somos profesionales como tú que no estamos dedicados al soporte. Esto significa que no estamos al pendiente de la ventana de chat. De repente encontrarás alguien al que le gusta dedicarse más al chat, pero aún es un voluntario.

Lo cierto es que procuramos ayudar cuando se puede. ¡Bienvenido!

Dicho lo anterior, permítenos hacerte algunas recomendaciones que te ayudarán a esquivar los patrones inconvenientes más comunes de los participantes nuevos y ocasionales. No pretendemos ofender; sólo buscamos poder ayudarte mientras nosotros continuamos con nuestro trabajo diario.

Entra con tiempo disponible

Para nosotros, es muy común revisar la pantalla de chat a eso a las 6:15 p. m. y ver lo siguiente:

[2:30p] * nuevo (~nuevo@example.net) se ha unido a #canal
[2:30p] <nuevo> hola
[2:33p] * nuevo se ha ido de #canal

A veces ocurre que nos damos cuenta casi 4 horas después de que un usuario nuevo entró y salió.

Comprendemos que es normal y humano que al ver un canal sin líneas de texto, se perciba como muerto y que es inútil preguntar. Sin embargo, esperar solamente 3 minutos antes de abandonar el canal no da ni siquiera oportunidad de ver el mensaje. Cuando estamos muy pocos fácilmente pueden pasar horas antes de que alguien vea un mensaje.

La realidad es que mientras hacemos nuestras labores diarias la ventana de chat está escondida. Las ventanas que usualmente tenemos activas son aquellas de nuestras herramientas de trabajo, no las de chat. Y si estamos en una reunión de trabajo, comiendo, durmiendo, cenando con nuestra familia, etc. nos es imposible enterarnos del chat.

En resumen, es poco probable estar viendo la pantalla de chat en el momento exacto en que un usuario entra.

Recuerda que para poder ayudar a alguien que tiene urgencia y prisa alguien tendrá que dejar de lado su actividad actual. La actitud de urgencia en usuarios nuevos es mal vista en IRC, porque significa que se menosprecia el tiempo de los demás participantes.

Usa un cliente de escritorio o aplica Pin en el navegador

Hemos notado que abandonar rápido el canal también se da porque es que latoso tener abierta una ventana de navegador. Incluso, es fácil cerrarla por accidente.

Por eso nosotros no usamos IRC a través del nevagador. En su lugar, usamos un cliente de IRC como XChat, irssi, BitchX, Chatzilla, Pidgin, Konversation, etc. Así, puedes dejar tu ventana de chat abierta en fondo. Además, estos clientes emiten una notificación cuando alguien te menciona y resalta esa línea para una fácil distinción visual.

Como alternativa, algunos navegadores soportan la función Pin. Esto evita que una pestaña de navegador se cierre por equivocación. Usualmente la encuentras haciendo clic derecho sobre la pestaña.

Pregunta directamente

Es muy común ver preguntas como esta:

<nuevo> ¿Alguien ha usado Audacity?
<voluntario> Hola nuevo. Yo lo uso más o menos.
<nuevo> Hola voluntario. ¿Por qué truena tanto?

Esto es mal visto. El usuario que más comúnmente hace esta pregunta busca un experto para resolver un problema complejo o necesita ser llevado de la mano hacia una respuesta. En ambos casos esto toma mucho tiempo. Precisamente, en el ejemplo, ambas preguntas hechas son vagas y no permiten llegar a ningún lado.

Estrictamente hablando, la respuesta es “no sé”. Causas puede haber muchas y cada una se resolvería por alguien con distinto perfil:

Causa	Quién podría resolver	Dificultad de diagnóstico
Compilación incorrecta	Integrador o distribuidor	Difícil
Falta de una librería	Integrador o distribuidor	Difícil
Falta de espacio en disco o RAM	Tú mismo	Fácil
Falta de red	Tú mismo	Fácil
Falla de hardware	Tú mismo	Difícil
Bug en el programa	Autor del programa	Difícil
Problema de permisos	Según el caso	Según el caso

Preguntar directamente permite que todo el canal vea tu pregunta completa desde tu primera intervención sin necesidad de que alguien te lleve de la mano.

Ejemplos de preguntas que difícilmente te van a llevar a algo (observa el uso de la palabra “alguien”):

“¿Hay alguien aquí que me pueda ayudar?”
“¿Alguien ha manejado X/Y/Z?”
“¿Alguien ha logrado compilar el kernel antes?”

Decíamos que estas preguntas son mal vistas: se distingue que el usuario espera un diálogo individual con algún voluntario para propósitos de soporte o incluso consultoría. Para que un voluntario te dedique tiempo él debe dejar alguna de sus actividades de lado. Aunque sin intención, el usuario está manifestando una falta de respeto al tiempo de otros. (Ver la sección Antes, un poco de contexto).

Lo más probable es que alguien ignore la pregunta, desafortunadamente, incluso cuando haya alguien que pueda ayudarte.

Y no es que no queramos apoyar o resolver dudas sin cobrar, sino que preferimos que las cosas ocurran de otra manera:

Que todos se enteren de tu pregunta desde el principio para que si alguien puede y quiere ayudar, así lo haga.
Que todos se enteren de la conversación completa, pues a todos nos sirve como experiencia.
Que todos se enteren de la solución.

Mejor, lanza tu pregunta directamente y de manera concreta y así la vemos todos desde el principio.

Haz la tarea antes de preguntar

Por hacer la tarea nos referimos a tu propia labor de búsqueda, investigación y estudio; incluso, a hacer el intento de que funcione lo que pretendes hacer.

Es muy común esto:

<nuevo> Hola. ¿Cómo cambio permisos en un archivo en Linux?

Hay decenas de páginas que ofrecen respuestas directas a esta pregunta. Están a una búsqueda de distancia. No necesitas de nuestra ayudar para ir a Google y buscar:

cambio de permisos en linux

Entonces la mayoría lo interpretará como que te dio flojera buscar.

Sin embargo, tal vez el problema no era que no hayas buscado y encontrado la información, sino que leíste y no sabes cómo hacer eso de “chmod” que todas las páginas mencionan. Entonces tu pregunta no fue conveniente. Mejor pregunta directamente y con contexto:

<nuevo> Hola. Quiero cambiar los permisos en un archivo pero
<nuevo> todas las páginas dicen algo de "chmod", pero ¿cómo hago eso?

Entonces sabemos que debemos guiarte a entrar a la Terminal.

O tal vez no entiendes lo de los permisos, lo del “664” y “ug=rw”. Entonces pregunta:

<nuevo> Hola. Quiero cambiar los permisos en un archivo pero
<nuevo> me está costando trabajo entender lo del "664" y el "ug=rw".

Hay muchas otras páginas que explican eso claramente, así que seguramente no te daremos un tutorial personalizado, pero sí una liga a una página que consideremos decente y clara. Léela. Lo que pasa es que no sabemos si no le entiendes a nada o si tienes una duda en específico.

La siguiente pregunta nos permite darte una respuesta concreta sin emplear mucho tiempo, al menos un sí o un no:

<nuevo> Hola. Me está costando trabajo entender lo del "664" y el
<nuevo> "ug=rw". En un canal me mandaron a esta página: http://.../
<nuevo> ¿Entonces 660 significa "ug=rwx"?

Esta pregunta nos da aún más contexto para ayudarte. No sabemos qué pasó en tu proceso de entendimiento, pero te podemos ayudar diciéndote que estás equivocado y que 660 equivale a ug=rw, no a ug=rwx.

Y con eso seguramente saldrán dudas muy específicas.Poco a poco irás corrigiendo y comprendiendo correctamente cómo funcionan los permisos. No es lo mismo que explicarte todo desde cero.

Sé paciente al esperar una respuesta

Una regla general en IRC es que sólo conteste quien sepa la respuesta, pueda ayudar, o dicho más generalmente, quien pueda y quiera contribuir con la conversación. Procuramos evitar dos situaciones en específico. La primera es generar ruido innecesario:

<nuevo> ¿Alguien sabe si Chromium tiene una opción para abrir URLs
<nuevo> desde la línea de comandos?
<voluntario2> No, sorry.
<voluntario3> Yo no sé.
<voluntario4> Nel.
<voluntario5> Yo no pero tal vez alguien más sepa.
<voluntario6> Usa --new-window. Es una opción no documentada.
<voluntario7> Ni yo.
<voluntario8> Ya somos 7 que no sabemos.

Visualmente se pierde la respuesta de voluntario6 entre tanto ruido para todos, incluso para quienes leen de golpe los últimos mensajes del canal.

La segunda, y más importante, es evitar que un “no sé” se malinterprete como “nadie sabe”:

<nuevo> ¿Alguien sabe si Chromium tiene una opción para abrir URLs
<nuevo> desde la línea de comandos?
<voluntario1> No, sorry.
<voluntario2> Yo no sé.
<nuevo> Bueno, muchas gracias de todos modos.
* nuevo se ha ido de #canal
<voluntario3> Usa --new-window... uhh, ya se fue.

Pregunta con contexto

Mencionábamos en la sección Pregunta directamente cómo las preguntas vagas no llevan a ningún lado debido a la amplitud de sus alcances.

Por eso, parte de preguntar en concreto es incluir brevemente el contexto de la pregunta. Por ejemplo:

<nuevo> Hola. Audacity me manda mucho el error
<nuevo> "Imposible escribir a archivo" y luego truena.
<voluntario1> nuevo, ¿ya revisaste que tu disco duro tenga espacio?
<voluntario2> nuevo, ¿no tienes problemas de permisos?
<voluntario3> nuevo, ¿con qué usuario lo estás ejecutando?

El mensaje de error, además de dar un punto de partida, ofrece una idea de por dónde comenzar a atacar el problema.

Respeta el tema del canal

¿Entrarías a un canal de leyes preguntando sobre ingeniería de aviones? No. De la misma manera, nuestro canal tiene un tema central.

Un truco: en el espacio de texto por donde hablas puedes mandar el texto /topic (con diagonal al inicio). El canal de chat te va a contestar inmediatamente con el tema del canal. A veces ahí ponemos avisos y ligas a páginas útiles que contestan preguntas frecuentes.

Conclusión

Todos hemos sido usuarios nuevos y hemos pasado por lo mismo. Los voluntarios del canal no sólo tenemos identificados estos patrones de comportamiento sino que comprendemos por qué suceden. Todos fuimos usuarios nuevos alguna vez y hemos pasado por lo mismo. Ahora que somos un poco más experimentados observamos que nuestros errores se repiten en otros usuarios nuevos. Es simplemente que juzgar a partir de la evaluación de condiciones inmediatas simplemente forma parte de nuestra evolución como seres humanos.

Gracias por leer hasta aquí, sinceramente, y de nuevo, bienvenido a nuestro canal.

Fechas para próximos Raspberry Pi Bootcamps en Cuernavaca

2016-03-28T19:26:51+00:00

Después de nuestro 1er Raspberry Pi Bootcamp en Cuernavaca, ya tenemos la lista de las siguientes fechas, aquí la lista

Abril 16, 2016
Abril 30, 2016
Mayo 14, 2016
Mayo 28, 2016
Junio 11, 2016
Junio 25, 2016

Para recibir más información nos puedes escribir a raspi@informatux.net

El Raspberry Pi es una computadora de bajo costo de el tamaño de una tarjeta de crédito que se conecta a un monitor o televisión y utiliza un teclado y ratón común.
Este dispositivo aunque pequeño da la oportunidad a gente de toda edad de explorar una plataforma computacional aparte de permitir el aprendizaje de una manera sencilla e interactiva de programación con lenguages como Scratch y Python.
Es capaz de hacer cualquier tarea que una computadora de escritorio o laptop, desde navegar internet hasta reproducir video de alta definición.

Por su fácil manejo, el Raspberry Pi ha sido utilizado en diversos proyectos, ha sido utilizado en proyectos para crear dispositivos musicales, sensores de movimiento y estaciones meteorológicas.

Tweet This Post

Caddeus 0.4

2016-03-20T20:00:08+00:00

He liberado Caddeus 0.4. Caddeus es un archivo GNUmakefile ya preparado con orientación a la calidad estricta de programas hechos en C.

Cuenta con un ejecutor de pruebas óptimo, banderas CFLAGS estrictas, revisión automática de código con Cppcheck, análisis estático con Clang y búsqueda de fugas de memoria con Valgrind, en caso de encontrar estas herramientas instaladas en el sistema.

Raspberry Pi Bootcamp – presentación UNIVAC

2016-03-16T01:11:07+00:00

El día de hoy tuvimos la oportunidad de estar en la UNIVAC con alumnos de ingeniería para presentar el Raspberry Pi Bootcamp a celebrarse este próximo Sábado 19 de Marzo en Cuernavaca.

Para recibir más información nos puedes escribir a kwame@informatux.net

Tweet This Post

Raspberry Pi Bootcamp – Zero demo

2016-03-09T02:50:11+00:00

Por su fácil manejo, el Raspberry Pi ha sido utilizado en diversos proyectos, ha sido utilizado en proyectos para crear dispositivos musicales, sensores de movimiento y estaciones meteorológicas.

Tweet This Post

Raspberry Pi Bootcamp – Camera board

2016-03-08T04:12:10+00:00

Hablando del Raspberry Pi, sin importar su tamaño, es un equipo de cómputo totalmente completo. En este curso vamos a ver como conectar el Raspberry Pi para hacer uso de sus funciones básicas. Vas a aprender cómo interactuar con el Pi y como interactuar con su hardware.

Algunos de los conceptos que vamos a trabajar son:

Utilizar las funciones básicas del Raspberry Pi
Conocer las capacidades del Raspberry Pi
Instalar la versión más reciente de Raspbian
Configurar el Raspberry Pi para poder interactuar con él localmente y de manera remota por medio de VNC y SSH
Comandos básicos de BASH para interactuar con Raspbian
Programación con Scratch
Usar la Raspberry Pi Cam para crear un timelapse
Utilizar la interfaz GPIO en el Raspberry Pi para poder controlar hardware

Para más información favor de escribir a kwame@informatux.net

Tweet This Post

Raspberry Pi Bootcamp en Cuernavaca

2016-03-04T04:00:57+00:00

El próximo 19 de Marzo del 2016 se llevará a cabo el Raspberry Pi Bootcamp.

Este curso está enfocado para aquellas personas que quieran explorar las posibilidades y capacidades del Raspberry Pi.

El curso no asume que los participantes tienen previa experiencia en programación o Linux, sin embargo, un poco de conocimiento de Linux y conocimiento del lenguage de programación Python sería de gran ayuda.

Si no cuentas con conocimiento previo de Linux o Python no te preocupes, en este curso se encuentran secciones que abarcan los pasos básicos de uso de Linux y Python.

El objetivo de este curso es realizar 2 proyectos:

El primer proyecto te enseñará como utilizar Python para hacer uso de la cámara y crear un timelapse
El segundo proyecto está enfocado a controlar leds utilizando los pines GPIO, todo por medio de Python, utilizando el módulo GPIOZero para Python.

El tiempo apróximado de este curso es de 7 horas.

Hardware provisto para usar durante el curso:

Raspberry Pi 2 Modelo B
Raspberry Pi Camera Board
Capacitive Touch Sensor Hat
Protoboard
Leds y resistencias
Teclado y mouse
Monitor

Más informes en kwame@informatux.net

Tweet This Post

GPIO Zero: a friendly Python API for physical computing – Raspberry Pi

2016-02-11T21:17:27+00:00

Physical computing is one of the most engaging classroom activities, and it’s at the heart of most projects we see in the community. From flashing lights to IoT smart homes, the Pi’s GPIO pins make programming objects in the real world accessible to everybody. Some three years ago, Ben Croston created a Python library called RPi.GPIO, […]

Source: GPIO Zero: a friendly Python API for physical computing – Raspberry Pi

Tweet This Post

Raspberry Pi: Weather Monitoring Project Outline and Resources

2016-01-19T18:08:49+00:00

Un buen video acerca de como crear una estación meteorológica con Raspberry Pi

Tweet This Post

generate_timedivisions() para PostgreSQL

2015-09-18T06:47:27+00:00

En PostgreSQL, supongamos que queremos generar todos los períodos mensuales entre ‘2015-09-12 23:50:00’ y ‘2015-11-22 00:20:00’ con corte al inicio del día 8.

Se puede crear la siguiente función:


CREATE OR REPLACE FUNCTION generate_timedivisions(ts_start timestamp, ts_end timestamp, period varchar, period_offset interval = '0') RETURNS TABLE(tr_start timestamp, tr_end timestamp) AS $$
DECLARE
    end_of_test_interval timestamp;
BEGIN
    SELECT date_trunc(period, ts_start) + ('1 ' || period)::interval + period_offset INTO end_of_test_interval;
    WHILE end_of_test_interval < ts_end LOOP
        RETURN QUERY SELECT ts_start, end_of_test_interval;
        ts_start = end_of_test_interval;
        end_of_test_interval := ts_start + ('1 ' || period)::interval;
    END LOOP;
    RETURN QUERY SELECT ts_start, ts_end;
END;
$$ LANGUAGE plpgsql;

Y usarla de esta manera:


-- Obsérvese que se usa '7 day' y no '8 day' por las siguientes razones:
-- 1. los días comienzan a contarse con 1.
-- 2. el último parámetro es 'interval'
-- 3. Se pide el corte al *inicio* del día 8.
SELECT * from generate_timedivisions('2015-09-12 23:50:00', '2015-11-22 00:20:00', 'month', '7 day');

      tr_start       |       tr_end        
---------------------+---------------------
 2015-09-12 23:50:00 | 2015-10-08 00:00:00
 2015-10-08 00:00:00 | 2015-11-08 00:00:00
 2015-11-08 00:00:00 | 2015-11-22 00:20:00

How to Shrink an LVM Volume [Wiki] | NDCHost

2015-09-16T13:28:45+00:00

The following steps will show you how to shrink an LVM volume. In this example we will be shrinking volume VolGroup00-LogVol00 down to 20GB. Note: This can and will cause data loss if performed improperly or on a volume that you attempt to shrink below the current volume usage. With that said, the steps are as follows:

Source: How to Shrink an LVM Volume [Wiki] | NDCHost

Tweet This Post

Asiste al Software Freedom Day Tijuana 2015

2015-09-08T01:12:13+00:00

¡Nos vemos el sábado 19 de septiembre de 2015 en el Software Freedom Day Tijuana 2015!

En este evento tendremos por primera vez dos salas con actividades simultáneas. ¡Será como un minicongreso! Tendremos los talleres mencionados y un área de demostraciones donde podrás interactuar de primera mano con los programas de Software Libre.

Conoce todos los detalles y regístrate en http://sfd.gultij.org/

Como siempre, te pido que nos ayudes a pasar la voz:

Dale ‘Invitar’ y ‘Compartir’ a tus amigos al evento en Facebook.
Dale ‘Retweet’ al post en Twitter.

Infinitas gracias a nuestros expositores, voluntarios y patrocinadores.

10 Job Interview Questions for Linux System Administrators | Linux.com

2015-08-03T17:01:01+00:00

SysAdmins of all experience levels can benefit from brushing up on their job interview skills if they want to find and land a great new job.

Source: 10 Job Interview Questions for Linux System Administrators | Linux.com

Tweet This Post

Crecimiento y declive de la comunidad

2015-07-29T01:45:48+00:00

En el grupo de Facebook Gultij – Grupo de Usuarios de GNU/Linux de Tijuana, Gustavo pregunta lo siguiente. He traducido las citas que originalmente estaban en inglés.

Momentum de las comunidades del software libre:

Veo un post en los grupos de OpenSuSE que dice algo así como:

«Googleé grupos de usuarios de Linux en mi región y encontré que la mayoría de los sitios no han sido actualizados en años. ¿Comenzó a morir Linux mientras estuve ausente?»

Y una de las respuestas, que me pareció acertada:

«Sí, la comunidad es una sombra de lo que alguna vez fue. El Código Abierto y la tecnología ya no es tan padre y la nube es un enorme parásito adjuntado a la comunidad Open Source.»

Me parece acertada la última línea. ¿Se ha vuelto la comunidad FLOSS simplemente un producto / mercancía para los intereses de otras compañías o proyectos, mas allá de la temática filosófica? ¿Qué opinan?

Primero hay que detectar las falacias, y en la pregunta original hay una grave. No es lógico implicar “sitios de los GUL sin actualizar → Linux comienza a morir”, esa es una conclusión un tanto melodramática.

Lo que sí es cierto es que la comunidad se ha transformado. No es que la comunidad venga a menos sino que se ha transformado gracias al surgimiento de otras fuentes de información centralizadas en la nube. Al tener un alcance mayor, es más fácil encontrar respuestas de mayor calidad en estos foros; es natural. En otras palabras, la comunidad global se ha fortalecido y algunas comunidades locales presentan declives.

El beneficio de los GUL locales es menor en apariencia pero sólo lo es en cuanto al GUL como fuente de información. Hay otros beneficios más difíciles de apreciar y Mario H. Cornejo los describe muy bien en la publicación Presentar en un grupo de usuarios de su blog Developeando.

Sin embargo, a pesar de este surgimiento de información centralizada, modificar nuestro consumo hacia la nube nos hace dependientes de la misma (y en consecuencia de E. U. A. y el dólar), en lugar de ejercer la libertad de nuestro propio cómputo. No estoy lanzando culpas: los costos y el mercado dirigen parte de este movimiento, pero la disculpa no elimina la realidad.

Hay que diferenciar audiencia de comunidad. Hay que diferenciar a quienes buscan en el grupo de usuarios como mera fuente de información (la audiencia, que consume el valor del grupo) de quienes aportan con trabajo, participación, código y contenido original (la comunidad, que genera el valor del grupo).

El perfil de la gente que genera valor es diferente del perfil de la gente que lo consume. No resulta sorpresivo que —salvo algunas excepciones— la mayoría de la gente que genera valor también está presente en el canal de IRC #gultij en la red Freenode.

He visto —en otros lugares— que la gente dice “¿cuándo es la siguiente presentación?” pero nadie dice “yo ofrezco este tema”. Eso no es comunidad, eso es audiencia. Con esto me refiero a que los sitios Web de los LUG no se actualizan solos; algún humano debe generar el contenido (de preferencia original, no sólo enlaces a blogs).

Al final del día, el éxito de los GUL depende únicamente de la gente. Si la gente no aporta con trabajo a un GUL, éste automáticamente se desvanece. Es muy fácil:

Si pocos trabajan para el GUL, la densidad de trabajo es muy alta y los frutos de la comunidad son bajos; los voluntarios se desmotivan y se van.
Aunque haya actividad, si no se da la apariencia de dicha actividad, los externos no la perciben (como ocurre en la pregunta original) y no participan; entonces el trabajo se mantiene concentrado en unos cuantos… y ver punto anterior.

En resumen, a la pregunta original —la que fue citada por Gustavo— yo contestaría: los grupos de usuarios de tu área comenzaron a morir debido a que estuviste ausente.

Software Freedom Day, Tijuana 2015

2015-07-15T14:39:55+00:00

La fecha para el Software Freedom Day Tijuana 2015 está establecida. Será el sábado 19 de septiembre de 2015.

¡Bienvenidos presentadores! Envía tu propuesta antes del 31 de julio a http://sfd.gultij.org/

¡Comparte tus conocimientos! Regístrate en http://sfd.gultij.org/ y presenta en el Software Freedom Day, Tijuana 2015

Flash plugin update on Debian 8

2015-06-29T17:55:11+00:00

Just a quick reminder on how to upgrade your flash-plugin install in Debian 8

update-flashplugin-nonfree –install

Cheers!

Tweet This Post

A veces un “if” es más barato

2015-05-22T00:27:50+00:00

En una interesante discusión en el grupo de Facebook de la Comunidad .NET Tijuana surgió el tema de las microoptimizaciones, en particular el uso de evaluación en corto circuito y el ahorro de ifs “que son muy costosos al CPU”.

Mi último argumento:

A lo que iba es que el short-circuit, si bien te puede ahorrar ifs, también puede darte sorpresas como brincarse validaciones de seguridad. Ha ocurrido en otros lenguajes. Yo prefiero un if explicito, que en realidad no es nada caro al CPU, a menos que no diseñes bien tus condiciones.

Entonces el autor original hace un planteamiento: ¿Cuál de los dos siguientes programas es más rápido?

Programa X:

for (int i = 0; i < 1000; i++)
{
    if (x >= 10)
    {
        x = 0;
    }
    else
    {
        x++;
    }
}

Programa Y:

int y = 0;
for (int i = 0; i < 1000; i++)
{
    y = (y + 1) % 10;
}

A simple vista podría parecer que el programa X, el que tiene ifs, es más complejo: son más líneas y se divide el flujo del programa.

Pero, como siempre, la respuesta no es tan sencilla. Entonces se abre la caja de pandora. Para poder contestar sin experimentación se requiere de un conocimiento profundo y preciso de varios comportamientos que influyen en el rendimiento de un programa. Lo mejor que podemos hacer es el experimento.

¿En realidad importa?

Compilaré los siguientes programas en C:

Programa X:

#define LIMIT 1000
int main(void) {
    int x = 0;
    for (int i = 0; i < LIMIT; i++)
    {
        if (x >= 10)
        {
            x = 0;
        }
        else
        {
            x++;
        }
    }
    return 0;
}

Programa Y:

#define LIMIT 1000
int main(void) {
    int y = 0;
    for (int i = 0; i < LIMIT; i++)
    {
        y = (y + 1) % 10;
    }
    return 0;
}

Veamos cuál es más rápido:

$ c99 -o x x.c
$ c99 -o y y.c
$ time ./x

real	0m0.001s
user	0m0.000s
sys	0m0.001s
$ time ./y

real	0m0.001s
user	0m0.000s
sys	0m0.001s

Háganle caso al renglón user. En realidad no importa a cuál le hagan caso, los resultados de los dos programas son iguales.

Evidentemente ¡ambos programas son demasiado rápidos siquiera para ser medidos a pesar de que se trata de 1,000 iteraciones! Es decir, si hay una diferencia, es claro que ésta es menor a 1 ms. Realmente no nos importa.

Sin embargo, si estamos programando un sistema de manejo masivo de información (como un DBMS), esto podría resultar en una diferencia considerable. Por eso estos sistemas se escriben en C. En esos casos no sólo basta saber si importa, sino qué tanto importa.

Aumentemos el límite a 1,000,000

Qué bueno que definí el límite en una línea independiente, así puedo usar sed para modificar los archivos y que quede de manifiesto en la salida que pego a continuación.

$ sed -i -re 's/^#define LIMIT.*$/#define LIMIT 1000000/' x.c y.c
$ 
$ cat x.c
#define LIMIT 1000000
int main(void) {
    int x = 0;
    for (int i = 0; i < LIMIT; i++)
    {
        if (x >= 10)
        {
            x = 0;
        }
        else
        {
            x++;
        }
    }
    return 0;
}

$ cat y.c
#define LIMIT 1000000
int main(void) {
    int y = 0;
    for (int i = 0; i < LIMIT; i++)
    {
        y = (y + 1) % 10;
    }
    return 0;

Nuestra modificación funcionó. El límite quedó a 1,000,000. Compilemos:

$ c99 -o x x.c
$ c99 -o y y.c

Compila correctamente. ¿Cómo quedaron los tiempos?

$ time ./x

real	0m0.005s
user	0m0.005s
sys	0m0.000s
$ time ./y

real	0m0.012s
user	0m0.012s
sys	0m0.000s

Se asoma una ligera tendencia a favor del programa X. Sin embargo es prácticamente negligible. ¡Estamos hablando de 7 ns de diferencia por iteración!

Probemos con 1,000,000,000 de iteraciones

Sin embargo, los números aún son muy chicos como para tener suficiente resolución. Cualquier pequeño efecto pasajero sobre la máquina nos podría perjudicar en la medición. Una manera barata de mejorar esto es aumentando a 1,000,000,000 de iteraciones.

$ sed -i -re 's/^#define LIMIT.*$/#define LIMIT 1000000000/' x.c y.c;
$ c99 -o x x.c
$ c99 -o y y.c
$ time ./x

real	0m2.737s
user	0m2.735s
sys	0m0.000s
$ time ./y

real	0m8.827s
user	0m8.816s
sys	0m0.000s

Ya se observan valores más medibles: la diferencia es de 6 ns por iteración. Esta diferencia radica en que entre más iteraciones, los efectos de la carga del programa desde disco (o caché de disco), segmentación de memoria e inicialización de las librerías se reducen en comparación.

Niveles de optimización en los compiladores

GCC soporta varios niveles de optimización ¡y vaya que tienen efecto! ¿Qué pasa si medimos el tiempo de ejecución de los programas con 1,000,000,000 de iteraciones utilizando diferentes niveles de mágicas optimizaciones del compilador?

Para compilarlos probaremos las banderas -O0, -O1, -O2, -O3, -Ofast y -Os. Por ejemplo, para compilar con el nivel de optimización 1, usaríamos la siguiente instrucción:

$ c99 -O1 -o x x.c

Estos son los resultados, medidos en segundos:

Nivel -O	X	Y
0	2.734	8.806
1	1.450	0.339
2	0.000	0.000
3	0.000	0.000
fast	0.000	0.000
s	0.000	0.000

Dos observaciones interesantes:

En -O1, el programa Y funciona más rápido que el programa X.
A partir de -O2 ¡el tiempo se desploma a cero!

Pero no todo es tan simple…

Los compiladores son muy astutos, parte 1

Comparemos el código generado por -O0 contra el código generado por -O2 para el programa X:

$ c99 -O0 -o x x.c
$ gdb -batch -ex 'file x' -ex 'disassemble main'
Dump of assembler code for function main:
   0x00000000004004ed <+0>:	push   %rbp
   0x00000000004004ee <+1>:	mov    %rsp,%rbp
   0x00000000004004f1 <+4>:	movl   $0x0,-0x8(%rbp)
   0x00000000004004f8 <+11>:	movl   $0x0,-0x4(%rbp)
   0x00000000004004ff <+18>:	jmp    0x400518 <main+43>
   0x0000000000400501 <+20>:	cmpl   $0x9,-0x8(%rbp)
   0x0000000000400505 <+24>:	jle    0x400510 <main+35>
   0x0000000000400507 <+26>:	movl   $0x0,-0x8(%rbp)
   0x000000000040050e <+33>:	jmp    0x400514 <main+39>
   0x0000000000400510 <+35>:	addl   $0x1,-0x8(%rbp)
   0x0000000000400514 <+39>:	addl   $0x1,-0x4(%rbp)
   0x0000000000400518 <+43>:	cmpl   $0x3b9ac9ff,-0x4(%rbp)
   0x000000000040051f <+50>:	jle    0x400501 <main+20>
   0x0000000000400521 <+52>:	mov    $0x0,%eax
   0x0000000000400526 <+57>:	pop    %rbp
   0x0000000000400527 <+58>:	retq   
End of assembler dump.
$ 
$ c99 -O2 -o x x.c
$ gdb -batch -ex 'file x' -ex 'disassemble main'
Dump of assembler code for function main:
   0x0000000000400400 <+0>:	xor    %eax,%eax
   0x0000000000400402 <+2>:	retq   
End of assembler dump.

¡¿DAFUQ?! ¡¿En serio?! ¿El compilador cambió todo el código que escribimos con el sudor de nuestra frente, por dos míseras instrucciones?

Pues sí, resulta que el compilador observó que nuestro cómputo no sirve de nada porque de todos modos estamos regresando 0 en la línea return 0, así que todo nuestro código no tiene efecto observable. Por eso lo toma, lo tira a la basura y nosotros seguimos observando exactamente el mismo resultado: el correcto.

Los compiladores son muy astutos, parte 2

Hagamos el mismo análisis, comparando el código generado por -O0 contra el código generado por -O2, ahora para el programa Y:

$ c99 -O0 -o y y.c
$ gdb -batch -ex 'file y' -ex 'disassemble main'
Dump of assembler code for function main:
   0x00000000004004ed <+0>:	push   %rbp
   0x00000000004004ee <+1>:	mov    %rsp,%rbp
   0x00000000004004f1 <+4>:	movl   $0x0,-0x8(%rbp)
   0x00000000004004f8 <+11>:	movl   $0x0,-0x4(%rbp)
   0x00000000004004ff <+18>:	jmp    0x400536 <main+73>
   0x0000000000400501 <+20>:	mov    -0x8(%rbp),%eax
   0x0000000000400504 <+23>:	lea    0x1(%rax),%ecx
   0x0000000000400507 <+26>:	mov    $0x66666667,%edx
   0x000000000040050c <+31>:	mov    %ecx,%eax
   0x000000000040050e <+33>:	imul   %edx
   0x0000000000400510 <+35>:	sar    $0x2,%edx
   0x0000000000400513 <+38>:	mov    %ecx,%eax
   0x0000000000400515 <+40>:	sar    $0x1f,%eax
   0x0000000000400518 <+43>:	sub    %eax,%edx
   0x000000000040051a <+45>:	mov    %edx,%eax
   0x000000000040051c <+47>:	mov    %eax,-0x8(%rbp)
   0x000000000040051f <+50>:	mov    -0x8(%rbp),%edx
   0x0000000000400522 <+53>:	mov    %edx,%eax
   0x0000000000400524 <+55>:	shl    $0x2,%eax
   0x0000000000400527 <+58>:	add    %edx,%eax
   0x0000000000400529 <+60>:	add    %eax,%eax
   0x000000000040052b <+62>:	sub    %eax,%ecx
   0x000000000040052d <+64>:	mov    %ecx,%eax
   0x000000000040052f <+66>:	mov    %eax,-0x8(%rbp)
   0x0000000000400532 <+69>:	addl   $0x1,-0x4(%rbp)
   0x0000000000400536 <+73>:	cmpl   $0x3b9ac9ff,-0x4(%rbp)
   0x000000000040053d <+80>:	jle    0x400501 <main+20>
   0x000000000040053f <+82>:	mov    $0x0,%eax
   0x0000000000400544 <+87>:	pop    %rbp
   0x0000000000400545 <+88>:	retq   
End of assembler dump.
$ 
$ c99 -O2 -o y y.c
$ gdb -batch -ex 'file y' -ex 'disassemble main'
Dump of assembler code for function main:
   0x0000000000400400 <+0>:	xor    %eax,%eax
   0x0000000000400402 <+2>:	retq   
End of assembler dump.

No sólo ocurre lo mismo, sino que además llama la atención la línea marcada en negritas:

0x000000000040050e <+33>:	imul   %edx

A pesar de no utilizar optimizaciones, el compilador sabe que, para calcular el módulo, usar la operación DIV tomaría más ciclos de reloj que seguir un algoritmo basado en multiplicaciones enteras, y sabe que eso es cierto en este caso y en esta arquitectura.

Otro ejemplo de una optimización común: cuando hablamos de una variable x que es entera positiva, la expresión x / 2 suele ser convertida en x >> 1.

¿Cómo evitar que nuestro código sea eliminado?

Simplemente es cuestión de usar el valor. Podríamos imprimirlo en pantalla, pero para mantener limpio el desensamblaje mejor cambiemos return 0 por return x o return y según corresponda:

$ sed -i -re "s/return 0;/return x;/" x.c
$ sed -i -re "s/return 0;/return y;/" y.c
$ cat x.c
#define LIMIT 1000000000
int main(void) {
    int x = 0;
    for (int i = 0; i < LIMIT; i++)
    {
        if (x >= 10)
        {
            x = 0;
        }
        else
        {
            x++;
        }
    }
    return x;
}

$ cat y.c
#define LIMIT 1000000000
int main(void) {
    int y = 0;
    for (int i = 0; i < LIMIT; i++)
    {
        y = (y + 1) % 10;
    }
    return y;
}

Bien, nuestro código fuente está correcto. Compilemos con -O3:

$ c99 -O3 -o x x.c
$ c99 -O3 -o y y.c

Compiló correctamente. Verifiquemos en el código generado:

$ gdb -batch -ex 'file x' -ex 'disassemble main'
Dump of assembler code for function main:
   0x0000000000400400 <+0>:	mov    $0x3b9aca00,%edx
   0x0000000000400405 <+5>:	xor    %eax,%eax
   0x0000000000400407 <+7>:	xor    %esi,%esi
   0x0000000000400409 <+9>:	nopl   0x0(%rax)
   0x0000000000400410 <+16>:	lea    0x1(%rax),%ecx
   0x0000000000400413 <+19>:	cmp    $0x9,%eax
   0x0000000000400416 <+22>:	mov    %ecx,%eax
   0x0000000000400418 <+24>:	cmovg  %esi,%eax
   0x000000000040041b <+27>:	sub    $0x1,%edx
   0x000000000040041e <+30>:	jne    0x400410 <main+16>
   0x0000000000400420 <+32>:	repz retq 
End of assembler dump.
$ gdb -batch -ex 'file y' -ex 'disassemble main'
Dump of assembler code for function main:
   0x0000000000400400 <+0>:	mov    $0x3b9aca00,%esi
   0x0000000000400405 <+5>:	xor    %edx,%edx
   0x0000000000400407 <+7>:	mov    $0x66666667,%edi
   0x000000000040040c <+12>:	nopl   0x0(%rax)
   0x0000000000400410 <+16>:	lea    0x1(%rdx),%ecx
   0x0000000000400413 <+19>:	mov    %ecx,%eax
   0x0000000000400415 <+21>:	imul   %edi
   0x0000000000400417 <+23>:	mov    %ecx,%eax
   0x0000000000400419 <+25>:	sar    $0x1f,%eax
   0x000000000040041c <+28>:	sar    $0x2,%edx
   0x000000000040041f <+31>:	sub    %eax,%edx
   0x0000000000400421 <+33>:	lea    (%rdx,%rdx,4),%eax
   0x0000000000400424 <+36>:	add    %eax,%eax
   0x0000000000400426 <+38>:	sub    %eax,%ecx
   0x0000000000400428 <+40>:	sub    $0x1,%esi
   0x000000000040042b <+43>:	mov    %ecx,%edx
   0x000000000040042d <+45>:	jne    0x400410 <main+16>
   0x000000000040042f <+47>:	mov    %ecx,%eax
   0x0000000000400431 <+49>:	retq   
End of assembler dump.

Claramente el código ya no está siendo eliminado.

$ time ./x

real	0m1.460s
user	0m1.458s
sys	0m0.000s
$ time ./y

real	0m4.188s
user	0m4.180s
sys	0m0.004s

El resultado: ~3 ns de diferencia por iteración en -O3.

La nueva tabla completa de resultados entre los diferentes niveles de optimización, medidos en segundos:

-O	X	Y
0	2.729	8.810
1	1.455	4.188
2	1.455	4.180
3	1.458	4.180
fast	1.458	4.185
s	1.451	5.688

¡Tenemos un ganador!

Observaciones interesantes: A diferencia de los resultados que obtuvimos en la primera tabla, donde el código usaba return 0, en esta ocasión el programa Y ya no gana ni siquiera en -O1. En realidad no es que fuera más óptimo anteriormente, sino que el compilador alcanzaba a descartarlo mejor por el uso de return 0.

Conclusiones

Las conclusiones te tocan a ti.

Actualización

Después de hacer la publicación caí en cuenta de que olvidé mencionar algunos detalles importantes:

El sistema donde se probó es un Intel(R) Xeon(R) CPU X5472 @ 3.00GHz de 8 núcleos con memoria ECC. Nunca vi que se usara más de un solo núcleo. Los invito a repetir las pruebas en sus laptops y Raspberry Pi. Raspberry Pi es ARM, hay que tomarlo en consideración.
GCC no fue lo suficientemente inteligente para detectar que sólo estábamos trabajando con constantes y haber reducido el programa a una asignación directa con complejidad O(1).
Es importante considerar que los dos programas probados no son equivalentes. X arroja 10, Y arroja 0. Para hacer una comparación justa entre dos programas es importante que el resultado sea el mismo. Aparentemente, el motivo del planteamiento era probar brutamente if contra bloques sin if. El motivo es que, en la vida real, las adecuaciones que se necesitarían para garantizar el resultado afectarían la complejidad del programa; se supone que uno es una refactorización del otro. En este caso sí importa cuidar los nanosegundos puesto que se trata de una medición.
El propósito de esta publicación es dejar en claro que la velocidad de un programa es muy variable y que depende de muchos factores, como del lenguaje, del compilador, de la arquitectura en la que corre el programa, del modelo exacto de microprocesador, incluso de la manera en como hacemos nuestra prueba, pero sobre todo, del algoritmo. La microoptimización sólo tiene sentido en casos muy particulares.

Monitor

2015-05-11T22:42:57+00:00

Diagrama de estados de Monitor

Monitor es un script escrito en puro Bash que permite dejar a la PC monitoreando el resultado de una instrucción. A diferencia de watch, no se trata de estar vigilando la salida de la instrucción, sino de detectar el momento en que ocurre la falla y ejecutar instrucciones cuando el servicio vigilado se cae o se levanta.

Monitor fue escrito para vigilar servicios con fallas de naturaleza aleatoria. En ocasiones el problema dura poco y no es fácil tomar una muestra del sistema justo cuando el problema ocurre.

Además, este tipo de situaciones tiene algunas características:

Se quiere saber cuándo se cayó y cuándo se volvió a levantar el servicio para saber en qué sección de las bitácoras buscar.
Se quiere tomar acción cuando se detecta otra caída. Estas acciones pueden ser toma de diagnósticos o envío de alertas.
Suele necesitarse ser tolerante a oscilaciones pasajeras; por ejemplo, un ping perdido no implica una caída de un equipo.

Si bien este tipo de vigilancia se resuelve fácilmente con un while de Bash, éste puede volverse rápidamente complejo y no es divertido estar depurándolo cada que uno se ve en la necesidad. Además, es posible cometer errores al programar la lógica del while y no darnos cuenta hasta cuando el problema original ya volvió a ocurrir y no obtuvimos la monitorización esperada.

Con Monitor, la lógica está establecida y comprobada. Sólo basta indicar qué instrucción queremos monitorizar.

El código está disponible en Github: https://github.com/alvarezp/monitor

Ejemplo

En un hipotético problema perdemos comunicación con nuestro propio host y no sabemos por qué. Sospechamos que un proceso corriendo en nuestra máquina está insertando reglas de iptables que resultan en el bloqueo de esta comunicación.

Utilicemos monitor.bash para vigilar el resultado de un ping a localhost y que en caso de caída confirmada se tome una muestra de iptables.

# monitor.bash --rest-time 1 --on-down 'iptables-save' 'ping localhost -c 1 -w 1 >/dev/null 2>&1'
       INIT 2015-11-05 15:21:58 PDT lun
         UP 2015-11-05 15:21:58 PDT lun
     ---- el proceso misterioso aplica iptables -A INPUT -i lo -p icmp -j DROP ----
FALLINGDOWN 2015-11-05 15:22:13 PDT lun
# Generated by iptables-save v1.4.21 on Mon May 11 15:22:17 2015
*filter
:INPUT ACCEPT [74:70608]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [67:5781]
-A INPUT -i lo -p icmp -j DROP
COMMIT
# Completed on Mon May 11 15:22:17 2015
       DOWN 2015-11-05 15:22:17 PDT lun
     ---- el proceso misterioso aplica iptables -F INPUT ----
RAISINGBACK 2015-11-05 15:22:32 PDT lun
         UP 2015-11-05 15:22:36 PDT lun

Da la impresión que iptables-save se ejecuta después de quedar en FALLINGDOWN, pero en realidad se ejecuta justo al entrar en DOWN.

Ya tenemos fechas y horas para buscar en bitácoras y algo de evidencia para profundizar en el diagnóstico.

LibreOffice Styles Tutorial

2015-03-13T16:01:09+00:00

LibreOffice Styles Tutorial

I wrote a small-and-quick tutorial for using LibreOffice Styles. It is intended to quickly let you understand (and hopefully grasp) the concepts behind the use of Styles without having to go through an entire manual.

It briefly covers and exemplifies the notion of Paragraph and Character Styles, Direct Formatting, automatic table of contents generation and chapter rearrangement through the Navigator.

Styles can do much more than explained in the tutorial, but it should get you started saving a significant amount of time.

Download it by clicking on the image or from here: /files/libreoffice-styles.odt

Internet radio stations at the tip of your fingers (and terminal)

2015-02-04T14:10:06+00:00

For those who want to listen to a variaty of internet radio stations, here I leave you with these bash alias

<span class="pl-s3">alias</span> news=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://minnesota.publicradio.org/tools/play/streams/news.pls<span class="pl-pds">"</span></span> <span class="pl-c"># MPR News </span>
<div id="file-internet_radio_stream_aliases-sh-LC7" class="line"><span class="pl-s3">alias</span> current=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://minnesota.publicradio.org/tools/play/streams/the_current.pls<span class="pl-pds">"</span></span> <span class="pl-c"># The Current </span></div>
<div id="file-internet_radio_stream_aliases-sh-LC8" class="line"><span class="pl-s3">alias</span> classical=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://minnesota.publicradio.org/tools/play/streams/classical.pls<span class="pl-pds">"</span></span> <span class="pl-c"># Classical MPR </span></div>
<div id="file-internet_radio_stream_aliases-sh-LC9" class="line"><span class="pl-s3">alias</span> minnesota=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://minnesota.publicradio.org/tools/play/streams/local.pls<span class="pl-pds">"</span></span> <span class="pl-c"># Minn </span></div>
<div id="file-internet_radio_stream_aliases-sh-LC10" class="line"><span class="pl-s3">alias</span> heartland=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://minnesota.publicradio.org/tools/play/streams/radio_heartland.pls<span class="pl-pds">"</span></span> <span class="pl-c"># MPR Radio Heartland </span></div>
<div id="file-internet_radio_stream_aliases-sh-LC11" class="line"><span class="pl-s3">alias</span> wonderground=<span class="pl-s1"><span class="pl-pds">"</span>mplayer http://wondergroundstream2.publicradio.org/wonderground<span class="pl-pds">"</span></span> <span class="pl-c"># MPR Wonderground Windows Media </span></div>
<div id="file-internet_radio_stream_aliases-sh-LC12" class="line"><span class="pl-s3">alias</span> choral=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://choralstream1.publicradio.org/choral.m3u<span class="pl-pds">"</span></span> <span class="pl-c"># Clasical MPR Choral</span></div>
<div id="file-internet_radio_stream_aliases-sh-LC13" class="line"><span class="pl-s3">alias</span> wefunk=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://www.wefunkradio.com/play/shoutcast.pls<span class="pl-pds">"</span></span> <span class="pl-c"># WEFUNK Radio MP3 64K</span></div>
<div id="file-internet_radio_stream_aliases-sh-LC14" class="line"><span class="pl-s3">alias</span> sleepbot=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://sleepbot.com/ambience/cgi/listen.cgi/listen.pls<span class="pl-pds">"</span></span> <span class="pl-c"># Sleepbot Environmental Broadcast 56K MP3</span></div>
<div id="file-internet_radio_stream_aliases-sh-LC15" class="line"><span class="pl-s3">alias</span> groovesalad=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://somafm.com/groovesalad130.pls<span class="pl-pds">"</span></span> <span class="pl-c"># Soma FM Groove Salad iTunes AAC 128K</span></div>
<div id="file-internet_radio_stream_aliases-sh-LC16" class="line"><span class="pl-s3">alias</span> dronezone=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://somafm.com/dronezone130.pls<span class="pl-pds">"</span></span> <span class="pl-c"># Soma FM Drone Zone iTunes AAC 128K</span></div>
<div id="file-internet_radio_stream_aliases-sh-LC17" class="line"><span class="pl-s3">alias</span> lush=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://somafm.com/lush130.pls<span class="pl-pds">"</span></span> <span class="pl-c"># Soma FM Lush iTunes AAC 128K</span></div>
<div id="file-internet_radio_stream_aliases-sh-LC18" class="line"><span class="pl-s3">alias</span> sonicuniverse=<span class="pl-s1"><span class="pl-pds">"</span>mplayer -playlist http://somafm.com/sonicuniverse.pls<span class="pl-pds">"</span></span> <span class="pl-c"># Soma FM Sonic Universe iTunes AAC 128K

Tweet This Post

First impressions of CentOS 7

2015-01-24T02:37:58+00:00

CentOS 7 has been out for a while now and it’s time to get busy with it and exploring this new version.
Some major changes have taken place in this version and I’ll list them here with no specific order.

The first thing you’ll see is that the installer is now the same as the one used in Fedora, you can still drop to the text mode install but if you use the GUI installer it’s just about the same as the one Fedora uses.

During the partitioning you’ll see that the filesystem chosen by default is now xfs and not ext4, even though it’s still available (ext4). It’s kind of a surprise that xfs was chosen as the default over ext4, specially considering that the last recorded updates for xfs date from 2013 http://xfs.org/index.php/XFS_Status_Updates. Now, talking about the nice features of xfs, it’s very powerful, it allows you to create incremental backups and from what I read in the documentation, it has the ability to suspend and resume in-progress dumps. If you are serious about migrating to CentOS 7 in the near future, xfs is definitively something you need to get your head around.

I’ll continue in another post my review of CentOS 7

Tweet This Post

Guía de Configuración avanzada de Servidor Linux basado en Ubuntu Server 12.04 LTS

2015-01-04T07:24:39+00:00

Este articulo es el cuarto dedicado a la instalación y configuración de servidores de red basado en Ubuntu Server 12.04, en esta ocasión dedicaremos tiempo a realizar las tareas de configuración avanzada post instalación, al realizar estas tareas dejaremos un ambiente funcional y personalizado para que sea integrarlo a cualquier ambiente con requisitos de tipo [...]

Guía de Configuración básica de Servidor Linux basado en Ubuntu Server 12.04 LTS

2014-10-05T06:04:46+00:00

Este articulo es el tercero dedicado a la instalación y configuración de servidores de red basado en Ubuntu Server 12.04, en esta ocasión dedicaremos tiempo a realizar las tareas de configuración básicas post instalación, al realizar estas tareas dejaremos un ambiente funcional y personalizado para que sea posible desarrollar de forma eficiente diferentes actividades ya [...]

Guía de Instalación de Servidor Linux basado en Ubuntu Server 12.04 LTS

2014-09-29T07:15:06+00:00

Esta es la segunda parte de una serie de 4 artículos que estaré publicando acerca de GNU/Linux en servidores de red, para ver la primera parte hacer clic aquí. En este articulo mostrare como realizar una instalación básica del sistema operativo Ubuntu Server 12.04 LTS. Ubuntu Server es una distribución GNU/Linux optimizada para funcionar como servidor [...]

Porque usar GNU/Linux en servidores de red

2014-09-28T06:15:37+00:00

Introducción En este articulo explicare porque recomendamos usar GNU/Linux como sistema operativo para servidores de red, ya sea para uso personal o empresarial. Empezaremos hablando de analizar los requisitos para implementar un servidor de red, porque usar GNU/Linux, y al final porque usar la distribución Ubuntu Server para servidores de red. Analizando los requisitos para la implementación de [...]

Consumo pico de memoria general en Linux

2014-08-27T20:36:49+00:00

Desafortunadamente, Linux no mantiene un registro del consumo pico de memoria general. Sí lo hace para un proceso pero no para la totalidad del sistema.

A falta de esto y como mero hack, el siguiente script se puede dejar corriendo durante un tiempo determinado:

#!/bin/bash

free -m -s 0.05 | while read A _ V _; do
  [ "$A" = "-/+" ] && [ "$V" -gt "${M:-0}" ] && { M=$V; echo $M; }
done

Ventajas:

No necesita de la instalación de ningún programa externo.
Es compatible con POSIX Shell.

Desventajas:

Funciona por sondeo (polling) cada 0.05 segundos. Esto significa que si entre muestra y muestra hay un pico que desaparece, éste no se reflejará. Idealmente el kernel llevaría el registro de manera asíncrona durante cada llamada a brk() y sbrk().
Podría no funcionar en locales con diferente separador decimal. Sería necesario cambiar 0.05 por 0,05. Tal vez se pudiera usar el parámetro $1 para evitar este problema.

Dejar de usar gmail, y sincronizar contactos, calendarios y archivos a ownCloud

2014-08-13T07:00:00+00:00

Siguiendo mis intentos de idependizarme de las grandes compañías, en este post escribiré cómo dejar de usar gmail, google calendar, google contacts (sincronización de contactos con android), y dropbox.

Dejar gmail La alternativa más efectiva a gmail y sin tener que recurrir a alguna otra grande compañía es montar tu propio servidor de correos, el cual puede resultar tedioso y hasta difícil para alguien sin experiencia computacional, por lo que les recomendaré el que me encontré hace unos días y empecé a usar: openmailbox. Este servicio de emails aún no es tan popular, pero está enfocado principalmente en respetar tu privacidad. Según eso, no registran nunca tu IP, y todo va encriptado. Tiene la opción de ponerlo en español, permite mandar archivos adjuntos de hasta 500 megas, y te aseguran que usan puro software libre. Obviamente tiene también acceso IMAP, POP, con sus varias encriptaciones. La interfaz es sinceramente muy bonita, y para mi una de las mayores ventajas que te dan es que te ofrecen tu propio ownCloud con 1 giga de almacenamiento, el cual usaré para deshacerme de otros productos de google y dropbox.

Owncloud es un software que podemos usar en nuestro propio servidor (o puedes tener 1 giga gratis cuando abres tu correo con openmailbox), el cual cuenta con innumerables características. Con ownCloud demostraré cómo me cambié de varios servicios de google y dropbox a algo más libre y controlado por mi.

Dejar dropbox

No tengo nada en contra de dropbox, simplemente quiero que mis archivos no sean manejados por una gran compañía que quién sabe qué hagan con mis documentos. Con ownCloud en nuestro servidor, podemos usarlo de la misma manera que usamos dropbox. Tiene clientes gratuitos para Linux, winbugs y mac, así como clientes para android y iphone. El cliente de android de la play store no es gratuito, pero podemos descargar libre y legalmente el mismo cliente desde F-Droid (tienda de software libre de aplicaciones para android). Y listo, tu propio sincronizador de archivos con espacio tan limitado como tu servidor.

Dejar google calendar

Este paso toma un poco de más tiempo dependiendo en qué tantos dispositivos quieras sincronizar el calendario. Usaremos de igual manera ownCloud, que funcionará como nuestro servidor CalDAV (formato estándar de calendarios). El calendario de ownCloud al momento de empezarlo a usar ya estará listo para CalDAV, no son necesarios pasos extras. El truco de esto es poder sincronizar este calendario en android, firefox OS, y en mi caso, en linux (disculpa iphone, jamás te he usado, pero seguro googleando se encuentra la forma). En el caso de linux, tanto KDE, como gnome, thunderbird, Firefox OS, y los demás escritorios cuentan por defecto con importación de calendarios CalDAV, con lo que lo único que hay que hacer será agregar el link CalDAV de nuestro calendario de ownCloud y listo. Para android, los pasos a seguir son los mismos que los de sincronizar contactos, como menciono a continuación.

Dejar de sincronizar contactos de android con google

Siempre es útil sincronizar contactos en caso de perder o cambiar nuestro celular. Como lo escrito anterior, usaremos ownCloud para guardar y sincronización nuestros contactos, en este caso usando CardDAV, el cual es un formato estándar de contactos. Estos pasos a seguir son los mismos que se usan para sincronizar el calendario de android con el de ownCloud. Lo primero que hay que hacer es descargar la aplicación DAVdroid, disponible gratuitamente en F-droid, o de pago en la play store. Una vez instalada, la abrimos y agregamos una nueva cuenta, en el cual llenamos los parámetros que se piden, como es el link de nuestro ownCloud, el usuario y la contraseña. DAVDroid automáticamente reconocerá todos los calendarios y contactos, y te permitirá elegir cuáles sincronizar. Una vez terminado esto, en el calendario de android nos aparecerá un nuevo calendario a sincronizar, con el nombre que le pusimos en DAVDroid, y ya de esta manera el calendario queda sincronizado. También cada que agreguemos un contacto, podremos seleccionar que lo guarde en DAVDroid, el cuál quedará sincronizado con ownCloud.

Y listo, ahora somos un poco más independientes. Paso a pasito llegaremos a ser libres algún día :D. Cualquier duda pueden buscarme con mi nick "biker" en freenode.

Webmaps usando OpenStreetMap

2014-07-31T07:00:00+00:00

En mi lenta transición de convertirme en una persona libre (como la cerveza), decidí cambiar el mapa embebido en mi sección de Lugares de Google Maps a OpenStreetMap (OSM). En la wiki de OpenStreetMap hay una gran lista de librerías para poder lograr esto.

El que elegí es uno llamado Leaflet, el cual los autores describen como simple, ligero y con gran soporte móbil. En mi experiencia, fue muy fácil implementarlo en mi sitio, igual sólo necesitaba un mapa con un montón de marcadores. Hay una sencilla guía de introducción (en inglés) en el sitio de la librería, el cual pueden seguir. Pero AGUAS, porque esa guía usa los mapas de Mapbox. Si, como yo, quieren usar los de OSM, necesitan simplemente cambiar el tileLayer para que use OSM, como pueden ver en mi ejemplo.

No pasó más de una hora y ya tenía mi mapa con todos los marcadores. Si quieren una alternativa a Google Maps, les recomiendo esta opción libre (:

Webmaps using OpenStreetMap

2014-07-31T07:00:00+00:00

So in my little steps of trying to be fully free (as in beer), I decided to change the map in my Places section from Google Maps to OpenStreetMap. There is a whole table in the OpenStreetMap wiki with many libs you can use to embed OpenStreetMap into a webpage, and add a lot of stuff to it.

The one I picked was the one at the top of the list, called Leaflet, which the authors describe as a library that focuses on performance, usability, simple API, small size and mobile support. In my experience, it was really easy to implement on my site, as well as I just needed something simple: a map with a bunch of markers. There is an easy quick start guide on Leaflet's site, where they use Mapbox for the maps, but if you are like me and want to use OSM, you only need to change the tileLayer to use it, see my example.

It didn't take me more than an hour to have the map with all the markers on it. If you want an alternative solution for embedding maps into your site, you can use this opensource one (:

Restricting mysql access to a user based on his source ip

2014-07-16T00:36:33+00:00

One of the most challenging aspects of working as a sysadmin is the broad scope of the tasks you have to work on. In a single day’s work you could be asked to look into a security report and take the appropriate steps to address it and fix it. You can also be brought into an alert reported by a monitoring system and do various things, such as, modify the threshold of the alert since it was a false positive and / or look into the alert itself and fix it. You can be asked to modify some application software to be able to handle the load it’s receiving by changing its settings or just deploy a second or more instances of this application and place all of them behind a load balancer so the load is spread between all of the app servers, all of this, without any downtime or interrupting the sessions of users already logged into your application. You can also be tasked to lock down the access to an application on a specific layer and you need to be able to do it in a very short amount of time since the application might be vulnerable or under attack.

All of these aspects make a sysadmin’s work day a very interesting one. I was recently asked to restrict access to MySQL and allow users to be able to connect from only a specific network segment. If I had just been asked to restrict access to MySQL based on network segment (this is a high traffic MySQL server running on a Linux server) I would have used iptables right out of the bat and be done with the task, but the request was to restrict access in the database itself.

So I went to the MySQL documentation site and followed some pointers. Fired up a VM to do some tests and these are the steps I would follow to achieve such task.

1. Review grants for the user which I want to lock down:

[root@workvm ~]# mysql -u root -p -h localhost
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 7
Server version: 5.1.73 Source distribution

Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> select user,host from mysql.user;
+-------+--------------------+
| user  | host               |
+-------+--------------------+
| kwame | %                  |
| root  | 127.0.0.1          |
|       | localhost          |
| kwame | localhost          |
| root  | localhost          |
|       | workvm.pythian.com |
| root  | workvm.pythian.com |
+-------+--------------------+
7 rows in set (0.00 sec)

mysql> show grants for 'kwame'@'%';
+------------------------------------------------------------------------------------------------------+
| Grants for kwame@%                                                                                   |
+------------------------------------------------------------------------------------------------------+
| GRANT USAGE ON *.* TO 'kwame'@'%' IDENTIFIED BY PASSWORD '*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19' |
| GRANT ALL PRIVILEGES ON `db1`.* TO 'kwame'@'%'                                                       |
+------------------------------------------------------------------------------------------------------+
2 rows in set (0.00 sec)
mysql>

In this case we want to restrict access to the user ‘kwame’ to have access only from 192.168.100.x

2. Remove access to this user:


mysql> delete from user where user='kwame' and host='%';
Query OK, 1 row affected (0.00 sec)

mysql> delete from user where user='kwame' and host='localhost';
Query OK, 1 row affected (0.00 sec)

mysql>

3. Grant access to the user only from 192.168.100.x


mysql> grant all privileges on `db1`.* TO 'kwame'@'192.168.100.%' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)

mysql> show grants for 'kwame'@'192.168.100.%';
+------------------------------------------------------------------------------------------------------------------+
| Grants for kwame@192.168.100.%                                                                                   |
+------------------------------------------------------------------------------------------------------------------+
| GRANT USAGE ON *.* TO 'kwame'@'192.168.100.%' IDENTIFIED BY PASSWORD '*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19' |
| GRANT ALL PRIVILEGES ON `db1`.* TO 'kwame'@'192.168.100.%'                                                       |
+------------------------------------------------------------------------------------------------------------------+
2 rows in set (0.00 sec)

mysql> select user,host from mysql.user;
+-------+--------------------+
| user  | host               |
+-------+--------------------+
| root  | 127.0.0.1          |
| kwame | 192.168.100.%      |
|       | localhost          |
| root  | localhost          |
|       | workvm.pythian.com |
| root  | workvm.pythian.com |
+-------+--------------------+
6 rows in set (0.00 sec)

mysql>

4. Confirm the access is working only from the expected source:

[kwame@workvm ~]$ ifconfig | grep 'inet addr' | grep 100
          inet addr:192.168.100.194  Bcast:192.168.100.255  Mask:255.255.255.0
[kwame@workvm ~]$ mysql -u kwame -p -h 192.168.100.194
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 13
Server version: 5.1.73 Source distribution

Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show grants;
+------------------------------------------------------------------------------------------------------------------+
| Grants for kwame@192.168.100.%                                                                                   |
+------------------------------------------------------------------------------------------------------------------+
| GRANT USAGE ON *.* TO 'kwame'@'192.168.100.%' IDENTIFIED BY PASSWORD '*2470C0C06DEE42FD1618BB99005ADCA2EC9D1E19' |
| GRANT ALL PRIVILEGES ON `db1`.* TO 'kwame'@'192.168.100.%'                                                       |
+------------------------------------------------------------------------------------------------------------------+
2 rows in set (0.00 sec)

mysql>

Tweet This Post

Como convertir en VirtualBox un disco VDI dynamic a VDI fixed

2014-06-17T23:06:28+00:00

Introducción Tengo una máquina virtual que cree para realizar algunas pruebas de integración con una red y sistemas homogeneos, está VM la cree usando un disco duro virtual dinámico, lo cual para las pruebas fue bien, sin embargo, la VM la estoy usando cada vez más y noto que está algo lenta. Usando programas de línea de [...]

Como instalar las herramientas de desarrollo en sistemas GNU/Linux

2014-06-04T13:57:35+00:00

Si te encuentras en la situación en la que tienes que instalar algún programa desde las fuentes, tendrás que tener instalados los programas y herramientas para compilar e instalar programas desde las fuentes o incluso para programar. En lugar de tener que instalar programa por programa, uno a uno, mejor instalaremos los grupos de paquetes que [...]

Control de consolas HP ILO3 desde IPMITool en GNU/Linux

2014-05-30T19:17:04+00:00

Introducción En este articulo hablare un poco sobre IMPI, IPMItool y conexiones de administración out-of-band a las consolas ILO de servidores HP. IMPI o Intelligent Platform Management Interface es una interfaz estandarizada usada por administradores de sistmeas para administración out-of-band de equipos de computo y monitorización de la operación. Permite administrar computadoras que pudieran estár apagadas o [...]

Como usar un disco duro externo USB en sistemas GNU/Linux como medio de almacenamiento adicional basado en LVM

2014-05-19T16:45:22+00:00

Introducción Actualmente uso una Laptop con dos discos duros internos, un disco es SSD de 32 GB que uso para almacenar el sistema operativo Kubuntu 14.04, y un disco SATA de 500 GB que uso para almacenar datos personales. El disco de datos ya esta llegando al 80% de su capacidad máxima, por lo que es buen tiempo [...]

The Heartbleed Bug

2014-04-08T17:21:25+00:00

Today we woke up with a very fun and interesting news made public here http://heartbleed.com/

heartbleed

In short what this means is that all internet, IM, email and vpn communications that you thought where encrypted and secured, they are not. This is related to a bug in the OpenSSL software used to encrypt such communications.
Even more interesting is that according to this report, if your server was compromised there is no log or any evidence that it ever happened.
The OpenSource community is actively releasing patched to address this bug.
So, if you where p3wn3d, don’t worry about it, nobody will ever know it, not even your self

Patch and keep safe!

Cheers!

Tweet This Post

A lightweight screen locker

2014-03-31T23:39:47+00:00

For a long time I’ve been using Awesome as my window manager and Xscreensaver (by Jamie Zawinski) has been my screensaver of choice.
Recently I started looking for something even more lightweight than Xscreensaver and I found i3lock.
i3locki3lock is a simple screen locker like slock. After starting it, you will see a white screen (you can configure the color/an image). You can return to your screen by entering your password. To install it on your Debian system all you need to do is an:

apt-get install i3lock

I would recommend to install xautolock. This is a program to start up programs in case of user inactivity in X.
After you’ve installed both programs you can set the timer for i3lock to start up with something like this:

xautolock -time 5 -locker i3lock

Taking a look at the options from i3lock I saw that I can specify an image instead of the default white color. I chose a Linux wallpaper with this option:

xautolock -time 5 -locker "i3lock --image=/home/kwame/Pictures/linux_wallpaper.png -t"

Hope you find this useful.

Tweet This Post

FOSDEM 2014

2014-02-16T08:00:00+00:00

What up! In this post I will talk about my experiences at my first FOSDEM. FOSDEM (Free and Open source Software Developers' European Meeting) is the biggest open source event in Europe; It is celebrated every year in Brussels. Now that I'm living in Europe, I added that event into my calendar since the moment I knew about it.

My trip there was only possible thanks to Fedora, who sponsored my trip. The first day I arrived, I was confident that I would know how to arrive to the hotel using my phone's GPS, but when I arrived to the train station, Murphy's law came into action and made me be without internet =/, so I asked some policemen at the station and they told me to go in some direction. So I began walking through Brussels until I found out I was somehow lost in the city center. I decided to ask some locals, and when I did, those "locals" were also foreigners coming to FOSDEM, but they were heading to some bar where the preFOSDEM party was going on, so I decided to go with them. There I met a lot of people (and also drank a couple of beers), but what I liked the most was seeing some old friends from the States. After the bar I managed to find my hotel.

The first day at FOSDEM I went directly to the Fedora booth, were I met a lot of european Fedora and Red Hat folks. Between the stuff we brought to the booth, the thing that most attracted people were some 3D printers. And what do 3D printers have to do with Fedora? Well, Fedora has one spin called Fedora 3D printing, where we can find a lot of CAD programs and other design tools to use in regular 3D printers. I was there the first day all the morning helping at the booth. After noon, I went with some friends to give a round at the expo room. There were many FLOSS projects, and what I liked the most: hardware projects. Being an embedded systems guy hardware for me is one of the best things I could see there. That night I went out with the Red Hat guys and I manage to know them more.

The second (and last) day, I was mostly working at the Fedora booth, where I met a lot of people interested in the project, and we also heard some cool stories of them using Fedora. I also went to the Mozilla booth and met a lot of the Mozilla folks. I am also a Mozilla Reps, so meeting them was of great pleasure for me. I discussed with them about different topics, and I really liked seeing a lot of young people volunteering in the Mozilla project. I would be really glad to see a lot of teens volunteering in the Fedora project. At the end of the day, I had dinner again with the Fedora/Red Hat people, and I heard lots of cool stories about FLOSS and off-topic with them.

FOSDEM I don't think is just about going to conferences and getting free stuff, but most importantly of meeting the people with who you work with, the people who volunteer on other projects, or even people that barely knows about FLOSS but are beginning to get interested on it. I really want to be there next year again, and see my friends and make new ones. Thanks again to Fedora, and I am really glad I'm contributing to it (:

Enable hardware acceleration in Chrome/Chromium

2014-01-16T08:00:00+00:00

What up! Thanks to one of the blogs I follow (LINUXMANR4) I found a way to enable hardware acceleration in chromium. It is just quick and easy.

In any tab in chromium we should write chrome://flags, and enable the option that says Override software rendering list, and then restart the browser. That's all! You can check that it worked by going in any tab to chrome://gpu, and there most of the options should be green and saying "Hardware accelerated" ;)

Habilitar aceleración por hardware en Chrome/Chromium

2014-01-13T08:00:00+00:00

Qué ondas! Gracias a uno de los blogs que sigo (LINUXMANR4) encontré la forma de habilitar la aceleración por hardware para chromium! Es fácil y rápido:

En alguna pestaña de chromium escribimos lo siguiente: chrome://flags, y habilitamos la especificación que dice Override software rendering list (en español dirá algo como: Cancelar la lista de renderización del software), y reiniciamos el navegador y listo! puedes comprobar que la aceleración por hardware está funcionando accediendo en alguna pestaña a: chrome://gpu, y ahí la mayoría de especificaciones nos deberán de aparecer en verde y diciendo "Hardware accelerated".

El problema de la liebre

2014-01-10T21:34:35+00:00

Tendria yo como unos 10 años cuando leí el siguiente acertijo en un libro llamado “A jugar con los números”:

Una liebre pesa 10 libras más la mitad de su peso. ¿Cuál es el peso de la liebre?

Inmediatamente llegué a una respuesta: 15. Busqué la solución al final del libro y decía simplemente:

20 libras (y no 15 como era de esperar).

Ni una palabra más ni una palabra menos.

Pregunté a algunos adultos muy pacientes y algunos también decían que 15. Si alguien me dijo que 20 fue por usar alguna herramienta matemática (seguramente álgebra, pero yo ni si quiera sabía lo que era).

Cuando aprendí álgebra la ecuación resultó obvia:

p = 10 + p/2

Y manipular la ecuación para dejar sola la p es fácil: primero se multiplica todo por 2:

2p = 2*10 + 2p/2

2p = 20 + p

Y se le resta p a todo:

2p – p = 20 + p – p

p = 20

Bien, ya tengo la respuesta. Confirma que mi intuición estaba mal. Pero no me quedo agusto si hay una discrepancia entre la realidad y mi interpretación de la realidad. Ahora, ¿cómo corregir mi intuición? ¿Dónde estaba el error? ¿Podía haberlo comprendido yo, de niño, sin conocimiento de álgebra?

Otros aspectos del mismo problema

El problema resonó en mi cabeza mucho tiempo y con el tiempo fui descubriéndole puntos de análisis según diferentes aspectos hasta volverse en uno de mis favoritos.

Me gusta porque es un problema que no es matemáticamente difícil. Es la interpretación e intuición lo que estamos retando. Permite discutir el análisis sin tocar el álgebra y es un problema fácil de captar.

El problema tiene algunos aspectos desde los que se pueden sacar diferentes conclusiones. La simplicidad matemática del problema permite describir cada aspecto en pocas líneas y además relacionarlos todos. Esto permite que podamos pulir nuestro proceso de pensamiento.

El aspecto lingüístico

El ser humano tiende a dividir los problemas en partes. Es más fácil, práctico y supongo que hasta forma parte de nuestra evolución, pero no todos los problemas son divisibles y este es uno de ellos.

En este problema el principal reto es la frase “una liebre pesa 10 libras”, la cual implanta una asociación (errónea) textual: la liebre pesa 10 libras. Con el problema dividido y un punto de partida: si pesa 10 libras, la mitad de su peso es 5 libras, entonces son 15 libras. De ahí llegamos a la respuesta incorrecta.

En realidad el problema no dice que pesa 10 libras, sino 10 libras más la mitad de su peso.

Sin embargo, es curioso lo que ocurre si redactamos el mismo problema de otra manera:

Una liebre pesa la mitad de su peso más 10 libras.

La asociación errónea desaparece más fácilmente. Matemáticamente sigue siendo una ecuación equivalente (en esencia, la misma),

p = p/2 + 10

porque bien sabemos que 5+8 = 8+5 por la propiedad conmutativa de la adición.

Estuve platicando con alguien que batalla con este problema y al explicarle el planteamiento invertido me dijo: pero es que ahora no sé cuánto pesa la liebre. Es decir, la asociación desapareció pero permaneció la expectativa de algún dato como punto de partida. Esto pudo haber ocurrido sólo por que la discusión previa del problema en su forma original dejó una estructura mental donde extistía este dato de partida y se convirtió en un cabo suelto.

Me pregunto qué pasaría si a dos grupos numerosos de niños se les pone el problema de manera independiente, sin conocimiento previo del mismo en ambas versiones. Me pregunto que ocurrirá si una vez dado suficiente tiempo, se le plantea a cada grupo la correspondiente inversión.

Me pregunto qué pasaría si repetimos el experimento con adultos que no tienen preparación algebraica.

El aspecto lógico

¿Es posible darse cuenta al hacer la errónea asociación, p = 10, de que se está cometiendo un error?

Puesto que el problema consiste en encontrar el valor de p, el problema estaría resuelto al saber que p = 10. Entonces la liebre ya no puede pesar otra cosa. Con la asociación hecha se vuelve absurdo decir que la liebre pesa 10 + algo, porque entonces p milagrosamente dejaría de valer 10 para pasar a valer 15. Esto es una contradicción lógica al tomar dos valores simultáneamente.

Trayendo este análisis lógico a lo físico: si uno coloca la liebre en una báscula, la lectura siempre será la misma:

Si la báscula marca 10, entonces 15 es una respuesta incorrecta puesto que marcó 10.
Si la báscula marca 15, entonces la mitad de su peso es 7.5 y no corresponde con el problema planteado.

Pero lo cierto es que nunca cambiará simplemente por yo establecer mentalmente su peso. Si eso fuera cierto, entonces la báscula marcaría 10, luego 15, luego 22.5, luego 33.75, y se iría haciendo cada vez más pesada hasta convertirse en un hoyo negro instantáneamente.

De vuelta a lo lingüístico: mentalmente se conjetura que hay una diferencia entre peso original y peso total que surgiría de sumar, misteriosamente, 10 con el otro valor. Pero volviendo a la báscula, peso original = peso total, siempre. Nunca hay dos valores para el peso de la liebre. Por eso este planteamiento es absurdo.

El aspecto de la notación algebraica

Al escribir p = 10 + p/2, cada lado se considera como un todo independiente. En esta notación no cabe lugar a dudas que p ≠ 10 porque claramente se indica otra cosa. Automáticamente, la notación permite establecer el problema real sin ambigüedad y sin artilugios humanos.

Se podría uno cuestionar si la bondad de este lenguaje algebraico radica más en nuestra falta de conocimiento de otras notaciones, es decir, si realmente existe forma de expresar matemáticamente el problema de manera incorrecta, pero al no haberla aprendido en la escuela no tenemos lugar al error. Intentándolo, sólo se me ocurre

(p = 10) + p/2

pero tratando de interpretar la ecuación no logro interpretarla de vuelta a una proposición que pueda ser evaluada o desarrollada. Desconozco si esta notación tenga alguna aplicación en otra rama de las matemáticas. Sinceramente lo dudo porque usualmente se usan las sumatorias para formar series aditivas que son más formales, claras y no son ambiguas.

La solución, sin álgebra

El meollo del asunto: siendo un problema tan simple cómo analizarlo sin depender del álgebra.

Para evitarnos liebres tomemos algo más simple, genérico: una línea, rectángulo, tabla de madera rectangular y vamos a decir que su longitud mide p.
Para describir p a partir de sus secciones podemos usar nuestras manos. Sabemos que p está formado por dos componentes (p/2 y 10) y al ser aditivos y los únicos, ambos deberían abarcar la línea completa.
Es decir, podemos dividir esa línea en dos secciones y describir hasta dónde abarca cada uno de los componentes. Por una parte tenemos 10, que de momento es variable, y por otra tenemos p/2 que sí sabemos hasta dónde abarca: hasta la mitad de la línea.
Finalmente, sabemos que un entero está formado por dos mitades y ambas son exactamente iguales.
Entonces, si una parte es p/2, la otra parte también debe ser una mitad exacta. ¡Esa mitad exacta sólo puede ser el 10! Si una mitad es 10, pues la otra también debe valer 10 y podemos concluir que la línea mide 20.

Nuevo proyecto: Caddeus, un Makefile para TDD en C

2013-12-02T18:26:18+00:00

Caddeus es un Makefile para GNU Make que sirve como plantilla para comenzar el desarrollo de cualquier proyecto en C. Caddeus está liberado bajo una licencia BSD simplificada. Caddeus está hospedado en Github en la siguiente dirección

https://github.com/alvarezp/caddeus

Esta plantilla soporta automáticamente:

Un modelo de desarrollo dirigido por pruebas (TDD): No es un framework sino la construcción de un módulo y su falla temprana sin reconstruir otros módulos ni reejecutar cada pruebas innecesariamente. La regla es muy simple: si tienes un modulo.c, crea otro llamado modulo.t.c y Make automáticamente compilará y ejecutará modulo.t.c automáticamente después y registrará si la prueba pasó. Cualquier modificación al módulo provocará una ejecución nueva de las pruebas de dicho módulo.

Un archivo llamado aplicacion.tt es considerado un script a ser ejecutado tras la compilación de la aplicación final, útil para prueba de integración.

Por defecto, las CFLAGS son muy estrictas, forzando la estandarización y la portabilidad (o la documentación de la falta de portabilidad) desde un principio: -std=c99 -W -Wall -Werror -Wextra -pendatic-errors. Si tu programa falla con estas banderas, intenta #define _GNU_SOURCE al principio de tu módulo y proponte como reto poder eliminar esa definición. Como resultado, tendrás un código de mayor calidad y mejor portabilidad.

Análisis estático automático, cortesía de CppCheck y Clang. Si están presentes en el sistema, todos tus módulos serán automáticamente revisados por CppCheck y Clang, dándote seguridad de un código fuente de mayor calidad.

Análisis automático de ejecución, cortesía de Valgrind. Si está instalado en el sistema, las pruebas unitarias se ejecutarán a través de Valgrind con revisión completa por fugas de memoria.

Todo lo anterior se desactiva automáticamente ante la presencia de un archivo “RELEASE”, lo que permite liberar código sin forzar a que el resto del mundo ejecute las mismas pruebas.

Se pueden establecer timeouts de manera opcional para dejar corriendo el juego de pruebas y si se cae en un ciclo infinito, el consumo del CPU se detenga después de un tiempo establecido.

Se generan automáticamente dependencias de los archivos .c a sus encabezados .h, de modo que al cambiar cualquiera de los encabezados, también se regeneran los módulos que correspondan.

Motivos para deshabilitar JavaScript (video en español)

2013-11-30T21:16:04+00:00

Motivos para deshabilitar JavaScript. Está disponible en HD. Si le dan click al botón de YouTube, cambien la calidad por 720p para que se alcance a ver un poquito mejor la pantalla.

Presentado el 26 de noviembre de 2013 durante la reunión mensual del grupo Tijuana.js.

El audio está un poco fuerte, pero sirvió para poder oir algunas preguntas y comentarios que salieron. Entonces, de nada y sorry.

Asignacion de variables en Bash

2013-11-21T18:00:26+00:00

En Bash, ¿qué diferencia hay entre las siguientes tres instrucciones?

VARIABLE=valor instrucción
VARIABLE=valor; instrucción
export VARIABLE=valor; instrucción

¿Por qué no todas las combinaciones funcionan cuando se invoca Make y por qué no todas las combinaciones funcionan con echo?

Asignar una variable puede afectar a una de dos: al ambiente o a las variables del shell. Pero ¿cuál afecta a cuál? Para acabar de complicar la situación, en algunos casos es un cambio persistente y en otros es un cambio temporal.

Para salir de la duda de una vez por todas y entender con exactitud lo que ocurre, he preparado una dupla de pruebas para cada una de las 3 sintaxis, resultando en 6 combinaciones:

VAR=val env | grep VAR; env | grep VAR
VAR=val; env | grep VAR; env | grep VAR
export VAR=val; env | grep VAR; env | grep VAR
VAR=val echo $VAR; echo $VAR
VAR=val; echo $VAR; echo $VAR
export VAR=val; echo $VAR; echo $VAR

Estas pruebas deberían ser suficientes para salir de la duda. Para asegurar la fiabilidad a las pruebas, cada una la envolví de esta forma, que permitirá, incluso, ver los saltos de línea:

(unset VAR; PRUEBA) | tr '\n' :; echo

Resultados:

	VAR=val instr	VAR=val; instr	export VAR=val; instr
echo $VAR; echo $VAR	::	val:val:	val:val:
env \| grep VAR; env \| grep VAR	VAR=val:	(línea vacía)	VAR=val:VAR=val:

Se concluye lo siguiente:

	VAR=val instr	VAR=val; instr	export VAR=val; instr
Alcance	Sólo para la instrucción especificada	A partir de este momento	A partr de este momento
Ambiente al que afecta	Subproceso	Shell actual	Shell actual y subproceso

Tiene sentido:

En la sintaxis VAR=val instr, la asignación es un prefijo para instr y sólo para instr. Lo interesante es que sólo afecta al ambiente exportado a la instrucción. Es decir, VAR=val echo $VAR no funciona porque la variable la expande Bash mismo antes de asignar el valor val a VAR. En efecto: VAR=val1; VAR=val2 echo $VAR regresa val1.

En la sintaxis VAR=val; instr, el punto y coma efectivamente separa una instrucción de la otra. Es el equivalente de asignar el valor val a VAR antes que cualquier otra instrucción como una acción independiente; es una acción independiente. Esto le da la persistencia del valor tanto en esta sinaxis como en la tercera. Además, Bash, por defecto, no exporta sus variables al entorno. Esto hace que sólo se afecte la instrucción echo… O bueno… en realidad no, no es echo quien se está viendo afectado. Ojo: Echo no recibe la variable en su entorno: es Bash quien está expandiendo la variable a su valor al llamar echo, quien recibe el valor ya expandido como argumento.

La tercera sintaxis, export VAR=val; instr es igual a la segunda: dos instrucciones independientes, con la adición de que la instrucción export, naturalmente interna a Bash, indica que VAR se debe exportar al ambiente de los siguientes subprocesos. Es decir, tanto se asigna como se importa en la misma instrucción. Es por esto que afecta tanto a echo $VAR como a env, Make y lo que se ponga a su paso.

Siendo dos aspectos afectados y dos puntos a combinar podría pensarse que falta una cuarta sintaxis: export VAR=val instr, sin el punto y coma. Sin embargo, esta sintaxis es una simple invocación a export, indicando que queremos exportar las variables VAR e instr.

Referencia rápida de expresiones regulares

2013-11-16T07:25:22+00:00

Como complemento a mi presentación de hoy en la reunión de noviembre del Gultij, publico esta tabla de expresiones regulares.

Observaciones:

Esta tabla no contempla la compatibilidad con POSIX. Por ejemplo, \b es un Perlismo que da la casualidad de que otros lo soportan también. Wikipedia trae información más detallada.
Perl toma algunas consideraciones con los fines de línea (\n). La manera más simple y segura de hacer matching en Perl de forma consistente con los demás motores es hacerle chomp a la línea. Como dicen en los comerciales: se aplican restricciones.

Si le detectan errores, por favor háganmelos saber.

	Perl	GNU Grep	GNU Grep Ext	Gawk	GNU Sed	GNU Sed Ext
Caracteres
Comodín	. (punto)	. (punto)	. (punto)	. (punto)	. (punto)	. (punto)
Juego	[a-z]	[a-z]	[a-z]	[a-z]	[a-z]	[a-z]
Excepto juego	[^a-z]	[^a-z]	[^a-z]	[^a-z]	[^a-z]	[^a-z]
Clase alpha	[:alpha:]	[:alpha:]	[:alpha:]	[:alpha:]	[:alpha:]	[:alpha:]
Clase dígitos	[:digit:], \d	[:digit:]	[:digit:]	[:digit:]	[:digit:]	[:digit:]
Clase controlchars	[:cntrl:]	[:cntrl:]	[:cntrl:]	[:cntrl:]	[:cntrl:]	[:cntrl:]
Clase alnum	[:alnum:]	[:alnum:]	[:alnum:]	[:alnum:]	[:alnum:]	[:alnum:]
Clase visibles	[:graph:]	[:graph:]	[:graph:]	[:graph:]	[:graph:]	[:graph:]
Clase minúsculas	[:lower:]	[:lower:]	[:lower:]	[:lower:]	[:lower:]	[:lower:]
Clase mayúsculas	[:upper:]	[:upper:]	[:upper:]	[:upper:]	[:upper:]	[:upper:]
Clase imprimibles	[:print:]	[:print:]	[:print:]	[:print:]	[:print:]	[:print:]
Clase puntuación	[:punct:]	[:punct:]	[:punct:]	[:punct:]	[:punct:]	[:punct:]
Clase espacios	[:blank:], \h	[:blank:]	[:blank:]	[:blank:]	[:blank:]	[:blank:]
Clase espacios y \n	[:space:], \s	[:space:], \s	[:space:], \s	[:space:], \s	[:space:], \s	[:space:], \s
Clase hexes	[:xdigit:]	[:xdigit:]	[:xdigit:]	[:xdigit:]	[:xdigit:]	[:xdigit:]
Límite de palabra	\b	\b	\b	(no hay)	\b	\b
[_[:alnum:]]	\w	\w	\w	\w	\w	\w
[^_[:alnum:]] (separadores)	\W	\W	\W	\W	\W	\W

Anclas
Inicio	^cadena	^cadena	^cadena	^cadena	^cadena	^cadena
Fin	cadena$	cadena$	cadena$	cadena$	cadena$	cadena$

Calificadores
Agrupamiento	(j)	$j$	(j)	(j)	$j$	(j)
Referencia	\1	\1	\1	(no hay)	\1	\1

Cuantificadores
Cero o más	*	*	*	*	*	*
Cero o uno	?	\?	?	?	\?	?
Al menos 1	+	\+	+	+	\+	\1
Rango	{m,n}	\{m,n\}	{m,n}	{m,n}	\{m,n\}	{m,n}

Operadores
Concatenación	ab	ab	ab	ab	ab	ab
Alternancia	\|	\\|	\|	\|	\\|	\|

Laws of Engineering

2013-11-07T08:00:00+00:00

On my Real-Time Systems book called "Hard Real-Time Computing Systems" by Giorgio C. Butazzo, in the introductory chapter the author writes:

"Due to the relevance that pessimistic assumptions have on the design of real-time systems, Table 1.1 lists the most significant laws on the topic, which a software engineer should always keep in mind".

Table 1.1 is the next one:

Murphy’s General Law
If something can go wrong, it will go wrong.

Murphy’s Constant
Damage to an object is proportional to its value..

Naeser’s Law
One can make something bomb-proof, not jinx-proof..

Troutman Postulates
1. Any software bug will tend to maximize the damage.
2. The worst software bug will be discovered six months after the field test..

Green’s Law
If a system is designed to be tolerant to a set of faults, there will always exist an idiot so skilled to cause a nontolerated fault..

Corollary
Dummies are always more skilled than measures taken to keep them from harm..

Johnson’s First Law
If a system stops working, it will do it at the worst possible time.

Sodd’s Second Law
Sooner or later, the worst possible combination of circumstances will happen.

Corollary
A system must always be designed to resist the worst possible combination of circumstances.

Como copiar archivos con espacios en el nombre usando scp

2013-10-29T20:35:31+00:00

Recientemente tuve la necesidad de copiar un archivo desde un servidor a mi máquina, esto normalmente no es ningún problema, sin embargo, esta vez el nombre del archivo tenía varios espacios, al tratar de hacer la copia con scp esto es lo que aparece: $ scp remote-server:/srv/samba/data01/TI/08 - Example-creds-v6-final.kdb . scp: /srv/samba/data01/TI/08: No such file or directory cp: [...]

CentOS kvm clone no muestra el device eth0

2013-10-05T04:30:06+00:00

Desde ya hace un buen rato estoy utilizando KVM para manejar mis VMs en Linux (ya sea fedora o debian). Tengo una imagen base de CentOS 6 con la cuál, cuando necesito de otra máquina para hacer pruebas, solamente la clono y listo, tengo una máquina list en unos 3-4 minutos para poder hacer las pruebas que necesito.

Una cosa que me molestaba al clonar máquinas es que la interfaz eth0 no es reconocida en el nuevo sistema, siempre tengo eth1. Después de googlear e investigar un poco, esto se debe a que “udev” recuerda los settings de la NIC que fue clonada. Al levantar la máquina recien clonada, busca los settings, específicamente la mac address de la máquina original, pero como en la máquina clonada tenemos un nuevo mac address para la interfaz, entonces udev nombra a esta interfaz como eth1.

[root@centos-lvm ~]# ifconfig -a
eth1      Link encap:Ethernet  HWaddr 52:54:00:04:65:ED  
          inet addr:192.168.0.104  Bcast:192.168.0.255  Mask:255.255.255.0
          inet6 addr: fe80::5054:ff:fe04:65ed/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:116 errors:0 dropped:0 overruns:0 frame:0
          TX packets:53 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:14386 (14.0 KiB)  TX bytes:8810 (8.6 KiB)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:16436  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)

[root@centos-lvm ~]# ls /sys/class/net/
eth1  lo
[root@centos-lvm ~]#

Solucionar esto es realmente sencillo. Solo tienes que modiciar el archivo /etc/udev/rules.d/70-persisten-net.rules de la siguiente manera.

Archivo original:

[root@centos-lvm ~]# cat /etc/udev/rules.d/70-persistent-net.rules
# This file was automatically generated by the /lib/udev/write_net_rules
# program, run by the persistent-net-generator.rules rules file.
#
# You can modify it, as long as you keep each rule on a single
# line, and change only the value of the NAME= key.

# PCI device 0x1af4:0x1000 (virtio-pci)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="52:54:00:bf:b4:70", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"

# PCI device 0x1af4:0x1000 (virtio-pci)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="52:54:00:04:65:ed", ATTR{type}=="1", KERNEL=="eth*", NAME="eth1"
[root@centos-lvm ~]#

Archivo modificado:

[root@centos-lvm ~]# cat /etc/udev/rules.d/70-persistent-net.rules
# This file was automatically generated by the /lib/udev/write_net_rules
# program, run by the persistent-net-generator.rules rules file.
#
# You can modify it, as long as you keep each rule on a single
# line, and change only the value of the NAME= key.

# PCI device 0x1af4:0x1000 (virtio-pci)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="52:54:00:04:65:ed", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"
[root@centos-lvm ~]#

Después de modificar este archivo solo es cuestión de modificar tu /etc/sysconfig/network-scripts/ifcfg-eth0 con su correspondiente mac address, reiniciar tu VM y listo, vas a tener eth0 disponible en tu sistema.

Tweet This Post

Software Libre (presentación en español en el CDTI 2011)

2013-09-30T20:40:06+00:00

Hace dos años presenté sobre Software Libre en el CDTI 2011, en Tijuana (13/ago), en Tijuana, México, en representación del GUL Tijuana (Gultij).

Disculpen las deficiencias en el audio y el video.

Cómo imagino yo JavaScript en la Web

2013-09-17T07:37:55+00:00

Ya todo el mundo sabe que estoy en contra del scripting en documentos. Lo considero uno de los peores errores de la historia computacional. Yo considero que ver datos debe ser una operación segura por naturaleza.

Navegar por la Web es visitar contenido, en esencia datos. ¿Cómo imagino yo una Web segura? Obligando al control del operador antes de la ejecución de JavaScript. Deshabilitando los plugins por completo.

El siguiente es el flujo que quisiera que mi navegador soportara para el uso de aplicaciones Web.

Al visitar el sitio Web, el navegador sólo interpreta el HTML y CSS. No se procesan scripts ni plugins. El sitio Web contiene una etiqueta apuntando hacia la aplicación Web, que es reconocida por el navegador y muestra alguna indicación al usuario como corresponde.

Primero, el usuario visita el sitio Web. El navegador sólo interpreta el HTML y CSS. Los plugins y scripts no son procesados. El sitio Web contiene una etiqueta <link> con una URL apuntando hacia la aplicación Web.

Como ejemplo tomamos a Twitter, con una etiqueta <link rel=”webapp” url=”https://app.twitter.com/”> en el código HTML. El navegador Web muestra un icono o cualquier otra indicación con la que el usuario pueda interactuar (como hacer click) para instalar la aplicación Web. En la imagen, el icono es un círculo con líneas similares a las terminales de un circuito integrado empaquetado QFP.

Este icono y sus funciones relacionadas deberán mantenerse privadas, sin visibilidad de ningún tipo por ninguna API o mecanismos programáticos para terceros.

El sitio Web podría ya sea ofrecer contenidos separados para la página y la aplicación, o mejor aún, usar la técnica de la mejora progresiva para evitar tener que programar dos veces.

Al usuario se le alerta, por medio de una ventana modal o por algún otro mecanismo, sobre los riesgos de instalar una aplicación Web. En esta ventana se le pide al usuario confirmar su decisión.

El usuario hace clic en el icono de la aplicación Web (en el ejemplo, el círulo con terminales QFP) indicando su decisión de instalar la aplicación Web en su escritorio. El navegador alerta al usuario de los riesgos potenciales y pide al usuario confirmar su decisión.

El mecanismo puede ser una ventana modal o cualquier otro que se integre con la plataforma, pero que no permita la instalación hasta que el usuario haya confirmado la instrucción. En la ventana podría (o debería) incluir la URL a instalar y el icono y título con el que el sitio será instalado en el escritorio.

El navegador crea un icono en el escritorio con el que se puede invocar la aplicación Web en todo su esplendor: con JavaScript habilitado, pero con los plugins deshabilitados. Habilitar los plugins requeriría de configuración extra por parte del usuario.

El usuario acepta y reitera su instrucción de instalar la aplicación Web. Se instala entonces un icono en la galería de aplicaciones instaladas (en la imagen, el propio escritorio), con el mismo favicon y título que se usó en el sitio Web inicial. La instrucción es iniciar una instancia en modo “Webapp” de algún navegador que cuente con este modo. El sistema operativo deberá manejar esta asignación, de modo que no sea manipulable externamente. El usuario podría alterar el valor por defecto por medio de alguna interfaz de su sistema operativo.

El usuario invoca la aplicación como cualquier otra. El navegador muestra la ventana de la aplicación Web y permite la total interacción entre el usuario y la aplicación. Google Chromium es un ejemplo de navegador que soporta “modo app”, aunque sólo es un artilegio visual sin diferencias funcionales.

Finalmente, el usuario lanza la aplicación Web de la misma manera en que lanza cualquier otra aplicación. El navegador es lanzado en modo “Web app” con las siguientes características:

No existe una barra de direcciones.
Se permite un nivel (hasta donde sea seguro) de integración con el escritorio. Esto podría permitir la integración de las notificaciones de Facebook con la bandeja de notificaciones de GNOME, por ejemplo.
JavaScript está habilitado para el dominio en cuestión, y se mantiene la aplicación de la política de “mismo origen”. Por defecto, se usará el “modo estricto” y el usuario podrá alternar entre el modo “estricto (más seguro)” y el modo “relajado (menos seguro)”.
Hacer clic con el botón secundario mostraría un menú en dos secciones: la sección que ofrece las funciones típicas del navegador: atrás, adelante, imprimir, zoom, etc. y la sección donde la aplicación inserta sus propios elementos. Ambas secciones podrían aparecer en el mismo menú, aunque sería mejor idea que la sección del navegador apareciera en un submenú propio, digamos, con el texto “Navegar »”.
La ventana de la aplicación deberá correr en su propio espacio de memoria y ambiente, es decir, en su propio sandbox.
El navegador no permitirá la visita de dominios ajenos a la aplicación Web. Hacer clic en enlaces hacia dominios independientes invocan al navegador en su modo de “sólo datos”, como se describía en el paso 1.

Cómo agregar correctamente el DRAE y el DPD como motores de búsqueda en Chromium

2013-07-16T00:12:44+00:00

La Real Academia Española ofrece una consulta en línea de su Diccionario de la Lengua Española, Vigésima segunda edición así como de su Diccionario Panhispánico de Dudas, Primera edición.

Estas búsquedas funcionan de una manera extraña. Entre el uso de JavaScript, el desajuste de codificación de caracteres y la inhabilidad de Chromium de editar esta codificación por medio de la interfaz gráfica, la única forma de realmente hacerlas funcionar plenamente (con acentos) es la siguiente:

Entrar a la Real Academia Española.
En la sección derecha, en la búsqueda, hacer clic derecho sobre el cuadro de búsqueda del Diccionario de la Lengua Española y escoger “Agregar como motor de búsqueda…”
Cambiar la palabra clave por alguna de nuestro gusto. En mi caso: drae
Cambiar la URL por http://lema.rae.es/drae/?val=%s

Para el DPD el procedimiento es el mismo pero con diferente URL:

Entrar a la Real Academia Española.
En la sección derecha, en la búsqueda, hacer clic derecho sobre el cuadro de búsqueda del Diccionario Panhispánico de Dudas y escoger “Agregar como motor de búsqueda…”
Cambiar la palabra clave por alguna de nuestro gusto. En mi caso: dpd
Cambiar la URL por http://lema.rae.es/dpd/?key=%s

Con esto ya es posible usar las claves drae y dpd directamente sobre la barra de direcciones para buscar en estos diccionarios usando Chromium.

Sugiero comprobar el funcionamiento con la palabra guión, tanto en el DRAE como en el DPD.

Aplausos.

Como ejecutar un programa automáticamente al inicio de KDE

2013-06-24T20:33:51+00:00

En el mundo de Linux y el shell bash es bien sabido que que es posible ejecutar programas al inicio de sesión a través de los archivos .bash*, para login-shells se usa .bash_profile y para non-login shells se usa .bashrc. Pero para ejecutar algún programa gráfico al inicio de sesión en KDE es otra cosa, para [...]

Como deshabilitar el mouse Touchpad en Ubuntu

2013-06-20T22:48:04+00:00

Cuando trabajamos en alguna laptop por default se habilita el mouse touchpad, hay quienes les gusta usarlo, y hay quienes prefieren usar un mouse externo USB. En algunos casos he visto que el mouse touchpad es muy sensible e interfiere cuando tecleamos, se brinca el puntero a lugares que no queremos. Para deshabilitar el mouse touchpad de [...]

RAID & LVM Screencast

2013-05-27T22:28:36+00:00

Este fin de semana grabé un nuevo screencast, al igual que los anteriores, relacionado con Linux y Software Libre. En esta ocasión, hablo de RAID y LVM.
La url es http://vimeo.com/67086457
Pásenle a escucharlo y enviar sus comentarios.

Tweet This Post

Screencast – Administración básica de MySQL con Fedora 18

2013-05-20T15:48:42+00:00

En días anteriores platicando con un padawan linuxero me comentaba que se le estaba haciendo algo difícil el utilizar MySQL en Fedora 18.

Para ayudarle un poco grabé este screencast de administración básica de MySQL con Fedora 18

Tweet This Post

Posts 2012

2013-04-29T04:09:55+00:00

Si, desafortunadamente los 8 posts que había escrito en el 2012 los perdí por no haber tenido un respaldo actualizado de la base de datos de mi blog.
Lección aprendida.

Actualmente estoy ya un poco más normalizado de carga de trabajo, se me hace increíble que ya estoy cerca de cumplir 9 meses trabajando en Pythian. Tengo ya en mi borrador los temas que quiero tomar en mis siguientes posts, podcasts y screencasts.

Estoy seguro que este 2013 va a ser un año en donde voy a retomar mi vocación bloggera.

Saludos!

Tweet This Post

SCALE 11x

2013-03-02T08:00:00+00:00

El fin de semana pasado, del 22 al 24 de marzo, se realizó la 11va edición del Southern California Linux Expo (Expo de Linux del Sur de California, SCALE para abreviar). Es la primera vez que yo asisto a este evento, y también el evento más grande al que yo he asistido (aprox 2300 personas). El evento es en Los Ángeles, California, y son varias conferencias simultaneas durante todo el día. Las conferencias las hay de diversos temas, desde niveles muy básicos como qué es linux, cómo pedir ayuda en la web, hasta talleres y temas avanzados como secure boot, git, impresoras 3D, y muchas más! Fueron alrededor de 90 conferencias ;) También hubo varios Birds of Feather, que para los que no sepan, un birds of feather son reuniones informales que se hacen para platicar sobre algún tema. Por mencionar algunas, hubo de Raspberry Pi, de Programación Funcional, de Open Cloud, de ideas sobre instalación de paquetes desde la red, entre muchas otras.

Aparte de todo esto, hubo dos grandes auditorios en los que hubo exposición de varias empresas y comunidades, como HP, Mozilla, VideoLAN, System76, Canonical, entre muchas otras. Obviamente también hubo una de Fedora, y es ahí donde estuve yo participando. Fue mi primera experiencia en un evento grande estando yo en el booth de Fedora, y les diré que fue una muy genial experiencia. Conocí otros embajadores, como a douglax, vwbusguy, herlo, suehle, y a nuestra amada líder, rbergeron. Me dió mucho gusto conocer a todos :D En el booth teníamos dos o tres computadoras corriendo Fedora 18, dos Raspberry Pi corriendo Fedora Raspberry Pi Remix, y una XO de la OLPC (One Laptop Per Child). Aparte de swag dimos calcamonías, DVDs, camisetas y gorras.

La participación fue enormemente buena. No hubo un sólo momento en el que no hubiera gente en el booth. En uno de los Raspberry Pi estábamos corriendo un emulador de SNES con el Super Mario Bros. 2. Esto fue un hit para los niños (es correcto, había varios padres geeks que llevaron a sus hijos al evento, bien papás y mamás! you are doing it right!) y también para los no tan niños (como yo :P ). También llegó mucha gente muy emocionada que llegaba y nos decía que ellos llevaban usando Fedora durante bastante tiempo. Algunos cuantos llegaban con sus laptops y nos pedían ayuda de algunos problemas técnicos que tenían, de los cuáles muchos eran problemas de gnome o kde :P pero igual les ayudábamos (: Y como no podía faltar, también llegó mucha gente que se quejaba de algunas funciones o características de Fedora. Creo que lo que más quejas recibió fue el nuevo instalador de Fedora (creo que es una versión nueva de anaconda), que siendo honestos a mi tampoco me gustó mucho =/ Algunas otras quejas fue que algunos no podían instalar Fedora con secure boot activado, que no les funcionaba cierta característica de su compu (en las cuales tratamos de ayudar y logramos arreglar algunas cosas), y algunos detalles menores.

Entre las cosas positivas que nos dijeron es que fuimos de los más amables y platicadores de los booths, que somos una distro muy buena que siempre hay alguien dispuesto a ayudar (no estoy mintiendo), que el swag que dimos era muy bueno, entre muchos otros cumplidos (: Se hace también como un concurso de booths, de cuál es la que da el mejor swag (que ganó HP porque dieron cerveza :P ), los de mejor disfraz, y algunas otras categorías. Fedora ganó mención honorable debido al trato con la gente :) así que bien fedora! Pero lo que a mi más me llamó la atención, fueron dos niñitas que llegaron (una como de 7 años y la otra como de unos 4),., iban cargando sus mochilas de barby, y una de ellas viene y me dice con su linda voz (en inglés): Yo uso fedora todo el tiempo, mi papá nos los instaló, y jugamos y hacemos muchos dibujos". Me sentí tan conmovido por la niña, que fui a buscar a su papá y lo felicité con todas las ganas del mundo, y él me respondió: Yo sólo les enseño lo que pueden hacer, y ellas son las que quieren quedarse con ello". Es un muy buen ejemplo de que Linux no es lo difícil que solía ser antes, y que incluso niños lo usan para diferentes fines. Me sentí muy feliz con esto :D

También hubo un momento en el que llegó un señor con sus dos sobrinos (como de unos 20 años). Iban vestidos muy extravagantes al estilo country boys mezclado con gitanos jaja, una vestimenta muy rara y a la vez genial. Empezaron a tocar justo enfrente de nuestro booth. El señor tocaba el cerrucho (así como lo oyen, el cerrucho), y los sobrinos uno tocaba la mandolina y el otro el teclado. Tocaban música muy alegre. Justo unos instantes después llegó vwbusguy con su mandolina y empezó a acompañarlos, y no mucho después me prestaron el teclado (el del teclado agarró una especie de alcancía y le pegaba con un palito de madera) y empezamos a jamear. Mucha gente se acercó a oir y muchos incluso nos grabaron. Fue algo bien genial!!!!

También me tocó conocer mucha gente de Red Hat, que para mi fue un honor, ya que Red Hat es una de las empresas en las que me gustaría trabajar, por las cosas que hacen y por que son una empresa púramente de Software Libre. En fin, si quieren saber más sobre las conferencias que hubo, ver algunos videos y otras cosas, el link de SCALE11x es: http://www.socallinuxexpo.org . Es un evento que se hace cada año, y lo recomiendo mucho! así que si van,., nos veremos ahí el siguiente año!

Muchas gracias al Proyecto Fedora por patrocinarme el viaje :) espero poder asistir a muchos eventos más! un saludo a todos!

En el siguiente video, el booth de Fedora es el que más se ve: el más cercano de la esquina vienod hacia acá.