Ahora que Ubuntu, en su versión 7.10 (Gutsy), viene con Compiz Fusion por defecto, no estaría mal completar la 'experiencia' de usuario con una barra dock con estilo.

Que a todo esto, quizá hay quien no conozca Compiz Fusion; con el siguiente video se hará una ligera idea de su potencia:

El tutorial es una simple traducción del que se puede encontrar en los foros de Ubuntu, pero como mucha gente no conoce esta aplicación, la doy a conocer aquí :]

NOTA: El procedimiento está probado para Gutsy de 32 y 64 bits, no sé si con otras distribuciones o versiones de Ubuntu irá con tanta facilidad.

Instalación

Primero, añadid el repositorio de AWN:

echo 'deb http://download.tuxfamily.org/syzygy42 gutsy avant-window-navigator
deb-src http://download.tuxfamily.org/syzygy42 gutsy avant-window-navigator' | sudo tee -a /etc/apt/sources.list

Ahora añadid la clave apt:

wget http://download.tuxfamily.org/syzygy42/reacocard.asc
sudo apt-key add reacocard.asc
rm reacocard.asc

Y ahora instaladlo:

sudo apt-get update
sudo apt-get install avant-window-navigator-bzr awn-core-applets-bzr


Y ya está, muy sencillo como podéis comprobar =)

FAQ

¿Cómo ejecuto AWN?

En un terminal, avant-window-navigator &

¿Cómo hago para que AWN arranque al inicio?

En Ubuntu, vas a Sistema > Preferencias > Sesiones. Ahora añade una entrada para el comando 'avant-window-navigator'

¿Como añado un lanzador al dock?

Hay dos formas: la primera es simplemente arrastrar un lanzador ya creado a la barra; la segunda, consiste en ir al gestor del AWN (click derecho sobre el dock) e ir al apartado Launchers.

He añadido un lanzador y le he puesto un icono pero no se ve, ¿qué pasa?

Parece ser un bug de AWN. La solución cutre es crear un lanzador en el escritorio, ponerle un icono y arrastrarlo al dock.

Un código fuente ofuscado es aquél que, deliberadamente, se ha escrito de tal forma que es muy complicado de leer y/o entender. No hay que confundirlo con código que por su complejidad algorítmica, de estructuras de datos, llamadas a funciones extrañas, etc. es díficil de saber qué hace, ya que el programa más trivial que se te pueda ocurrir, si está ofuscado, es muy complicado de entender.

Siempre me había preguntado qué técnicas se usan para encriptar código. Afortunadamente, en la Wikipedia hay un ejemplo paso a paso que muestro a continuación:

void primes(int cap) {
 int i, j, composite;
 for(i = 2; i < cap; i++) {
   composite = 0;
   for(j = 2; j < i; j++)
     composite += !(i % j);
   if(!composite)
     printf("%d\t", i);
 }
}

int main() {
 primes(100);
}


Este programa no hace más que imprimir los números primos menores que 100. Veremos que con unas cuantas transformaciones lo podremos convertir en algo así:

_(__,___,____){___/__<=1?_(__,___+1,____):!(___%__)?_(__,___+1,0):___%__==___/
__&&!____?(printf("%d\t",___/__),_(__,___+1,0)):___%__>1&&___%__<___/__?_(__,1+
___,____+!(___/__%(___%__))):___<__*__?_(__,___+1,____):0;}main(){_(100,0,0);}


Que parece un poco más difícil de entender xD Los pasos seguidos han sido los siguientes:

Reescribir el cuerpo de la función como un único while con estructuras if-else en su interior:

void primes(int cap) {
 int i, j, composite, t = 0;
 while(t < cap * cap) {
   i = t / cap;
   j = t++ % cap;
   if(i <= 1);
   else if(j == 0)
     composite = 0;
   else if(j == i && !composite)
     printf("%d\t",i);
   else if(j > 1 && j < i)
     composite += !(i % j);  
 }
}

int main() {
 primes(100);
}

Sustituir el bucle while por una serie de llamadas recursivas:

void primes(int cap, int t, int composite) {
 int i,j;
 i = t / cap;
 j = t % cap;
 if(i <= 1)
   primes(cap,t+1,composite);
 else if(j == 0)
   primes(cap,t+1,0);
 else if(j == i && !composite)
   (printf("%d\t",i), primes(cap,t+1,0));
 else if(j > 1 && j < i)
   primes(cap,t+1, composite + !(i % j));
 else if(t < cap * cap)
   primes(cap,t+1,composite);
}

int main() {
 primes(100,0,0);
}

Sustituir los if-else por el operador ternario a?b:c. Por ejemplo, if(a) b else if(c) d else e equivale a a?b:c?d:e:

void primes(int m, int t, int c) {
 int i,j;
 i = t / m;
 j = t % m;
 (i <= 1) ? primes(m,t+1,c) : (j == 0) ? primes(m,t+1,0) : (j == i && !c) ?
 (printf("%d\t",i), primes(m,t+1,0)) : (j > 1 && j < i) ?
 primes(m,t+1,c + !(i % j)) : (t < m * m) ? primes(m,t+1,c) : 0;
}

int main() {
 primes(100,0,0);
}

Sustituir las variables i y j por sus valores (t/m) y (t%m):

void primes(int m, int t, int c) {
 ((t / m) <= 1) ? primes(m,t+1,c) : !(t % m) ? primes(m,t+1,0) :
 ((t % m)==(t / m) && !c) ? (printf("%d\t",(t / m)), primes(m,t+1,0)) :
 ((t % m)> 1 && (t % m) < (t / m)) ? primes(m,t+1,c + !((t / m) % (t % m))) :
 (t < m * m) ? primes(m,t+1,c) : 0;
}

int main() {
 primes(100,0,0);
}

Renombrar la función primes y las variables m, t, y c a _, __, ___, ____, respectivamente:

void _(int __, int ___, int ____) {
 ((___ / __) <= 1) ? _(__,___+1,____) : !(___ % __) ? _(__,___+1,0) :
 ((___ % __)==(___ / __) && !____) ? (printf("%d\t",(___ / __)),
 _(__,___+1,0)) : ((___ % __) > 1 && (___ % __) < (___ / __)) ?
 _(__,___+1,____ + !((___ / __) % (___ % __))) : (___ < __ * __) ?
 _(__,___+1,____) : 0;
}

int main() {
 _(100,0,0);
}

Eliminar espacios en blanco, tipos innecesarios y paréntesis superfluos:

_(__,___,____){___/__<=1?_(__,___+1,____):!(___%__)?_(__,___+1,0):___%__==___/
__&&!____?(printf("%d\t",___/__),_(__,___+1,0)):___%__>1&&___%__<___/__?_(__,1+
___,____+!(___/__%(___%__))):___<__*__?_(__,___+1,____):0;}main(){_(100,0,0);}


Y éste ha sido el briconsejo de hoy :] Los amantes del riesgo podéis probar a entregar una práctica de, por ejemplo, Sistemas Operativos con un código de este estilo xD

Introducción
Petrovich es más que un lenguaje de programación, es un sistema operativo completo y un entorno de desarrollo. Recibe su nombre de Ivan Petrovich Pavlov, el tipo que demostró que los perros reaccionaban de forma condicionada a los estímulos recibidos. Se le podría haber llamado 'Pavlov' pero parece que todos los nombre molones ya están en uso.

Principios de Diseño
* Proporcionar un SO y un lenguaje capaces de aprender y mejorar su rendimiento de forma natural.
* Adaptarse a la entrada del usuario de forma inteligente

Conceptos del Lenguaje
Petrovich proporciona dos métodos de influir en su comportamiento: recompensas y castigos. Cuando Petrovich hace algo que el usuario no quiere, éste puede castigarlo. Asimismo, si Petrovich hace algo útil, el usuario puede premiarlo. Petrovich adapta su comportamiento para evitar los castigos y disfrutas de más premios.

Comandos
Petrovich es muy simple de usar ya que sólo posee cuatro comandos. Normalmente se escriben en modo interactivo; también hay disponible una versión con scripts, pero sólo se recomienda a usuarios avanzados.

   > do something
     hace que Petrovich haga algo
   > do something with <file>
     hace que Petrovich haga algo con ese archivo
   > reward
     recompensa a Petrovich
   > punish
     castiga a Petrovich

Ejemplos
Para entender cómo funciona Petrovich, lo mejor es servirse de algunos ejemplos. A continuación se muestra una sesión ejemplo de Petrovich, anotada con comentarios.

Petrovich> do something
11:15:23 11 June 2005
Petrovich> reward
Petrovich>

El usuario le pide a Petrovich que haga algo, y éste responde con la hora y fecha actuales. Como ha sido útil para el usuario, éste le recompensa.

Petrovich> do something with data_run_20050711.txt
plotting data to printer
Petrovich> punish
Petrovich> do something with data_run_20050711.txt
performing Fast Fourier Transform...
saving result to data_FFT_20050711.txt
Petrovich> reward
Petrovich>

El usuario le pide a Petrovich que haga algo con datos científicos. Primero se le ocurre imprimirlos. Como no es lo que el usuario quería, le castiga y prueba otra vez. Como no quiere que le castiguen otra vez, Petrovich prueba otra cosa; en esta ocasión realiza una operación util para el usuario. Para reforzar este comportamiento, el usuario premia a Petrovich.

Petrovich> do something with HalleBerry001.jpg
file deleted
Petrovich> punish
Petrovich> do something with HalleBerry002.jpg
searching web for similar images...
downloading...
Petrovich> reward
Petrovich>

El usuario le pide a Petrovich que haga algo con una foto picantona, y Petrovich borra el archivo. El usuario no quería que pasase eso, aquí que lo castiga. Ahora el usuario le pide que haga algo con otro archivo. Esta vez, escarmentado, Petrovich hace una búsqueda web buscando imágenes similares para añadirlas a la colección porno del usuario. El usuario premia a Petrovich.

Debería quedar claro gracias a estos ejemplos que Petrovich es increíblemente potente y que puede hacer cualquier cosa para manejar cualquier situación.

Y en caso de que pienses que esto es una broma, imagina una capa Petrovich sobre otro SO, por ejemplo Windows. Cada vez que Windows haga algo que no te gusta, podrías castigarlo y nunca lo volvería a hacer...

Fuente

MenuetOS es un sistema operativo para PC escrito totalmente en ensamblador de 32 y 64 bits. Soporta aplicaciones escritas en ese mismo lenguaje, de forma que son pequeñas, rápidas y consumen pocos recursos.

Menuet no está basado en UNIX ni en ningún otro sistema operativo. Se ha diseñado con el fin de eliminar ciertas capas del SO que son propensas a errores y complican la programación.

Algunas de sus características son:

- Multitarea apropiativa, ejecución multihilo, protección de tres niveles.
- Interfaz gráfica que soporta hasta 1280x1024x16M.
- IDE de macroensamblador para programar aplicaciones.
- Pila TCP/IP con interfaz de loopback y drivers Ethernet.
- Clientes y servidores FTP/HTTP.
- Ventanas de aplicación de formas libres, drag & drop.
- Captura de datos desde el disco en tiempo real.
- Ocupa un solo diskette.

Algunas imágenes de esta proeza de la programación:




MenuetOS es gratuíto y puede ser descargado desde aquí en formato imagen de diskette. Además, por 15 euros te mandan a casa un CD con el sistema operativo más algunos extras como las versiones shareware de Doom (!), Quake (!!) o emuladores como Dosbox y ScummVM.

Estos días he estado escuchando el 10 Years de Armin y he pasado de los temas míticos (Communication, Blue Fear, etc.) e intentado prestar más atención a aquéllos que pasan más desapercibidos, como éste por ejemplo:

Título: Simple Things (Arxel Shortcut).
Autor: Armin van Buuren feat. Justine Suissa.
Género: Vocal Trance.
Año: 2006.

Por algún extraño motivo, estando en clase se abrió este discusión cuya resolución es vital para la realización de cualquier ser humano: ¿Qué es Pincho, uno de los personajes de la mítica serie de animación Los Fruitis? Las dos opciones mayoritarias (en realidad únicas, ya que nadie ha dicho destornillador o mesa plegable por el momento) son cáctus e higo chumbo, opciones que provocan una división de opiniones sin precedentes desde que comenzaron las luchas Barça vs. Madrid, PP vs. PSOE o 'Nintendo inventa'-'Nintendo no inventa' (La verdad duele, y'know).

El sujeto a estudiar

Los argumentos esgrimidos a favor y en contra de una postura (>>> u otra (<<< son aproximadamente los siguientes:

>>> (Razonamiento abductivo)
   H1: El tipo se llama Pincho
   H2: Los cáctus tienen pinchos
   ------------------------------------------
   Pincho es un cáctus

<<< Ese razonamiento no me sirve, ya que la piña se llama Gazpacho (?) y el plátano Mochilo (??)

<<< Además, que Pincho sea un cáctus entre un grupo de frutas es tan lógico como el conjunto {azul, rojo, carburador, amarillo}

>>> Que no tío, aunque la serie se llame Los Fruitis en realidad abarcaba un espectro más amplio: los vegetales. Por tanto, un cáctus encaja perfectamente.

<<< Menudo apaño cutre... ¿A que no has visto un higo chumbo nunca? ¡Mira!

>>> QUE ES UN CÁCTUSSS!!!!11#@#~%&(2 0xBFF75643 SEGMENTATION FAULT

Creo que no hace falta decir de qué parte estoy yo, ahora os toca opinar a vosotros :]