Poesía binaria

Estos días a varios de mis alumnos les ha surgido la necesidad de probar la existencia de un archivo haciendo la llamada al sistema open(). Es bastante sencillo, sólo hay que probar si éste se ha podido abrir (como lectura, por ejemplo, para no tocar el fichero en la medida de lo posible).
Una vez se abre el fichero pueden ocurrir varias cosas:

• que la llamada a open() no devuelva error. Por tanto el fichero existe
• que la llamada a open() de error:
  • si el resultado de errno es ENOENT (constante de error), ENOFILE en algunos sistemas o 2 (valor que generalmente vale dicha constante), el fichero no existe
  • si el resultado de errno es distinto, no podemos asegurar que no exista, pero tal vez el nombre de fichero no sea correcto, la ruta no exista, o no tengamos acceso a él.

Para contemplar estos casos creamos la función exists(). Incluyo la función y el código de ejemplo:

Descargar: exists (1Kb)
Para ejecutarlo podemos probar:

$ ./exists
El archivo no existe
$ touch archivo
$ ./exists
El archivo existe
$ chmod -r archivo # Eliminamos permiso de lectura al fichero
$ ./exists
Ocurrió un error al abrir. 13 (Permission denied)

Puede que también seas de los que piensan que si hay algún error al abrir el archivo, da igual, lo marcamos como no existente, de todas formas no podemos hacer nada con él. Así, construimos una función exists() más intuitiva que devuelve 1 cuando existe y 0 cuando no existe o hay error:

Hace tiempo hablábamos de capturar señales, aunque en ocasiones, es necesario saber quién me envía esa señal, si por ejemplo nos envían un SIGINT o SIGTERM, tal vez queremos saber qué proceso nos quiere muerto y qué usuario lo ha invocado. O tal vez estamos esperando una señal de control (SIGUSR1, por ejemplo) por parte de un proceso cliente específico.

El problema es que por nuestro modo actual de direccionar señales (con signal(señal, funcion)) sólo comunicamos el número de señal que se ha recibido, sin más información.

Para capturar esta información necesitamos utilizar sigaction para establecer la función a la que llamaremos cuando llegue la señal, para utilizarla podemos utilizar el siguiente código:

Como vemos sigaction tiene 3 parámetros:

• La señal que queremos capturar
• Un registro de tipo struct sigaction
• La acción que se ejecutaba antes, por si queremos guardarla para restaurarla más tarde

Dentro del registro, tendremos como valores importantes (struct sigaction act):

• sact.sa_sigaction : que especifica la función que la llamaremos, esta función será del tipo void funcion(int, siginfo_t*, void*), donde el primer int recibirá la señal que nos han enviado (tal y como hacía la función que asignábamos con signal), el segundo parámetro será información asociada a la señal, y la tercera el contexto de ejecución.
• sact.sa_handler : será la función a la que se llama, es la misma que cuando hacemos signal(señal, funcion)
• sact.sa_flags : Es un conjunto de flags, si especificamos SA_SIGINFO, estaremos dando paso a la función especificada por sa_sigaction, si no utilizaremos sa_handler. Aunque esta variable vale para más cosas, para esta práctica nos vale con saber esto. (man sigaction para más info)
• sact.sa_mask

: Nos proporciona una máscara de las señales que serán bloquedas, podemos utilizar sigfillset() para rellenar toda la máscara automáticamente. Si queremos que unas se bloqueen y otras no podemos utilizar sigaddset() y sigdelset()

Ahora bien, la función que se llamará cuando venga una señal tendrá el prototipo que hemos visto antes con tres parámetros: la señal recibida, la información de la señal con un puntero a siginfo_t y el contexto de ejecución, que se pasará con un puntero a void, que por ahora no utilizaremos. La estructura que controla la información de la señal entre otros muchos datos nos facilitará lo siguiente:

• si_pid : PID que nos envía la señal (y esta acción da título al post)
• si_uid : Usuario que ejecuta el proceso que nos manda la señal
• si_errno : Algún error que haya causado la señal
• … para más información, man sigaction

Para preparar la sentencia tendremos que escribir varias líneas definiendo los valores del registro así como la llamada a la función sigaction(), por lo tanto podremos crear una función que tenga los parámetros más comunes a la hora de definir este tipo de acciones, así lo llamamos como a signal():

En esta función es importante poner bien el prototipo de la función como parámetro, eso lo comenté en un post anterior sobre callbacks

Ahora, vamos a dejar el código más bonito, este programa implementará el control de errores y nos permitirá salir cuando recibamos 5 SIGINT (pulsemos 5 veces control+C):

Me he decidido a escribir esta guía tras hablar con varios de mis alumnos de clases particulares. Siempre les intento explicar de las ventajas de un sistema operativo GNU/Linux y les animo a probarlo. Aunque la instalación generalmente no sea difícil (en las distribuciones tipo Fedora/Mandriva/Ubuntu/Linux Mint/…) siempre es algo nuevo, y supone una gran cantidad de información nueva para una persona que no ha tenido experiencia en estos sistemas, lo cual puede llegar a saturar a cualquiera. Es cierto, que para una primera toma de contacto es conveniente tener una mano amiga cerca para guiarnos durante el proceso, al menos la primera vez.

Las razones por las que he cogido Linux Mint Debian Edition XFCE son:

• Porque es una distribución que uso, y me gusta
• Porque muchas de las personas que van a tener una primera experiencia con Linux, suelen hacerlo en un ordenador más antiguo que el principal, y es bueno que la distribución esté optimizada y no consuma demasiados recursos
• Porque aún hay cosas que tenemos que hacer en terminal, puede parecer un rollo, puede parecer retro, pero tenemos en nuestras manos una de las herramientas más potentes de la informática, disponible para cualquier ordenador, y para todos, sólo tenemos que tocar las teclas adecuadas
• Porque me parece que tiene una relación velocidad/estabilidad muy buena
• Porque me parece una buena distribución para embarcarse en el mundo Linux, y para aprender a utilizar el sistema (si queremos ser heavies podemos empezar con Gentoo, pero el usuario medio, incluso con interés puede terminar abandonando).
• Porque, por todos estos motivos quiero colaborar en su difusión.

¿Qué podemos encontrar en esta primera guía?

1. Descarga y copia en un soporte externo.
2. Arranque e inicio de la instalación
3. Configurar idioma, zona horaria y distribución de teclado
4. Configurar las particiones
5. Unos datos más previos a la instalación
6. Para sentirse como pez en el agua…
7. Notas finales

Descarga y copia en un soporte externo.

Antes de embarcarnos en la instalación debemos descargarnos la distribución (de forma libre y gratuita), desde algún mirror oficial. Debemos acceder a la descarga en 32bit o 64bit dependiendo de nuestra arquitectura y memoria RAM. Casi todos los procesadores nuevos (de 3 años hasta la actualidad) soportan 64bit (aunque al comprar el ordenador pudiera venir con una versión de 32bit de Windows, eso es lo de menos. Algo muy recomendable es que, independientemente de que nuestro ordenador soporte 64bit, si tenemos menos de 2Gb de RAM es mejor instalar la versión de 32bit.

Una vez descargado el archivo ISO (la imagen de CD o DVD), debemos grabarla en un disco o en una unidad USB flash o pendrive.

Para la primera opción, si estamos en Windows podemos utilizar alguna de estas utilidades, aunque podemos acceder a esta dirección, donde explican cómo hacerlo con una imagen de Ubuntu.

Si lo que queremos, para no gastar discos es hacerlo desde un pendrive, primero debemos asegurarnos de no tener nada importante dentro, ya que lo más recomendable es formatearlo y ejecutar la utilidad unetbootin, multi-plataforma, y muy fácil de usar.

Arranque e inicio de la instalación

Tal vez, nuestro ordenador cuando arranca, lea de primeras el CD o el puerto USB en busca de un soporte de arranque antes de iniciar el sistema operativo que tenemos instalado, con lo cual no tendríamos que preocuparnos.

Pero en ocasiones esto no es así. Normalmente existe una tecla con la que podemos seleccionar el dispositivo de arranque con un pequeño menú en pantalla (Escape, F1, F2, F5, F8, F10, F12, generalmente es alguna de estas, si no sale el logotipo de la marca normalmente pondrá en la pantalla qué tecla hay que pulsar), o pulsando Del (o Suprimir) para entrar en la configuración de la BIOS donde podremos seleccionar la secuencia de arranque (Boot Order / Boot Sequence) y pulsar F10 (casi siempre, pero mejor, leer la pantalla, que seguro que viene cómo hacerlo) para salvar cambios.

Al iniciar, arrancamos el menú con la opción por defecto y esperamos a que esté totalmente cargado antes de pulsar el icono Install Linux Mint y empezar con la instalación.

Configurar idioma, zona horaria y distribución de teclado

Empezamos con la instalación en serio, y primero vamos a seleccionar nuestro idioma. En mi caso Español (España), aunque la configuración de idioma la terminaremos después de la instalación.

Una vez seleccionado el idioma, pulsamos sobre el botón Forward (Continuar).

El siguiente paso será seleccionar la zona horaria. Buscamos el continente y la ciudad más cercana con la misma hora que la nuestra.

Y continuamos (Forward).

Como en las pantallas anteriores, aquí seleccionamos nuestra distribución de teclado. Normalmente la que viene por defecto está bien; en el cuadro de abajo podemos probar si el teclado está bien configurado escribiendo letras especiales y símbolos que suelen ser caracteres conflictivos y no en todos los teclados están distribuidos de la misma forma.

Configurar las particiones

Debemos distribuir en nuestro disco duro nuestra nueva instalación. En este punto se decidirá si la distribución se instala sola en el disco duro o debe convivir con otras instalaciones, incluso con Windows.Si pulsamos sobre Edit Partitions, tendremos la capacidad de crear, eliminar,  y redimensionar particiones en nuestro sistema, aunque por el momento no voy a tocar esa parte, es un sistema más o menos intuitivo donde podemos ver, como en esta imagen gráficamente el disco duro, y el espacio ocupado. Por ejemplo, si tenemos una partición Windows que ocupa todo el disco, podemos hacerla más pequeña (mejor si hacemos una copia de seguridad antes, aunque nunca pasa nada, seguro que la ley de Murphy juega en nuestra contra si no la hacemos).

En mi caso, yo he creado varias particiones:

1. Una muy pequeña (de unos 100Mb más o menos) que será para el arranque
2. Una para intercambio (swap) 2 Gb más o menos. Es importante darle más tamaño que nuestra memoria RAM, ya que si hibernamos el equipo necesitaremos copiar toda nuestra RAM en el disco duro, y puede que necesitemos algo más para trabajar. Además de para hibernar, hablando mal y pronto esta partición nos servirá como RAM cuando ya tenemos llena la RAM.
3. Partición raíz (yo suelo dar algo más de 1Gb, por lo que pueda pasar con respecto a archivos temporales), aunque no suele tener más de 400Mb siguiendo este sistema de particionado que propongo…
4. NOTA: Si tienes disco duro libre, estaría bien crear una partición para archivos temporales, sobre todo si vamos a grabar DVDs, podremos almacenar las imágenes ISO de los discos temporalmente en esa partición.
5. Una partición para los programas. En mi caso con 7.5Gb está bien, nos da para instalar muchos programas y nos sobrará disco, aunque si instalamos juegos o programas muy grandes tal vez se nos quede corta, habrá que ver el uso que vamos a hacer de nuestro Linux.
6. Una partición de 2Gb para datos variables, estos serán los archivos de instalaciones de paquetes, colas de impresión, informes de sistema (logs) y algunas cosas más.
7. La partición más grande de todas, para los directorios personales de los usuarios, donde éstos almacenarán sus datos, su configuración, sus descargas, etc.

Una vez hemos terminado de definir las particiones, procesamos los cambios y cerramos la ventana.

El siguiente paso es definir los puntos de montaje y cómo vamos a formatear nuestras particiones.

Asignaremos a cada una de las particiones, un formato y un punto de montaje (este es el que determinará la misión de la partición en nuestro sistema, y será el punto desde el que podremos acceder a ella):

1. La partición pequeña de arranque, se montará en /boot y será de tipo ext2
2. A la partición swap no hará falta hacerle nada.
3. La partición raíz se montará en / y será de tipo ext4
4. La pertición de programas se montará en /usr y será de tipo ext4
5. La partición de datos variables se montará en /var y será de tipo ext4
6. La partición de datos de usuario se montará en /home ; si tienes una instalación anterior y no quieres perder los datos, no debes especificar el tipo, ya que se formatearía, lo dejamos tal cual.
7. Si tienes  una partición para datos temporales, móntala en /tmp y dale de tipo ext4
8. Si tienes particiones de una instalación de Windows anterior, puedes dejarlas sin montar, o darles un punto de montaje, por ejemplo /mnt/Windows , /mnt/Documentos_Windows  y no darle tipo, ya que se formatearía como indiqué en el punto 6. Linux Mint se encarga de detectar el tipo de formato de esa partición.

Una vez finalizado el particionado, pulsamos Forward de nuevo.

Unos datos más previos a la instalación

Antes de terminar, debemos especificar nuestro nombre (sólo para que se vea en pantalla, que también puede ser un alias), nuestro nombre de usuario, con el que entraremos al sistema; la contraseña y un nombre para el equipo: vamos sed originales y bautizad vuestro ordenador, empecemos a darle personalidad !!

Desde esta ventana se instalará el gestor de arranque, un menú que se cargará antes que el sistema operativo y nos permitirá elegir  con qué sistema arrancar, también tendrá una opción de rescate.

Como última ventana antes de la instalación veremos un resumen de lo que vamos a hacer, debemos prestar especial atención a las particiones , sobre todo si hay alguna que no queramos formatear, porque todavá no se han realizado los cambios (excepto si hemos creado, eliminado o redimensionado alguna partición). Si queremos mantener nuestra partición de Windows, debemos ver que se va a montar (Mount) en algún sitio (aunque no es obligatorio), pero bajo ningún concepto será formateada.

Para sentirse como pez en el agua…

Iniciamos la instalación, a partir de ahora va solo… se formateará, copiarán los archivos y se configurará de forma básica el sistema.

Uhmmm… ¿Nunca has instalado una distribución de Linux? Al poco tiempo de estar con el sistema, verás que puedes probar cómo funciona desde el mismo disco de instalación, lo que significa que, mientras se instala (aunque no tarde mucho), podrás navegar por Internet, escuchar música (de tu disco duro, por ejemplo) y hacer mil cosas más, sólo hay que echar un vistazo a los progrmas disponibles. Esto no es exclusivo de Linux Mint, muchas distribuciones lo permiten desde hace mucho tiempo… ¿eso no te lo permite Windows, verdad?

Por ejemplo, podemos configurar la red para navegar un rato por Facebook… (aunque esta configuración no se mantendrá una vez instalado el sistema)

Pasados unos 15 minutos tendremos un sistema Linux Mint Debian Edition operativo; reiniciaremos el sistema, ¡listo!

Notas finales

Una vez hayamos terminado la instalación es recomendable actualizar la distribución. Para ello, nos dirigimos al icono arriba a la derecha, como un escudo, junto al icono de la batería, aunque en la captura no aparecen (yo ya actualicé), nada más instalarla aparecerán algunos paquetes para actualizar.

¡ Ya podéis disfrutar de un nuevo sistema !

Desde hace años, he tenido mala suerte con los sistemas de suspensión de sistema e hibernación. En mi época Windows (que casi todos hemos tenido), casi nunca suspendía el sistema, sobre todo porque, luego no espabilaba, vamos que, unas veces se quedaba el sistema dormido y no respondía, y otras veces parecía que volvía a responder pero no terminaba de encender. El gran problema era que pasara lo que pasara no podía monitorizar el problema, ni arreglarlo, por mucho que investigué. Aunque parece que a día de hoy ya no existe tanto problema con este sistema operativo.

Cuando entré en el mundo Linux, al principio tuve problemas similares, o que directamente no podía hibernar ni suspender porque el sistema no quería sencillamente, la verdad es que investigar un poco en el tema tampoco sirvió de mucho porque parecía que a todo el mundo le funcionaba directamente, menos a mí. Mi cruzada en este ámbito empezó con Gentoo, y por aquel entonces me paré a mirar todos los kernels que tenía disponibles y descubrí el kernel tuxonince, que era especial para hibernar y suspender. En Gentoo no tuve más problemas.

Aunque poco a poco toca renovarse, y en un netbook que utilizo para los viajes instalé Linux Mint Debian Edition, el netbook no es gran cosa, pero me hace el apaño y un tema que me preocupa, ahora sí, es la energía, ya que si estoy con batería (que dura unas escasas 2h:30) y por un momento dejo de utilizarlo, es tiempo que pierdo, por lo que vendría bien suspenderlo, que consuma poca energía y espabilarlo cuando vuelva a utilizarlo (apagarlo y encenderlo, puede ser muy pesado y en ocasiones gastar más energía aún, además de perder tiempo).
Como es normal, de serie no funciona ni la hibernación ni la suspensión, por lo que tuve que buscar alternativas, tal vez más adelante instale los parches de tuxonice, pero por el momento tengo prisa y no quiero compilar el kernel (que puede tirarse unas 3h).

Lo primero fue instalar uswsusp, y dado que no está marcado como estable en Debian, LMDE tampoco lo trae, por lo que las opciones son añadir sid a los repositorios, o bajarlo de aquí.

$ dpkg -i uswsusp_1.0-1_[plataforma].deb

Seguidamente, aunque hice pruebas con pm-utils (instalado por defecto), no logré que nada funcionara, incluso cambiando todas las configuraciones disponibles, por lo que instalé el hibernate script, que utilizaba yo con tuxonice, este sí que viene en el repositorio oficial:

$ apt-get install hibernate

De serie, no funcionó, aunque cambiando algo de configuración sí:

$ sudo nano /etc/hibernate/ususpend-ram.conf

Y cambiar las siguientes líneas:

Ahora, para hibernar ejecutamos el hibernate script, tanto hibernate como hibernate-ram para que todo funcione.
Más adelante probaré con tuxonice+LMDE, y publicaré mis resultados.

Vivimos en una época de cambio. En la que muchas personas invierten dinero y tiempo en cursos para aprender a manejar diferentes programas.
Es cierto, hablando de las herramientas de Microsoft, que el Word o el Excel 95 no se parece en nada al Word o Excel 2007, lo cual provocaría que muchos de los que invirtieron dinero en cursos de la versión antigua, tengan que volver a invertir un dinero en la versión moderna. Recuerdo hace unos años que eran famosos los cursos de Wordperfect y Quattro pro y a día de hoy aunque esos desarrollos siguen vivos (con última versión en 2008) poca gente se acuerda de ellos.

Aunque pueda parecer muy tonto, podríamos pensar que la mayoría de la gente que hace un curso sobre un programa sabría manejar cualquier programa derivado; aunque la experiencia indica lo contrario. Al final, la mayoría de las personas que saben manejar un programa X, cuando se les cambia algo de sitio (cambio de versión, de programa, de SO siendo el mismo programa, en fin, cambios menores) dejan de saber manejar ese software.

A lo que voy es a eso, sé que en algunos sitios ya se aplica y no sugiero una migración total a sistemas libres (OpenOffice.org / LibreOffice aunque en mi opinión en algunos aspectos superan a MS Office, en otros aspectos no), pero en los mismos cursos en los que se enseña uno se podría dar la alternativa, las opciones generales en uno y en otro (o usando como ejemplo alguna otra suite ofimática con el objetivo de tener una información contrastada). La clave es tener unos conocimientos que sirvan el día de mañana, igual que al aprender informática general no podemos limitarnos a un Menu Inicio y una “e” para el navegador porque es importante conocer o al menos que nos suene la imagen reprensentativa de otros navegadores y de otros menúes de “inicio” (he visto a personas que al cambiarle “Inicio” por una K grande ya no saben dónde pulsar ni lo intentan).

Parte del problema es también la colaboración de MS en esos cursos, pero lo realmente grave son los lugares en los que no colabora dicha empresa y se hace publicidad de sus productos, ese es el comienzo de las verdaderas víctimas de la dependencia tecnológica, personas que directamente buscan cursos de estos programas y no de una suite ofimática inconscientes en principio de la droga de la que están siendo presos.

Ayer, 11 de Enero de 2011 (por cierto, día binario) salió la noticia de la detención del responsable de informática de ETA (organización terrorista).
Bien, la guardia civil, no tiene otra que llamarla operación Linux.

Dicho nombre daña a la marca, a los desarrolladores, colaboradores, entusiastas y nos desprestigia como usuarios. Desde aquí me gustaría dar una dirección donde podemos reportar el abuso que se está haciendo contra el nombre: http://www.linuxfoundation.org/programs/legal/trademark/abuse-report
.

Entre todos debemos dejar claro que la asociación de Linux con el terrorismo no es viable; es como si nombramos la marca de cereales que desayuna por las mañanas; o como si se llamara operación Hacendado por tener un Mercadona en la puerta de un piso franco; seguro que al dueño de la cadena de supermercados le sentaría mal que una operación policial llevara este nombre. A nosotros como comunidad también debería.

Para enviar una queja o sugerencia a la Guardia Civil, se puede ir a este enlace.

De todas formas, está bien que hablen de Linux… aunque sea así. Algo bueno se puede sacar de ello.

Hace poco en la revista Muy interesante leí un dato curioso. La media de tiempo de arranque de un ordenador es de 89 segundos, y eso hace que si lo arrancamos todos los días, perdamos algo más de 9h al año en arranques de ordenador.

Lo curioso es que a mi me parece algo excesivo, ¡89 segundos! Siempre depende del hardware que se tenga y de los servicios que se arranquen, bueno, y del sistema operativo que corra. Me gustaría hacer en los próximos días una pequeña encuesta vía Twitter/Facebook/Blog acerca de los tiempos de arranque de sus ordenadores.

A ver lo que sale… ¿ cuánto tarda tu ordenador en iniciarse ? Dejadlo en comentarios, me gustaría que escribierais el tiempo, el hardware (no muy exhaustivo tampoco CPU y RAM) o el tiempo que tiene el ordenador y el sistema operativo.

Mis andanzas con Linux empiezan en el año 2001, en busca de un sistema operativo nuevo, por descubrimiento e investigación. Todo empezó intentando instalar una Debian en un ordenador que tenía para hacer experimentos, aunque no funcionó (aunque parezca extraño lo primero que vi fue un Kernel Panic, y por aquel entonces no tenía ni idea de por qué). Luego fui probando, e intenté instalar Red Hat, pero no me hallaba con la consola, y luego probé Mandrake, que me funcionó a la primera y con la que estuve un par de años.

La primera impresión que tuve de un GNU/Linux era la de un sistema delicado, tenía esa impresión subjetiva de que iba a tocar algo y todo se iba a fastidiar, luego pasé a tener la impresión de que me ocultaba partes del hardware, yo veía que con MSDOS y Windows accedía a las unidades C: y D: y con Mandrake no encontraba la forma de hacerlo.

Lo primero que intenté hacer, después de ver todos los juegos de KDE (KDE2, por aquel entonces), fue intentar compartir archivos con mi máquina Windows, y preguntando en algunos foros di con SAMBA, y después de una tarde entera investigando y editando smb.conf por fin pude conseguirlo; luego probé CUPS (en principio, sólo quería ver cómo irían mis necesidades básicas) y luego lo utilizaba para conectar al IRC (Internet Relay Chat, que, por aquel entonces estábamos todos muy viciados, más o menos como ahora a Facebook).

Aunque por aquel entonces no avancé demasiado, no tenía mucha idea, y a veces, al mirar los manuales no me enteraba de nada. Así que lo dejé por un tiempo.

Mientras tanto seguí un par de años más con Windows, y llegué al punto de tener que formatear y reinstalar cada tres meses. Un driver de una impresora chocaba con una actualización de Windows que necesitaba para instalar un programa; por otra parte, el ordenador se volvió demasiado lento (tengo que decir que no llegué a ser usuario de Windows XP, lo último que probé fue Windows 2000), me daba problemas con pendrives (al enchufarlos y desenchufarlos), además de llegó un punto en el que perdí información de trabajos para la Universidad por culpa de algún capricho tipo pantalla azul, lo cual me frustró profundamente (Tengo que decir que soy un usuario al que le gusta tener muchas cosas abiertas, escuchar música, navegar por Internet, tener mensajería instantánea (ahora uso más twitter, pero bueno), al mismo tiempo tenía servidor web, de base de datos y algunos programas más abiertos (habría que ver mi Firefox 1.5 con 20 pestañas abiertas)), tengo que confesar que un año antes eliminé definitivamente MS. Office, porque cada vez era más pesado y me resultaba menos útil, porque no había forma de matar al dichoso clip/perro/mago que te “ayudaba”, y porque ocupaba mucho disco duro, por aquel entonces empecé a usar StarOffice. Además, Windows empezó a transmitirme la sensación de un sistema sistema frágil, a medida que lo iba utilizando, se iba haciendo más y más lento (siempre me tomé en serio el tiempo de arranque, aunque soy más de dejar el ordenador todo el día encendido; Windows arrancaba lento y tenía que reiniciar de vez en cuando…). Por otro lado tenemos el tema de antivirus, tenía que tener tiempo para ponerlo al día, y me quitaba recursos de sistema que yo en ocasiones necesitaba…

Por eso a primeros de 2004 decidí darle otra oportunidad a Linux, y mi principal objetivo era aprender, por eso, tras probar Ubuntu y terminar con una sensación de un sistema más delicado, un arranque un poco más rápido que Windows, y la instalación de muchas cosas que no quería decidí probar Gentoo ; por aquel entonces la instalación era más complicada que ahora, e incluso siguiendo el manual, tal vez a la primera no se instalara bien, en dos o tres semanas aprendí muchas cosas sobre el kernel, los componentes del sistema y algunos problemas de optimizar tanto al compilar (puede que a veces el programa no funcione exactamente como se espera), aunque tardé dos semanas, conseguí tener un entorno gráfico listo para empezar a trabajar. Lo más importante: arrancaba en menos de la mitad de tiempo que un Windows recién instalado, las aplicaciones iban mucho más rápido, aprendí a medio-defenderme y lo demás fue buscar aplicaciones que reemplazaran las que yo más utilizaba (o probar con wine a ver si pitaba la flauta).

Como suite ofimática estaba OpenOffice (era muy parecida al StarOffice, de hecho fue precursor; tenía Firefox, y Thunderbird para el correo (lo cambié porque antiguamente utilizando Outlook, porque parece que cada vez que actualizan ese programa dan menos información al usuario); necesité un visor de fotos y encontré gqview y una vez que tenía lo necesario para trabajar encontré una amplia gama de programas para hacer mi experiencia de usuario mucho más llevadera (kontact, xpad, aMSN, xmms, mplayer, y muchos más).
Sólo quedaba un editor de texto, ya que una de mis aficiones preferidas era la programación, y aunque estuve con Kate un tiempo, la que realmente me convenció (aunque fui advertido, de que el camino no sería fácil) fue EMACS (y llevaba un par de años buscando un editor de texto para Windows, aunque sin éxito).

Lo único que echaba de menos son programas para edición de vídeo, y de hecho me he tirado unos cuantos años sin hacer ningún montaje grande por esto mismo (con muchos de los programas existentes se puede montar vídeo, pero no se consigue mucha estabilidad), para mí la balanza no tiraba tanto en ese sentido. Aunque parece ser que ahora con Openshot hay una esperanza.

Tras mi experiencia he de decir que las curvas de aprendizaje de Windows y GNU/Linux son muy diferentes, mientras que en Windows llega un punto en el que te estancas (aunque aprendes algo, pero ya sea por poco interés, por no querer indagar más, pereza, etc, ya no aprendes demasiado), en GNU/Linux nunca dejas de aprender cosas todos los días; aunque lo más importante es que lo considero un sistema altamente productivo: hago más cosas en menos tiempo y además no tengo estrés añadido (como cuando llevaba 3 días con Windows sin reiniciar, ahora mismo tengo un uptime (tiempo encendido) de 25 días y no hay pérdida de rendimiento), es un sistema seguro (en 6 años, sólo he tenido un problema de seguridad en uno de mis equipos directamente conectados a Internet (sin router) y fue por no instalar una actualización crítica del núcleo; en cambio con Windows no era la primera vez que malgastaba una tarde entera (o varios días) en intentar limpiar un virus que acababa de salir a la luz, el antivirus no se había enterado y se iba a comer mis datos; o trabajar durante un día para averiguar qué le pasa a un programa que ha dejado de funcionar de un día para otro y terminar formateando.

Es un sistema que me hace sentir más cómodo trabajando, y en mi tiempo de ocio, apenas hay sorpresas (ojo, que a veces se cuelga, y tiene sus pataletas, pero en mucha menor medida, y el 80% de las veces, en mi experiencia, ha sido problema de hardware; como curiosidad, la última vez que me pasó fue problema de un cable de corriente suelto en un disco duro SATA)

No suelo hacer un post sólo para enlazar un artículo, pero este me ha parecido interesante.

Y es que muchos vez un cambio a Linux como algo oscuro y siniestro, pero hay personas que consideramos el cambio a Windows como algo tremendamente difícil.

La pesadilla de cambiarse a Windows - Paraíso Linux

Personalmente, ¿ por qué uso Linux ?

• Me hace más productivo
• Me da más sensación de seguridad
• Me permite hacer más cosas
• Me gusta aprender algo cada día

Todo va mucho más allá de la filosofía del software libre.

GCC compila y linka automáticamente, nos devuelve un ejecutable directamente:

$ gcc -o ejecutable fuente.c

pero en realidad, aparte de pre-procesar y compilar, enlaza algunas bibliotecas del sistema para que nuestro ejecutable funcione bien. Sólo por jugar un poco, veamos, más o menos (depende del sistema) cómo obtener el ejecutable a mano, es decir, compilamos por un lado, y linkamos por otro.

Primero, creamos un programa sencillo, un hello.c que contenga lo siguiente:

Ahora obtenemos el fichero objeto, nuestro código compilado de la siguiente manera:

$ gcc -c hello.c

Veremos que se ha generado el fichero hello.o ; éste fichero aún no lo podremos ejecutar, ya que no tenemos las librerías del sistema necesarias para ello.

Ahora obtendremos el fichero ejecutable con el linkador:

ld -o hello -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 /usr/lib/crt1.o /usr/lib/crti.o /usr/lib/gcc/i686-pc-linux-gnu/4.2.3/crtbegin.o -L/usr/lib/gcc/i686-pc-linux-gnu/4.2.3 hello.o /usr/lib/gcc/i686-pc-linux-gnu/4.2.3/crtend.o /usr/lib/crtn.o -lc

Debemos cambiar /usr/lib/gcc/i686-pc-linux-gnu/4.2.3 por la ruta correspondiente en nuestro equipo; los archivos necesarios se encontrarán en en el directorio de GCC, tras seleccionar la arquitectura y SO correspondiente (en mi caso i686-pc-linux-gnu), y dentro de ese directorio encontraremos otro correspondiente a la versión de GCC (en mi caso la 4.2.3).

Más o menos lo que vemos en el proceso de linkado es lo siguiente:

• -o hello : es el nombre del ejecutable
• -m elf_i386 : es el tipo de ejecutable y la arquitectura. También puede ser elf_x86_64 si tenemos las bibliotecas necesarias.
• -dynamic-linker /lib/ld-linux.so.2: es el cargador dinámico
• /usr/lib/crt1.o /usr/lib/crti.o: son dos objetos encargados de la inicialización de memoria del programa
• /usr/lib/gcc/i686-pc-linux-gnu/4.2.3/crtbegin.o : indica cómo tiene que empezar el programa.
• /usr/lib/gcc/i686-pc-linux-gnu/4.2.3/crtend.o : indica cómo tiene que terminar el programa
• hello.o : es el objeto de nuestro programa.
• -L/usr/lib/gcc/i686-pc-linux-gnu/4.2.3 : hacemos que el linkador busque bibliotecas en el directorio indicado.
• /usr/lib/crtn.o : realiza tareas de limpieza de memoria.
• -lc: incluye la librería de C estándar.

Los archivos que empiezan por crt* normalmente se encargan de poner los datos que nos entran en su sitio; parece que el hecho de coger los parámetros que nos pasan por la línea de comandos y colocarlos en memoria para que nuestro programa los lea es tarea fácil, y que luego nuestro programa devuelva una respuesta; y además, los programas no se ejecutan siempre en la misma posición de memoria, depende de la memoria que haya libre, eso lo suele controlar el S.O. pero nuestros ejecutables tienen que estar preparados… en definitiva, hay muchos agentes involucrados.

Una vez hecho esto, tenemos nuestro hola mundo preparado para ser ejecutado.

Debo agradecer a Carlos, que me dio la idea de escribir este artículo.