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.

¿Alguna vez has querido hacer tu propia aventura gráfica, pero no tienes los conocimientos suficientes para ello, o simplemente no te apetece o no tienes tiempo para aprender cierto lenguaje (ya sea estándar como C o ‘dedicado’ como DIV2/Fenix) o librería de programación (SDL, Allegro, etc.) para cumplir tu sueño? En ese caso, estimado lector, lo que necesitas es Adventure Game Studio, cuyas características principales son:

* IDE basado en Windows para crear tus juegos lo más rápido y fácilmente posible.
* Versiones nativas del motor para Windows, Linux (x86) y MS-DOS.
* Lenguaje de scripting à là C si no te gusta usar ventanitas, aunque la mayoría de las cosas se pueden hacer con ratón.
* Soporte de color de 8, 16 y 32 bits, éste último con canal alpha si se desea.
* Resoluciones de 320×200, 320×240, 640×400, 640×480 y 800×600, tanto en ventana como a pantalla completa.
* OGG, MP3, WAV, MOD, XM y MIDI para sonido y música. Sonido ambiental dependiente de la localización, sonidos automáticos para los pasos, múltiples canales de sonido, crossfading.
* Soporte de texto hablado; la voz es compilada en un archivo opcional (es decir, el juego funcionará sin voces si no las tienes, pero funcionará).
* Respuesta a eventos programada mediante el interfaz o vía scripts.
* Gestión sencilla de inventario.
* Casi todo es personalizable, desde el GUI hasta los gráficos del cursor del ratón.
* Hasta 150 personajes (NPCs) en un mismo juego, cada uno con su propio inventario; que pueden ser escalados, iluminados y moverse en 2, 4 u 8 direcciones.
* Múltiples personajes jugables (como en Maniac Mansion o Day of the Tentacle).
* Salas con scroll.
* Sistema de conversación a lo Lucasarts.
* Las traducciones a otros idiomas se pueden distribuir por separado.
* Sistema de plugins para extender las funcionalidades de AGS.
* El juego se compila a un único EXE. Voz y música se puede almacenar en archivos separados.
* El script del juego se compila a bytecode cuando se salva el juego para que el motor vaya más rápido.
* Y el resto de cosas que podrías esperar: cargar/salvar partidas, objetos, animaciones, cutscenes, etc.

Algunas imágenes de juegos creados con AGS:





Lo bueno:
+ Es gratuíto.
+ Obtienes resultados en poco tiempo, ya que no tienes que aprender a usar ningún lenguaje o librería.
+ Puedes centrarte en la parte artística y jugable.
+ Los juegos corren en diferentes S.O (Windows, Linux, DOS)
+ Contenidos extra (voz, traducciones) pueden distribuírse aparte sin afectar al ‘núcleo’ del juego.

Lo malo:
- No es open source (al parecer, el autor escarmentó con su anterior proyecto libre, que fue ‘fusilado’ y vendido por parte de un listillo).
- Si quieres aprender a programar un juego como en la vida real, esto no es lo que buscas.
- Si necesitas hacer cosas muy específicas es mejor que te programes tu propio motor.
- El IDE sólo corre en Windows.

Sitio oficial

Algún día este mockup mio se hará realidad...

(qué profesional parece y todo)

Pues estas son algunas de las preguntas que un aspirante tuvo que contestar. No son los enunciados exactos ya que todo entrevistado se encuentra bajo NDA:


- ¿Por qué las tapas de alcantarilla son redondas?

- Un hombre se estrelló con su coche contra un hotel y perdió su fortuna, ¿qué ocurrió?

- Explica el significado de 'dead beef'.

- Escribe un programa en C que mida la velocidad de un cambio de contexto en un sistema UNIX/Linux.

- Dada una función que genera un entero aleatorio entre 1 y 5, escribe una función que produzca un entero al azar entre 1 y 7.

- Describe el algoritmo para recorrer un grafo en profundidad.

- Diseña una biblioteca de clases para escribir juegos de cartas.

- Necesitas comprobar que tu amigo Bob tiene tu número de teléfono correcto, pero no se lo puedes preguntar directamente. Tienes que escribir una pregunta en una tarjeta y dársela a Eve para que se la dé a Bob y éste escriba su respuesta. ¿Qué tienes que escribir en la tarjeta, además de la pregunta, para que Eve no sepa cuál es tu número?

- ¿Cómo se pasan las cookies en el protocolo HTTP?

- ¿Cuál es el tamaño de la siguiente estructura C en un sistema de 32 bits? ¿Y en uno de 64?

struct foo {
       char a;
       char* b;
};


- Diseña las tablas de una base de datos SQL para un servicio de alquiler de coches.

- Escribe una expresión regular en la que encajen las direcciones de correo electrónico.

- Escribe una función f(a, b) que tome dos strings y devuelva otro que solamente contenga aquellos caracteres que se encuentren en ambos, en el orden presente en a. Escribe una versión O(n^2) y otra O(n).

- Te dan el código fuente de una aplicación que casca al ejecutar. Después de probarlo 10 veces en el depurador, ves que nunca rompe en el mismo sitio. La aplicación solo tiene un hilo de ejecución y no usa más que la librería estándar de C. ¿Qué errores de programación pueden estar haciendo que casque? ¿Cómo lo probarías?

- Explica como funciona el control de congestion del protocolo TCP.


¿Cuántas eres capaz de contestar? ¿Podrías estar trabajando en Google? ¡Pues corre!

Extraído de aquí y traducido por un servidor.

En este pasado Siggraph se ha presentado una novedosa técnica para redimensionar imágenes denominada 'Seam Carving for Content-Aware Image Resizing', algo así como 'Redimensionado de Imágenes Basado en Contenido mediante Zurzido' (es posible que lo de zurzido sea una parida pero no se me ocurre mejor forma de traducir eso xD).

El algoritmo, desarrollado por Shai Avidan y Ariel Shamir del Efi Arazi School of Computer Science, permite reescalar imágenes de forma parecida a como un navegador recoloca el texto de una web cuando se redimensiona su ventana o se muestra en un dispositivo con una pantalla de distinto tamaño. La técnica se basa en encontrar las zonas menos importantes de la imagen y prescindir de ellas sin perder información relevante.

Es algo difícil de explicar con palabras, mejor verlo en un vídeo:

Obviamente, uno de sus creadores ahora trabaja en Adobe xD

De nuevo algo nombrado mediante un estúpido juego de palabras! xD (organize+nice). Esta vez no haré un FAQ como en el caso de FIC.tion porque me da pereza xD Así que me limitaré a comentar un poco de qué va y enseñar unas capturas...

orgaNice! es el resultado de una de las prácticas de la asignatura de Interfaces con el Usuario (IU), consistente en diseñar e implementar el interfaz de una agenda en Java+SWT o Python+pyGTK (en mi caso, Java+SWT). Como el profesor no especificó, de forma deliberada, qué se entiende por una agenda, teníamos bastante libertad para incluir lo que quisiésemos. Yo he optado por, aparte de las típicas funcionalidades de gestión de tareas y contactos, implementar un lector de noticias (estilo RSS), un cliente de correo y un sistema de consulta meteorológica.
Ya que la asignatura trata de interfaces, no era necesario que ninguna de las funcionalidades realmente hiciese algo (por ejemplo, la consulta del tiempo podría simplemente cargar una imagen con las temperaturas y siempre la misma, independientemente de la ciudad), bastaba con que la interfaz diese la opción de hacer ese algo. De todas formas, mi práctica contiene alguna funcionalidad que de verdad es útil.



Éste es el aspecto general de orgaNice!: una zona principal a la izquierda, un calendario y una lista rápida. Cada funcionalidad es accedida mediante las pestañas superiores, mientras que el calendario nos lleva a la agenda, al dia seleccionado. La lista rápida nos muestra los eventos que tenemos programados en los próximos 7 días.
Cada evento del día consta de una hora de comienzo y una descripción breve, que puede expandirse mediante el icono [+]


En la sección de contactos tenemos una lista que muestra la información sobre la que se suele buscar típicamente. Las columnas se pueden reordenar de cualquier forma y ordenar las filas en orden ascendente o descendente por cualquier campo.
Cuando se selecciona un contacto aparece más información en la parte inferior. Además, se puede buscar por cualquier campo de los de la tabla.



Las secciones de noticias e e-mail son muy similares: a la izquierda se elige el canal/cuenta de correo deseado y se muestran a la derecha las noticias/correos correspondientes. Al seleccionar una noticia/e-mail, se muestra en la parte inferior. El lector de RSS no funciona completamente, simplemente guardo una serie de titulares y URLs para mostrar (pero la web mostrada sí es la real y se accede de verdad a ella). Igualmente, el gestor de correos es de pega y en este caso los e-mails son simples cadenas de texto.


La sección de predicción meteorológica permite elegir unas cuantas ciudades del mundo y consultar la previsión para el día de hoy. La predicción es real, gentileza de Yahoo Weather.

También tiene un soporte inacabado para añadir/eliminar/editar eventos/contactos/canales RSS/cuentas de correo/fuentes de predicción, pero por el momento toda la información se extrae de ficheros auxiliares, siendo la agenda prácticamente de 'sólo lectura'.

Como siempre, críticas, comentarios, preguntas son bienvenidas :]

Seguimos comentando los lenguajes vistos en la carrera. En esta ocasión, los analizados son los siguientes:



Caml

Un engendro declarativo perpetrado por los inefables gabachos del Inria, como siempre jodiendo al estudiante con sus creaciones. En nuestro caso, tenemos que sufrir el maldito Caml en hasta TRES asignaturas: Programación Declarativa, Tecnología de la Programación (asignatura más estúpida no he visto en mi vida) y Teoría de Autómatas y Lenguajes Formales.

Será que no nos enseñan una mierda en PD, con ejemplos que hasta un simio entendería (del tipo let x=5 in x+3;), o que los lenguajes declarativos no se me dan especialmente bien (odio no decir exactamente cómo se tienen que hacer las cosas)... el caso es que no soporto este lenguaje y se me hizo bastante cuesta arriba en asignaturas posteriores (afortunadamente, esas prácticas las hacía mi compañero xD). Vendido por el profesor de PD como la panacea que supera a cualquier lenguaje imperativo (o casi), a final de curso resulta que el Caml de marras también posee estructuras típicas de los lenguajes estructudos (bucles, condicionales)... ¿pero no era tan autosuficiente y fantástico?

Pros
- Tiene nombre de animal, lo cual es divertido.

Contras
- Simplemente es odioso (lo siento, no puedo ser imparcial!).



Ensamblador MIPS

Un lenguaje para verdaderos hombres, no como ese Caml que te hace las cosas solo, psss...
Ensamblador permite un contacto directo con la máquina igual que programar a base de ceros y unos, pero con la ventaja de que es más comprensible gracias a mnemotécnicos y etiquetas. Este 'tú a tú con el hardware' posibilita hacer código condenadamente rápido y eficiente... si sabes hacerlo claro.
En el caso de MIPS, tenemos un ASM bastante regular en mnemotécnicos, sintaxis, sin modos de direccionamiento especialmente rebuscados... lo cual es de agradecer.

Pros
- Rápido y eficiente hasta el extremo...
- ... si te preocupas por programar bien, lo cual puede ser una motivación (¿cuántos ciclos de ejecución puedo recortar?)
- Útil para aprender cómo funcionan realmente las cosas por dentro (registros, direccionamiento, buses, formatos de instrucción, etc.)

Contras
- No es tan fácil de usar en principio como lenguajes de más alto nivel.
- Código difícil de comprender y mantener.
- Al estar tan próximo al hardware, es lo menos portable que existe.

Más en próximos capítulos =)