Probé poniendo la opción Options “DPMS” “false”, configurando la X usando xset para desactivar la opción de ahorro de energia y tambien probé con vbetool, pero ninguna me dio resultado.

Buscando y buscando, encontré que existen dos opciones: DPMS y ScreenBlanking.

ScreenBlanking: Es un “apagado de pantalla/monitor” de mentira, hace que la pantalla se “apague” y se ponga negra, pero realmente sigue prendida, por lo que solamente le baja el brillo. Por defecto está seteado en 10 minutos.

DPMS: Esta es una función real del manejo de energia para las pantallas. Por defecto pasa a un estado “StandBy” luego de 20 minutos, “Suspend” luego de 30 minutos y “Off” luego de 40.

Para manejar las configurar los parametros de estas opciones podemos hacerlo mediante la configuración de la X o usando xset.

Si ejecutamos xset -q podemos ver la configuración actual:

Keyboard Control:
auto repeat:  on    key click percent:  0    LED mask:  00000000
XKB indicators:
00: Caps Lock:   off    01: Num Lock:    off    02: Scroll Lock: off
03: Compose:     off    04: Kana:        off    05: Sleep:       off
06: Suspend:     off    07: Mute:        off    08: Misc:        off
09: Mail:        off    10: Charging:    off    11: Shift Lock:  off
12: Group 2:     off    13: Mouse Keys:  off
auto repeat delay:  660    repeat rate:  25
auto repeating keys:  00ffffffdffffbbf
fadfffefffedffff
9fffffffffffffff
fff7ffffffffffff
bell percent:  50    bell pitch:  400    bell duration:  100
Pointer Control:
acceleration:  2/1    threshold:  4
Screen Saver:
prefer blanking:  yes    allow exposures:  yes
timeout:  0    cycle:  600
Colors:
default colormap:  0×20    BlackPixel:  0    WhitePixel:  16777215
Font Path:
/usr/share/fonts/misc,/usr/share/fonts/100dpi:unscaled,/usr/share/fonts/75dpi:unscaled,/usr/share/fonts/TTF,/usr/share/fonts/Type1,/usr/share/fonts/misc/,/usr/share/fonts/TTF/,/usr/share/fonts/Type1/,/usr/share/fonts/100dpi/,/usr/share/fonts/75dpi/,built-ins
DPMS (Energy Star):
Standby: 600    Suspend: 600    Off: 600
DPMS is Disabled
Font cache:
Server does not have the FontCache Extension

Fijarse en la sección “DPMS”, aparecen tres valores, standby, suspend, off que estan seteados en 600 segundos, es decir, 10 minutos. Para configurar estos valores debemos hacer lo siguiente:

xset dpms 300 600 900
El primer número corresponde a Standby, el segundo a Suspend y el tercero a Off. Para desactivarlo podemos dejarlo en cero:
xset dpms 0 0 0
Tambien podemos desactivar directamente el DPMS con
xset -dpms
Y para activarlo cambiamos el signo menos (-) por un signo mas: +

Si desactivamos DPMS veremos que seguirá apagandose el monitor, pues debemos desactivar (o aumentar el valor) de ScreenBlanking.

xset s 0
Seteamos el valor a 0 (desactivado).

Para más información les recomiendo el siguiente link (fue el que me ayudó a mi):

http://www.shallowsky.com/linux/x-screen-blanking.html

Compartir/Guardar

Lo más comun, y que me da muca risa y aveces rabia, y me desespera un poco, es ver como los usuarios avanzan lentamente, directorio por directorio, hasta llegar a la destino final. Por ejemplo:

$ cd /
$ cd home
$ cd usuario
$ cd public_html
$ cd includes

En lugar de ejecutar directamente
$ cd /home/usuario/public_html/includes

Y peor aun, hay veces que el usuario es inseguro y prefiere verificar si lo hizo bien y termina su caminata por los directorios haciendo un “pwd”:

$ cd /
$ cd home
$ cd usuario
$ cd public_html
$ cd includes
$ pwd
/home/usuario/public_html/includes
$

Hay algo que me desespera aun mas, es cuando el usuario tiene la necesidad de listar el contenido de CADA directorio:

$ cd /
$ ls -l
$ cd home
$ ls -l
$ cd usuario
$ ls -l
$ cd public_html
$ ls -l
$ cd includes
$ pwd
/home/usuario/public_html/includes
$ ls -l

Para los que no saben, para esto existe un truco (tip!), no digo que se aprendan los directorios de memoria, pero pueden ejecutar todo en una sola linea, por ejemplo, cuando escriben / pueden presionar tabular dos veces y automaticamente aparecerá el listado de archivos y directorios dentro de /. Asi mismo, si escriben /home/ y dos veces tabular, veran todo el contenido de /home, sin tener que ejecutar cd /home, presionar enter y luego un ls.

Otra cosa que es muy comun, aunque no lo crean, es encontrar las passwords de las bases de datos, especialmente de MySQL. La gente está acostumbrada a ejecutar el comando mysql para conectarse a la base de datos pasandole como parametro el usuario y la password

$ mysql -uproduccion -p4gSg4ws -hlocalhost mydatabase
mysql>

Tambien usan esta misma tecnica para generar los típicos respaldos usando mysqldump.

$ mysqldump -uproduccion -p4gSg4ws -hlocalhost mydatabase >>mydatabase.sql

Obviamente esto es un problema de seguridad, ya sea porque no se educó bien al usuario o simplemente porque no existen medidas de seguridad dentro del contexto donde se está ejecutando este tipo de comandos.

Tambien es muy usual encontrar a usuarios que intentan pasarle la password de root al comando “su”, ejecutando comandos tipo:

$ su - 354dr2

Pensando que 354dr2 es la password de root, al igual que

$ sudo su - password_del_usuario

Pensando que de esa forma no le pedirá el password. Lo que no sabe el usuario es que todo lo que ejecuta esta siendo logueado y que está comprometiendo la seguridad del servidor.

El .bash_history o historial de comandos bash, muestra mucho como trabajan los usuarios, qué hacen y de qué forma lo hacen, de esta forma es posible obtener información sobre algun sistema o servicio que esté corriendo en el servidor, por ejemplo si entramos a la mala a un servidor y queremos buscar información privada o información que nos interese, podemos ver el historial de los usuarios para saber qué hacen, por donde se mueven y seguir sus pasos.

Un dia me tocó ver que un usuario tenia un script “escondido” que se conectaba vía llave pública a 4 o 5 servidores (incluyendo uno fuera de la red), obviamente, la llave privada estaba en el servidor donde yo estabam por lo que pude acceder a todas sus cuentas en los otros servidores.

Compartir/Guardar

Por twitter me recomendaron varias opciones. @Apostols me recomendó las herramientas “puppet” y “rlbackup”, mientras que @ssugasti “mondorescue”, pero yo seguia con mi idea de usar directamente “dd”. Debía hacer el mismo procedimiento en mas de 40 servidores, por lo que usar una aplicación “cliente->servidor” no era mi solución. Usar aplicaciones que requieran modo grafico o que requieran mucha interacción con el usuario tampoco me servian, yo necesitaba algo automatizado que pueda dejar corriendo de noche y volver al otro día y encontrar el trabajo hecho.

Leyendo el manual de LVM, especialmente el de lvcreate, encontré la opción “snapshot” que básicamente le toma una “foto” al volumen lógico de origen y crea un nuevo volumen con ese preciso instante en que se hizo el snapshot, de ésta forma la partición original podrá ser actualizara mientras que el snapshot se respalda sin problemas. Luego de eso, el snapshot se elimina y se guarda la imágen. La rutína sería mas o menos asi:

# lvcreate --snapshot /dev/Vol00/var --name var-snap -L100k
# dd if=/dev/Vol00/var-snap of=/backup/var.img
# lvremove -f /dev/Vol00/var-snap

De esta forma, creamos un snapshot llamado “var-snap” en base a la partición (o volumen) /dev/Vol00/var, luego, usando dd, creamos la imágen de dicha partición y la guardamos en /backup. Finalmente eliminamos el snapshot.
Para tener aún más certesa de que todo funcionaría, tambien decidí empaquetar, comprimir y guardar los ficheros, por lo que antes de eliminarla (lvremove) la debo montar y hacer un tar. La rutina quedaría así:

# lvcreate --snapshot /dev/Vol00/var --name var-snap -L100k
# dd if=/dev/Vol00/var-snap of=/backup/var.img
# mount /dev/Vol00/var-snap /mnt
# tar cfjv /bakcup/var.tbz2 /mnt
# umount /mnt
# lvremove -f /dev/Vol00/var-snap

En mi caso, /backup corresponde a un punto de montaje de red NFS.
Mi misión era realizar ésta misma rutina en más de 40 servidores, por lo que necesitaba hacer un script que se paseara por todos los servidores y ejecutara estos comandos.

#!/bin/bash

IDENTITYFILE=$HOME/.ssh/id_rsa
MACHINES=servidores.list
DATE=$(date +%d%m%Y)
NFS=/mnt/imagenes/servers/
DIR_SNAPSHOT=/mnt/snapshot

for server in $(cat servidores.list);
do
        echo "Respaldando $server ..."
        ssh -i $IDENTITYFILE $server "lvdisplay" >/tmp/lvdisplay_temp
        lvdisplay=$(awk '
                /LV Name/ { name = $3 }
                /VG Name/ { print name","$3 } ' /tmp/lvdisplay_temp)
        for _logicalv in $lvdisplay;
        do
                lvname=$(echo $_logicalv |cut -f1 -d ","|cut -f4 -d "/")
                logicalv=$(echo $_logicalv |cut -f2 -d ",")
                echo -e "\tVolumen Logico: $lvname"
                ssh $server "lvcreate --size 100m --snapshot --name $lvname-snap /dev/$logicalv/$lvname"
                ssh $server "mount /dev/$logicalv/$lvname-snap $DIR_SNAPSHOT"
                ssh $server "mkdir $NFS$server"
                ssh $server "tar cfj $NFS$server/snapshot_$lvname-$DATE.tar.bz2 $DIR_SNAPSHOT"
                ssh $server "umount $DIR_SNAPSHOT"
                ssh $server "dd if=/dev/$logicalv/$lvname-snap of=$NFS$server/image_$lvname-$DATE.img"
                ssh $server "lvremove -f /dev/$logicalv/$lvname-snap"
                echo -e "\tArchivo imagen: $NFS$server/image_$lvname-$DATE.img"
                echo -e "\tArchivo tarball: $NFS$server/snapshot_$lvname-$DATE.tar.bz2"
        done
done
scp /tmp/lvdisplay_temp $server:$NFS$server/lvdisplay

El script trabaja con la salida del comando lvdisplay que entrega una salida con los detalles de cada volumen lógico. Lee un fichero llamado servidores.list y hace un recorrido línea por línea, conectándose a cada servidor y ejecutando las instrucciones necesarias. Para hacer el proceso más eficiente y automatizado es necesario, previamente, copiar todas las claves públicas a cada servidor, para evitar la autentificación.

Compartir/Guardar

Luego de haberles comentado lo que estábamos preparando junto a la gente del HacklabCL y luego de varias reuniones y discusiones, ya hemos puesto fecha a nuestra primera jornada oficial de difusión de la filosofía del software libre.
Se llevará acabo en Kernelhouse el día miércoles 20 de Enero a las 20:00 horas. Los temas a tratar son introducción a los conceptos y paradigmas del software libre, respeto hacia la voluntad del autor, libertad tras las licencias populares y un tema bastanta particular titulado “tangibles e intangibles”.

Compartir/Guardar

Y luego me puse a probar distintos emuladores y juegos de consolas: NeoGeo, MAME, SNES, N64, PSX, etc.

Para emular juegos de NeoGeo tenemos el gngeo y el mame-sdl, para snes el famoso zsnes, para n64 mupen64 y para psx el epsxe.
A continuación, una pequeña muestra de cada emulador corriendo algún juego en especial.

Primero les voy a mostrar gngeo con su frontend XGngeo

Para descargarlo pueden encontarlo en su sitio oficial http://gngeo.berlios.de/ o bien buscarlo en los repositorios de la distribución que estén usando. Pueden descargar el frontend XGnGeo desde aquí: http://www.choplair.org/?XGngeo

Con el emulador de MAME puedes jugar tambien los juegos de neogeo. Para emular mame tienes el emulador por línea de comando “mame-sdl” y el frontend llamado qmc2.

Para emular súper nintendo, uso el conocido zsnes (muuuuy antiguo), que está en la mayoría de los repositorios de las distribuciónes GNU/Linux y también lo podemos encontrar en zsnes.com.

Yo recuerdo haber usado este mismo emulador hace muchos años atrás, era uno de mis preferidos, con zsnes pasé varias horas frente al pc jugando. El emulador permite configurar hasta 5 players y además, permite jugar en línea.

Para PlayStation 1 (PSOne, PSX) uso el epsxe. Este emulador es un poco complicado de instalar, necesita un plugin para cada cosa. Por ejemplo, un plugin de video y otro de sonido, aunque generalmente puedes encontrar el emulador con todos sus restos dentro del mismo repositorio. Por ejemplo, en Archlinux lo puedes descargar e instalar directamente de AUR. Luego debes intrusear un poco la configuración hasta llegar a la más óptima para tu hardware. En mi caso, me uso este emulador simplemente para jugar Silent Hill 1.

Compartir/Guardar

El evento, llamado “Archlinux Orphan’s Day” no busca difundir el uso del software libre ni nada por el estilo, simplemente orientar a los usuarios de archlinux sobre cómo empaquetar software para la distribución, adoptar los ya existentes y cómo mantenerlos. Para la organización hemos utilizado el wiki del hacklab donde pueden encontrar información sobre el temario, programa, etc.

Compartir/Guardar

El script, llamado mpd-twitter,  usa el cliente mpc para conectarse a mpd y obtener el artista y nombre de la reproducción actual, hacer el parseo necesario y posteriormente publica un estado en twitter.

#!/bin/bash
#
# Author: Zerial 
# Version: 0.1
# URL: http://dev.zerial.org/mpd-twitter
# License: GPL
#

CONF_FILE=$HOME/.mpd-twitter
USER=$(grep ^USERNAME $CONF_FILE |cut -f 2 -d "=")
PASS=$(grep ^PASSWORD $CONF_FILE |cut -f 2 -d "=")

if [ -f $CONF_FILE ]; then
	BEFORE=$(grep ^BEFORE $CONF_FILE |cut -f 2 -d "=")
	AFTER=$(grep ^AFTER $CONF_FILE |cut -f 2 -d "=")
else
	Xdialog --title "Error" --beep --msgbox "Can't read your local config file. Please copy the /usr/local/share/mpd-twitter/mpd-twitter.local to $HOME/.mpd-twitter" 200 100
	exit
fi

CURRENT_SONG=$(mpc current)
MY_UPDATE="$BEFORE $CURRENT_SONG $AFTER"

curl -u "$USER:$PASS" -d "status=$MY_UPDATE" -d "source=mpd-twit" "http://twitter.com/statuses/update.json"
exit

El archivo de configuración, que debe estar ubicado en ~/.mpd-twitter, es:

#
# Local Config file for mpd-twitter
#
#
# Config the username and password
#
USERNAME=your_username
PASSWORD=your_password
#
# Text before and text after the song.
# example:
# if BEFORE=Listening and AFTER=(powered by xxx)
# mpd-twitter will send "Listening  (powered by xxx)"
#
BEFORE=#nowplaying
AFTER=(powered by mpd)

Para los usuarios de Archlinux que quieran probarlo, he creado un PKGBUILD:

# Contributor: Zerial 
pkgname=mpd-twitter
pkgver=0.1
pkgrel=4
pkgdesc="Publish on twitter what you are listening on MPD"
arch=('i686' 'x86_64')
url="http://dev.zerial.org/mpd-twitter"
license=('GPL')
depends=('xdialog' 'curl' 'mpc')
source=(http://dev.zerial.org/mpd-twitter/${pkgname}_${pkgver}.tar.gz)
md5sums=('3d73b79fa38bd60f637386146137999b')

build(){
	cd $startdir/src/$pkgname
	install -d $startdir/pkg/usr/local/share/mpd-twitter
	mkdir $startdir/pkg/usr/bin
	install -m744 $startdir/src/$pkgname/mpd-twitter.local $startdir/pkg/usr/local/share/mpd-twitter/
	install -m755 $startdir/src/$pkgname/mpd-twitter $startdir/pkg/usr/bin/
}

Tambien lo pueden encontrar en el repositorio AUR.

La idea es lanzar el script con algun hotkey de nuestro gestor de ventanas y asi, cada véz que quieras mostrar lo que estás escuchando, simplemente precionas la combinacion de teclas que configuraste. Por ejemplo, en DWM la he configurado asi:

[...]
/* commands */
static const char *mpdtwittercmd[] = { "mpd-twitter", NULL };
static Key keys[] = {
[...]
      { MODKEY|ShiftMask,                     XK_t,   spawn,  {.v = mpdtwittercmd } },
[...]

De esta forma, cada vez que presiono Alt+Shift + T, aparece en twitter lo que estoy escuchando.

Compartir/Guardar

Para lograrlo, simplemente tenemos que agregar un par de líneas al config.h y volver a compilarlo.

Debemos descargar los ficheros bstack.c y bstackhoriz.c y agregar las siguientes líneas a nuestro fichero de configuración config.h, despues de la definición de la variable mfact y antes de la definición de layouts:

#include "bstack.c"
#include "bstackhoriz.c"

Y dentro de la definición de layouts debemos agregar:

{ "TTT",      bstack },
{ "===",      bstackhoriz },

El fichero config.h se debería ver mas o menos así:

[...]

/* layout(s) */
static const float mfact      = 0.55; /* factor of master area size [0.05..0.95] */
static const Bool resizehints = True; /* False means respect size hints in tiled resizals */

#include "bstack.c"
#include "bstackhoriz.c"

static const Layout layouts[] = {
        /* symbol     arrange function */
        { "TTT",      bstack },
        { "[]=",      tile },    /* first entry is default */
        { "><>",      NULL },    /* no layout function means floating behavior */
        { "[M]",      monocle },
        { "===",      bstackhoriz },
};

/* key definitions */
#define MODKEY Mod1Mask
#define TAGKEYS(KEY,TAG) \

[...]

Imágenes:

Pueden encontrar el artículo original en el siguiente link:
http://dwm.suckless.org/patches/bottom_stack

Compartir/Guardar

El modelo actual de difusión del software libre no está siendo efectivo, queremos mejorarlo.

En una reunión improvisada que tuve con 3 o 4 amigos, salió el tema del software libre y el cómo se está difundiendo en el país. Cuestionamos la efectividad de los distintos centros de difusión, grupos de usuarios, métodos y formas de difusión, etc. Dentro de tantas cosas que conversamos, decidimos volver a juntarnos para continuar conversando el tema y así buscar una solución a los distintos problemas que encontramos. Lo primero que decidimos fue que ante cualquier opinión o desacuerdo que tengamos, actuaremos. No buscaremos llenarnos la boca de palabras. Nuestro fín, es encontrar una solución al problema de la difusión de la filosofía del software libre en nuestro país, para ésto, hicimos una lista de los principales problemas que detectamos en el actual modelo de difusión:

• Los distintos grupos de difusión no están practicando lo que predican.
• Los eventos de difusión buscan masividad y no efectividad.
• Por lo general se buscan usuarios, dejando de lado el concepto de libertad.
• Se busca difundir el software libre usando software, drivers o firmwares privados.
• Las charlas no son efectivas, pues siempre asiste la misma gente. Además, las personas buscan que les enseñen, no que les digan cómo hacer las cosas. (hay una pequeña situlesa en aquella diferencia)

Para éstos problemas, nosotros encontramos la siguiente solución:

Mediante un proceso de educación y concientización, buscamos una migración efectiva y no masiva. No nos enfocamos en migrar sistemas operativos, sino en migrar mentes.

Antes de comenzar, me gustaría darle créditos a dererk por la parte de la frase donde dice que buscamos migrar mentes y no S.O.

Bien, ya hemos tenido dos reuniones en las cuales nos hemos dado el trabajo y, luego de largas discusiones, tenemos un borrador con los apuntes y con las decisiones que hemos tomado. La primera reunión que tuvimos, era para encontrar los problemas y fallos de los actuales modelos de difusión del país, tambien proponer soluciones y junto con todo ésto, agendar una segunda reunión donde podamos ver el documental “Revolution OS“, para quienes no lo han visto, y además, afiatar el compromiso de cada uno con éste nuevo proyecto.

Reunión 1

Mediante distintas analogías, logramos determinar lo importante que es el software libre y la importancia de difundirlo.

Llegamos a la conclusión que gnu/linux no es para todos. Ésto puede sonar bastante talibán o bastante cerrado, pero es a lo que llegamos. Hicimos la analogía del dildo de goma gigante, si tu quieres lo puedes usar y metertelo por el culo, nadie te dice que no lo hagas, pero no es para ti, estas en la libertad de hacerlo pero, claramente (creo), no lo harás. Con GNU/Linux pasa lo mismo,  cualquier persona puede descargarselo, instalarlo y usarlo, pero claramente no todos podrán sobrevivir con él, no todos podrán ser linuxeros y no todos compartirán la filosofía que conlleva. En simples palabras, GNU/Linux no es para todos, es para quien quiera usarlo.
Bajo ésta premisa, nos enfocaremos en éste tipo de usuarios, los que quieran usarlo.

Otro punto que discutimos, fue el no atacar a la competencia, a nuestro rival: Microsoft. Sino buscar forma de, por medio del argumento y la palabra, lograr que las mismas personas se den cuenta de lo malo del software privado. Tambien, nuestro amigo leo, hizo la analogía con una frase que dijo la Madre Teresa de Calcuta: Nunca iré a una marcha que diga “no a la guerra”, pero si dice “si a la páz”, iré. No buscamos el “no al software privado” o el “no a microsoft”, mas bien buscamos el “si al software libre”, “si a gnu/linux”.

Con todo ésto, buscamos, claramente, una migración efectiva y no masiva, buscamos la elección por parte de los usuarios, la concientización. Creemos que para evangelizar, debemos reforzar las bases de lo que estamos promoviendo. No podemos promover el uso de GNU/Linux si nos olvidamos de la base del software libre y sus libertades.

Hicimos la siguiente analogía para explicar un poco el tema del software privado vs software libre:

Imaginemos una escalera gigante y mucha gente, lo perfecto seria que cada vez que una persona suba un escalon le diga a la otra persona, “oye, logre subir, mira hazlo de esta forma” y asi sucesivamente van avanzando hasta llegar al ultimo escalon, pero, que pasa si las personas no dicen como subir pero sin embargo los ayudan a subir, y les cobran algo a cambio, quien llega a la cima primero?

Segúnda reunión

Vimos “Revolution OS” y armamos un debate, entre quienes ya lo habiamos visto y entre quienes lo vieron en ese momento, sobre cómo captaron el mensaje del documental. Tomamos apuntes sobre los distintos temas tratados en el documental y además, fijamos puntos para una próxima reunión. La idea de ésta segúnda reunión, es haberla hecho entre pocas personas, los que estamos formando parte de éste movimiento, para presentarnos con ideas claras hacia las demas personas. Hoy Sábado, tenemos nuestra tercera reunión, donde invitamos a personas que nosotros estimamos conveniente, que sabemos que podría existir interés hacia el software libre, amigos o conocidos de nosotros, para estudiar su reacción, ver como enfrentan el tema y cómo ven el documental. Luego de esta tercera reunión, tenemos planeado hacer algo un poco más masivo.

Para poder organizarnos, armamos un wiki en el cual vamos tomando notas y apuntos de las distintas reuniones que tenemos. Lo tenemos en http://wiki.hacklab.cl

Compartir/Guardar

Usar software libre es bueno porque permite, entre otras cosas, manejar y controlar algo que es tuyo: tu computador y es por éste motivo que nace el dilema entre el hardware y los famosos drivers propietarios/privativos v/s los libres. Para muchas personas el hecho de no poder aprovechar los recursos de su hardware gracias a los drivers libres significa un problema y entonces es cuando deciden usar el driver propietario o privado. El otro día, pensaba que la única forma de promover y mejorar el desarrollo de drivers (o firmwares) libres desde las propios fabricantes es usar los drivres libres ya existentes. Estamos en un proceso de educación y difusión del software libres y de nuestras libertades, si queremos lograr que éste proceso avance debemos sacrificarnos un poco. Imaginemos un mundo ideal, donde todas las personas usan drivers libres y los fabricantes no encuentran qué hacer para que los usuarios compren sus productos, como no se puede exprimir al máximo los recursos del hardware, el usuario no va a necesitar continuar comprando y por ende, los fabricantes se verían obligados a desarrollar ellos mismos un driver que sea libre y que cumpla con todo lo necesario para poder funcionar correctamente. Obviamente, es una utopía.

Hace un par de días tuvimos a Richard M. Stallman de visita en Kernelhouse y en el Hacklab y me quedó dando vueltas una frase que nos dijo: “Las personas que usan software privado no están respetando su libertad“.

Si bien las personas son libres de usar software privado o libre, creo que la diferencia está simplemente en cuando te obligan a usar uno u el otro. Cuando una persona decide usar software libre, entonces está haciendo uso de su libertad de hacerlo. El problema, para mi, es cuando no tienes opción o bien, te obligan. Generalmente estás obligado a usar software privado, compras un iPod y viene con software privado y hasta es ilegal “desbloquearlo” siendo que es tuyo.  Cuando compras un portatil o un computador de escritorio, éste viene con M$ Windows, de una u otra forma te están obligando a usarlo. En el precio se incluye el precio de la licencia y para evitar pagarla, hay que hacer miles de trámites que aveces no valen la pena. Pasa hasta en el gobierno, existen muchos planes para disminuir la brecha digital, tecnologizar a personas de escasos recursos, pero detrás de éstos métodos, siempre está Microsoft por detrás. Microsoft siempre ofrece ofertas que, debido a la ignorancia de quienes toman las decisiones, es imposible rechazar. Por ejemplo, para el colegio de escasos recursos donde existen 40 mil nños que jamás han tocado un cumputador, ésta monopólica empresa, decide “donar” 1000 computadores con licencias para usar Windows “especialmente” adaptada para esta ocasión, por ejemplo la típica “Starter Edition“. Con este tipo de metodologías, lo único que estamos logrando es crear una dependencia a un producto de una empresa privada. Para exáctamente lo mismo cuando el gobierno decide “auspiciar” y “becar” a sientos de personas de tercera edad o personas analfabetas tecnologicamente a cursar un taller o curso de “Microsoft Office”, hacen que éstas personas dependan de un producto de Microsoft, por ésto mismo, lo que se debería promover son cursos de “ofimática” que servirían para que un usuario sepa usar cualquier suite de herramientas de oficina, ya sea de MS Office, Open Office, Koffice, etc. Para que la educación de resultado, hay que enseñar a la persona a elegir, hay que demostrarle que tiene libertades que él mismo puede aprovechar. Windows no llegó a ser tan popular porque era un buen producto o porque era la única opción existente en el mercado, simplemente porque la ignorancia de las personas, gracias a la manipulación de las grandes empresas y el gobierno, hizo que así fuera.

Un proceso de educación tiene un bien final cuando el usuario logra, por si mismo, decidir qué sistema operativo usar (MS Windows, GNU/Linux, Mac, etc) y por ejemplo, en el caso que use GNU/Linux, que su conocimiento le permita decidir que distribución usar. El motivo de mi odio a Windows es similar al por qué odio a Ubuntu, sus políticas de marketing y sus filosofías no me gustan, Ubuntu de una u otra forma está haciendo lo mismo que Microsoft, no se hizo popular por su funcionalidad sino que por el dinero. Actualmente, me atrevería a decir que el 90% de los usuarios de Ubuntu  no tienen idea que existen más distribuciones, frente a (según yo) un 70% de usuarios Windows que si sabe que existen varias distribuciones de GNU/Linux.
En conclusión, estoy completamente de acuerdo en que cuando una persona usa software privado, no está respetando su libertad, ya que se está sometiendo, voluntaria o involuntariamente, a usar el producto (software o hardware) como el fabricante lo dice, aún pagando por él.

Compartir/Guardar

La guía del ocio, índice:

1. Ver los movimientos del mouse
2. Escuchar como trabaja nuestro disco duro
3. Jugar con el speaker

Contenido

• Ver los movimientos del mouse

Podemos visualizar los movimientos que hacemos con el mouse, dependiendo del dispositivo que usemos. Por ejemplo yo, con un mouse usb o con el touchpad de mi portatil usaré el dispositivo /dev/input/mice. Es simple, sólo debemos ejecutar el comando (como root):
# cat /dev/input/mice
Y comenzar a mover el mouse.
Resultado:



• Escuchar como trabaja nuestro disco duro

Esto va depende de cómo tengamos distribuido nuestros discos, en mi caso, corresponde al dispositivo /dev/sda y para “escuchar” cómo suena, sólo ejecuto este comando (root):

# cat /dev/sda >> /dev/audio
Y sentiremos como si estuviesemos escuchando ruido extraterrestre…

• Jugar con el speaker

Esto es un poco más divertido, para esto necesitaremos instalar el paquete “beep” y cargar el módulo pcspkr en el caso que no esté cargado. Para hacer sonar el speaker basta con ejecutar el comando:
# beep

Podemos jugar con las frecuencias y duración de cada beep (ver man beep) y lograr cosas como estas:

1. #!/bin/bash
2. beep -f 349;
3. sleep 0.33
4. beep -f 415.3;
5. sleep 0.165
6. beep -f 349;
7. beep -f 349 -l 170;
8. beep -f 466.2;
9. sleep 0.05
10. beep -f 349;
11. sleep 0.05
12. beep -f 311.1;
13. sleep 0.05
14. beep -f 349;
15. sleep 0.33
16. beep -f 523.2;
17. sleep 0.165
18. beep -f 349;
19. beep -f 349 -l 170;
20. beep -f 550;
21. sleep 0.05
22. beep -f 523.2;
23. sleep 0.05
24. beep -f 415.3;
25. sleep 0.05
26. beep -f 349;
27. sleep 0.05
28. beep -f 523.2;
29. sleep 0.05
30. beep -f 698.4;
31. sleep 0.03
32. beep -f 349 -l 170;
33. beep -f 311.1 ;
34. beep -f 311.1 -l 170;
35. sleep 0.05
36. beep -f 261.6;
37. sleep 0.03
38. beep -f 392;
39. sleep 0.03
40. beep -f 349 -l 750;

Por ejemplo, este “beep” lo hicimos junto a Pons y a otros compañeros en la Universidad, cuando estabamos muy aburridos y no teniamos cosas que hacer.

Compartir/Guardar