Eclipse instalando el plugin de Android (ADT) en Linux

Si habeis instalado Eclipse mediante el Centro de Software Ubuntu, puede que tengais problemas siguiendo el procediemiento que explica Google.

Por tanto, probar hacerlo mejor así:

1. Se supone que ya teneis instalado el paquete eclipse, instalar además el paquete: sudo apt-get install eclipse-jdt eclipse-pde , tal y como explica el Bug #477944 (aunque esta un poco caótico).
2. Ahora debeis ejecutar Eclipse y en Help -> Install new software, debeis añadir estos 2 sitios:
   • Galileo – http://download.eclipse.org/releases/galileo/
   • Google Android – https://dl-ssl.google.com/android/eclipse/
3. Ahora simplemente instalais «Developers Tools», que activará automaticmante «Android DDMS» y «Android Development Tools». Tendreis que aceptar todas las licencias que corresponda.
4. Fin, ya podemos crear un proyecto. Tengo pensado publicar un trabajo que estoy haciendo de Android y explicar un poco hacer un HolaMundo en cuanto tenga tiempo.

Espero que le sea útil a alguien. Un saludo

Fuentes:
http://developer.android.com/sdk/eclipse-adt.html
https://bugs.launchpad.net/ubuntu/+source/eclipse/+bug/482244
https://bugs.launchpad.net/ubuntu/+source/eclipse/+bug/477944

Habrá Steam para Linux

Hace unos días, Valve ha lanzado la versión de Mac de Steam por todo lo alto, acompañado de ofertas y regalando el Portal.

En un artículo en el Telegraph se ha dicho:
«Valve has also confirmed that it will make Steam available to Linux users in the coming months.»

Cada vez siento que estamos más cerca de un mercado multiplataforma … pero todavía falta mucho, lo que esta claro es que es un paso importante para el Gaming.

En cuanto al rendimeinto, si Valve ha llevado sus juegos a Mac, que es una plataforma prima respecto a Linux (pero con un rendimiento bastante menor que en Linux como se demuestra en esta benchmark). Tras esta confirmación, Linux ofrece un rendimiento muy ligeramente inferior a windows actualmente, (principalmente por la calidad de los drivers).

Todos estos temas se debaten en este articulo, y llegan a la conclusión de que esta noticia puede representar toda una revolución para el mercado de los videojuegos en Linux:
http://www.phoronix.com/scan.php?page=article&item=valve_steam_announcement&num=1

Ahora solo falta pedir que su cliente  se licencie como GPL, lo cual, conociendo a Valve es casi imposible. Un saludo.

P.D: Me gustaría escribir más, pero este año estoy concentrado en la uni y he abandonado más de lo que me gustaría el wiithon y el blog. ¡¡ Quiero terminar el cuatrimestre !!

Fuentes:
http://www.telegraph.co.uk/technology/apple/7715209/Steam-for-Mac-goes-live.html
http://www.muylinux.com/2010/05/12/ya-es-oficial-%C2%A1steam-estara-disponible-en-linux

Benchmark Factorial – Parámetros acumulados

Voy hacer un benckmark de 3 implementaciones de factorial:

Em primer lugar, la implementación más simple y eficiente, por siempre de los jamases, al menos para arquitecturas de Von Newman y monoprocesador:

long factorial_iterativo(long n)
{
	long i, ac = 1;
	for(i=n; i>0; i--)
		ac = ac * i;
	return ac;
}

Despues esta la recursiva lineal, típico ejemplo de recursividad. Fijaos en la linea de la llamada recursiva …

long factorial_recursivo(long n)
{
	if (n == 0)
		return 1;
	else
		return n * factorial_recursivo(n-1);
}

Y esta es la que realmente tenía curiosidad de comparar.  Es un tipo de recursividad que hace que la vuelta en lugar de ser de pila, sea de cola. Es necesario modificar la interfaz y crear una nueva función manejadora que respete la interfaz. Se trata de ir acumulando el resultado como parametro y principalmente que en la linea que se hace la llamada recursiva, solo haya una llamada recursiva.

Esta función, teoricamente implementado en Caml el compilador al pasarlo a código maquina la pasa a iterativa automaticamente. Si esto fuera tambien así en C, podríamos utilizar funciones recursivas, sin miedo a desbordar la pila y sin problemas de redimiento. Y por supuesto ganando la claridad de resolver algunos problemas de naturaleza recursiva.

long _factorial_recursivo_PA(long n, long r)
{
	if (n==0)
		return r;
	else
		return _factorial_recursivo_PA(n-1, n*r);
}

long factorial_recursivo_PA(long n)
{
	return _factorial_recursivo_PA(n, 1);
}

Los resultados son estos:

Señal SIGCHLD – Evitar Zombies

Hace un par de años hice una práctica de sockets, con el típico modelo cliente-servidor donde el servidor da servicio multicliente con fork(). La práctica cumplía los requisitos y los profesores no detectaron problemas.

Realmente la práctica tenía un bug y es que en ocaciones, se quedaban procesos zombies. Realmente el problema es que confie en el código base que nos daban los profesores, que estaba bugeado. Ahora he tenido que reutilizarla para otra asignatura, y ahora ya se cual era el problema.

En sistemas Unix, un proceso puede tener hijos ¬¬, creados mediante fork. Cuando el hijo termina, se envía la señal SIGCHLD al padre. Por defecto, la señal se ignora y se crea un proceso zombie. El padre debe instalar un manipulador de señales para actuar sobre la señal, ese era mi problema. En algunas plataformas Unix, se pueden evitar los zombies explícitamente ignorando la señal SIGCHLD. Sin embargo, instalar un manipulador de señales para SIGCHLD y llamar a wait es la mejor manera de evitar zombies conservando la portabilidad.
El manipulador de la señal:

void sigchld_handler(int s)
{
    while(wait(NULL) > 0);
}

Hay varias funciones o métodos para setear la señal, os pongo 2, el largo(más portable, POSIX) y el corto(desconozco su portabilidad):

    struct sigaction sa;
    sa.sa_handler = sigchld_handler; // manejador

    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1)
    {
        perror("Error en sigaction");
        exit(1);
    }

Os dejo la forma más corta y fácil:

signal(SIGCHLD , sigchld_handler);

No hace falta decir que necesitais el «signal.h»

Fuentes: http://es.wikipedia.org/wiki/SIGCHLD

Wiithon 1.1 publicado!

Actualizado: sábado, 21 de noviembre de 2009

Bueno por fin publicamos la nueva versión tras casi 5 meses desde el anuncio de la 1.0.
Para mi wiithon me ha aportado mucho en conocimientos, me he acostumbrado tras muchos años de SQL puro, el uso de bases de datos ORM. He aprendido la potencia del combo python + pygtk. He aprendido a crear paquetes deb que siguen las políticas de Debian. Crear manpages, hacerme un repositorio de paquetes, resolver conflictos de bazaar, subir paquetes, comprender los problemas de punteros en 32bits y 64 bits y por último, he aprendido a amar a los Makefiles y esa gran satisfacción de hacer cosas complejas de forma controlada y sencilla.

Sin más rollo os pongo un tutorial mucho más simplificado, si lo comparamos con el de la versión anterior:

1. Novedades
2. Características ya existentes
3. Reporte de bugs
4. Instalación
5. Actualización
6. Uso de Wiithon en Consola (CLI)
7. Descargar código fuente
8. Colaborar en Wiithon
9. Estado de traducción de Wiithon.
10. Team wiithon
11. Pantallazos

Wiithon 1.0 liberado!!

POST ANTICUADO, última versión wiithon: 1.1 https://blogricardo.wordpress.com/2009/11/20/wiithon-1-1-publicado/

Actualizado: martes, 28 de julio de 2009

Creo que ya es el momento de publicar esta versión de wiithon con un GUI basado en GTK. Un desarrollo que empeze en abril, (trás publicar wiithon 0.98) sin tener apenas expriencia en GTK, gracias a Jose Luis Segura(LK2) y Google, he aprendido lo sufuciente en GTK para llegar al punto en el que estamos.

Sin dar más vueltas os expongo ls partes que va a tener esta presentación:

1. Características
2. Descargas
3. Instalación
4. Ejecución
5. Actualización
6. Traducir wiithon
7. Agradecimientos.
8. Team wiithon
9. Screenshots

Espacios en for i in $(ls)

#!/bin/sh

IFS=$'\x0A'$'\x0D' ;
for i in $(find -iname "*.avi"); do
mv -v "$i" . ;
done;

Chuleta:  Para que el for no considere el espacio un separador, y una tarea como la del ejemplo lo realize bien. El script de ejemplo mueve todos los videos de subcarpetas al directorio actual.

Convertir PDF a Texto plano en Linux

Convertir texto en pdf es muy facil con el uso de impresoras de PDF o utilizando openoffice por ejemplo. Para la operación inversa tenemos este comando:

• pdftotext -layout servidor.pdf servidor.c

-layout : Es imprescindible ponerlo, ya que con él guarda la maquetación del pdf original, si no lo poneis se comera todos los saltos de linea, tabuladores y seguramente no sea lo que buscais.
servidor.pdf : Archivo pdf = origen
servidor.c : Archivo texto plano o txt = destino

Aqui pongo este tip, que me ha sido muy util para una práctica que me han dado en pdf, y por copy paste me salía mal. La conversión la hace perfecta excepo en los saltos de página que mete algún caracter utf extraño. Corregirlo no es más que buscar y reemplazar.

Recuperar / Restaurar GRUB pisado por «otro» SO

Cada disco duro tiene un espacio reservado para el MBR. El MBR es el primer mini-programa que arranca la BIOS y objetivo de virus en la época de DOS. Cuando instalamos sistemas operativos egoístas como Windows nos pisa nuestro MBR y pone su gestor de arranque que solo sirve para arrancar particiones FAT32 y NTFS.

1. Nos metemos en la BIOS y preparamos el ordena para arrancar por LIVE y ya que estamos aqui nos aseguramos en el caso de tener más de 1 disco duro, poner el disco duro que va arrancar linux por delante en la secuencia de arranque.
2. Arrancamos con un live de ubuntu 8.04 (por ejemplo), ya que aún faltan 10 días para la 8.10.
3. Montamos la partición que tiene el grub (es decir, la partición que tiene la carpeta /boot). Montamos por interfaz gráfica, por el hecho de entrar a visualizar datos, se automonta. Es importante montar.
4. Necesitamos saber 2 variables:
   • X = el número de nuestro disco duro
   • Y = el número de partición (la que tiene el grub)
5. Podemos ejecutar el gparted ( sudo gparted ) para ver en que posición de la lista pone el disco duro (X) y en que posición esta la partición. También nos podemos apoyar de df, analizamos el nombre lógico que asigna Linux a la partición. Por ejemplo /dev/sda2 . La letra «a» indica el primer disco duro y el 2 que es la segunda partición.
6. Teniendo nuestro X y nuestro Y le restamos 1 a ambos, debido a que la numeración de GRUB empieza por 0. Algunos ejemplos de como quedaría la cosa:
   • X=0,Y=0: es la primera partición del primer disco duro, al igual que hda1 o sda1
   • X=0,Y=1: es la segunda partición del primer disco duro, al igual que hda2 o sda2
   • X=1,Y=2: es la tercera partición del segundo disco duro, al igual que hdb3 o sdb3
7. Sabiendo eso el resto es fácil, abrimos un terminal y escribimos.
   • sudo grub para entrar en el intérprete del GRUB
   • En los 2 siguientes comandos os recuerdo que hay tener en cuenta el punto 6.
   • Indicamos en que partición esta ubuntu escribiendo (importante el espacio despúes del root): root (hdX,Y)
   • Finalmente instalamos GRUB en el MBR del disco X, para ello escribimos (importante el espacio despúes del setup) : setup (hdX)
   • Salimos de grub escribiendo : quit y reiniciamos : sudo reboot

Fuentes:
http://www.guia-ubuntu.org/index.php?title=Recuperar_GRUB

Freeze en linux

Aunque es improbable que ocurra un cuelgue en Linux puede ocurrir por varios motivos.
Los programas pueden ejecutarse en el espacio de usuario(con restricción de instrucciones) o en espacio del sistema (acceso total a todo el conjunto de instrucciones).
A diferencia de windows(un cuelgue de calculadora te podría matar el sistema) un cuelgue es el espacio de usuario no cuelga el sistema aunque puede hacerte estragos, especialmente si consume el 100% de la CPU, a pesar de estar en el espacio de usuario.
Cuando un proceso en el espacio de usuario se comporta erráticamente y es proceso «manifestado» en una ventana usaremos «forzar el cierre» o simplemente cerramos y GNOME debería proponer un forzar cierre. Si esto no nos sirve ya sea por que no cierra o es un proceso oculto, nos iremos a un terminal con la combinación CTRL + ALT + F1, y desde hay con los comandos: ps aux, kill -9, killall o htop solucionamos el problema, también es útil saber que estando en GNOME con la conbinación CTRL + ALT + BACKSPACE mata e inicia GNOME.

Bueno hasta aqui, no creo a ver dicho nada nuevo para la mayoría. En linux los únicos programas que se ejecutan con todas las instrucciones de ensamblador disponibles son: El kernel de linux y sus modulos adjuntos a este. Sólo estos dos podrían generar un freeze , incluidos el módulo de por ejemplo el virtualbox. Por tanto si hemos recibido algún freeze total(solo soluciona el reinicio) debemos revisar nuevos modulos que hayamos instalado, especialmente los modulos de propietarios que son los que más bugs suelen traer debido a que es dificil integrar una caja negra en un sistema que destaca por su transparencia.

No obstante si alguna vez nos pasara un freeze total, deberiamos realizar lo siguiente en lugar de reiniciar:

Pulsamos las teclas ALT y la de «Imprimir pantalla», y sin soltar el ALT, el Imprimir pantalla si puedes soltarlo, vamos escribiendo letra a letra REISUB (os podeis formar una memotecnia fácil con REI y SUB, prefiero no decir la mía : D). Con esto logramos reiniciar nuestro sistema de manera segura ya que según vamos pulsando las teclas vamos mandando una orden a nuestro sistema, tales como:

R.- Devuelve el control al teclado (Raw)
E.- Manda todos los procesos al term, es decir, los hace terminar (End)
I.– Manda los procesos al Kill, es decir, los mata.
S.- Sincroniza el disco duro (Sync)
U.- Desmonta todos los sistemas de ficheros (Unmount)
B.- Por último, reinicia el ordenador. (reBoot)

Otra forma que en lugar de reiniciar, lo deja apagado sería en lugar de REISUB, el combo mágico sería REISUO

Fuentes :
http://en.wikipedia.org/wiki/Magic_SysRq_key
http://www.esdebian.org/foro/25034/reisub-yo-que-quiero-apagar

Amarok : Teclas multimedia sobre GNOME

Me han convencido a probar amarok en sustitución a rhythmbox una temporada, la verdad que es muy completo, tiene un mejor soporte de ipod, tiene buen soporte de podcast, radios shoutcast … una maravilla el único problema es que las teclas multimedia no me funcionan en gnome. Buscando plugins para amarok he encontrado este plugin para Amarok que soluciona el problema.

• Nos bajamos el archivo y lo almacenamos en nuestro pc.
• En el amarok. Herramientas -> Gestor de scripts -> Instalar el script y seleccionamos el archivo que acabamos de bajar.
• Si no os funciona comprobar que teneis los paquetes (python-dbus y libdbus-glib)
• Por último para configurar las teclas que queremos usar solo hay que ir a “Sistema–>Preferencias–>Atajos de teclado” y listo

Fuente : http://www.otrobloggeek.com/blog/2008/02/howto-teclas-multimedia-en-amarok-usando-ubuntu-con-gnome/

GetDeb se especializa: repositorio de juegos PlayDeb

Llevamos tiempo disfrutando de los repositorios de GetDeb pero según pone en el blog de getdeb , se ha creado el proyecto playdeb, que tratara de centrarse exclusivamente en ser el principal repositorio de juegos de ubuntu.
– Para instalar el repositorio sólo hay que ir a Sistema -> Administración -> Orígenes del Software y en la pestaña de Software de terceros hacer click sobre Añadir y pegar la siguiente línea:

deb mirror://www.getdeb.net/playdeb-mirror/hardy/// hardy/

Una vez recargada la lista, desde el Menú principal -> Añadir y quitar se puede acceder a todos los juegos e instalarlos cómodamente.
Otra forma es ir a esta lista de juegos de PlayDeb y gracias al protocolo apt:// podemos instalar juegos con un simple click desde el hipervínculo.

Unison: Sincronización de carpetas en local o remoto

Os pondre un ejemplo para sincronizar dos carpetas remotas, Unison en remoto usa ssh. Asi que necesitamos instalar ssh y unison. Asi que lo primero :

sudo apt-get install ssh unison unison-gtk

Con esto nos instala un cliente de SSH, pone un servidor de SSH en el puerto por defecto. Y además porsupuesto el unison y su interfaz gráfico.

Me voy a basar en un ejemplo para sincronizar los mapas del Warcraft III. Para serviriía evidentemente para sincronizar 2 carpetas cualesquiera.

Son 2 portatiles en LAN con IPs 192.168.1.4 y 192.168.1.5. Ambos PCs juegan bastante mapas muy variados y al poco tiempo un ordenador tiene más mapas que otro, o tiene más mapas de tipo td, vampiro y menos de otro tipo.

En definitiva queremos que todos los mapas que tenga el 4 y no el 5 se copien el 5. Y todos los mapas que tenga el 5 y no tengo el 4 se copien al 4. De manera que ambas carpetas queden exactemente iguales.

Por ultimo se quiere comprobar si hay mapas nuevos cada 5 min, no es problema, unison es muy eficiente, y robusto. Tienes modos para trabajar en batch (proceso de fondo, con poca prioridad y no interactivo, el usuario no interviene). Bueno eso de que unison no pregunte puede asustar, eso no es un problema, porque unison solo sincroniza lo que sabe perfectamente que puede modificar sin peligro de que el usuario se emcabrone por perder información. Cada cierto tiempo el usuario puede entrar por el interfaz gráfico del unison y resolver los posibles conflictos de sincronización.

Conky : El monitor del sistema más versatil

Conky es un software libre para monitorear el estado de sistemas basados en linux. Lo mejor es de conky es su gran versatilidad, dispone de su propio lenguaje de scripts, este script nos permite por ejemplo mostrar la salida de un comando cada cierto tiempo. Por ejemplo tail -n 5 /var/log/messages , mostrar textos fijos, conky tiene una gran lista de variables predefinidas, podemos poner lineas, tablas, graficos y todo ello del color que queramos. Tenemos una innumerable lista de posibilidades, pero lo mejor para empezar es estudiar scripts que la comunidad pone a disposición, y siguiendo la filosofía de software libre mejorandolo y adaptandolo a nuestras necesidades, para despues volverle a poner a disposición de la comunidad. Siguiendo esta filosofía aqui os pongo mi .conkyrc. Para configurar vuestro conky igual que el mio, debeis escribir en consola: gedit ~/.conkyrc y pastear todo este script, despues seguimos los pasos que aparecen en la cabezera del script, debido a que tiene algunas dependencias que hay que instalar. Es fácil analizar la sintaxis y modificarlo a nuestras necesidades:

# Ultima actualización : domingo, 02 de noviembre de 2008
# Algunos trozos basadas en : http://ubuntuforums.org/showthread.php?t=281865&page=172
# Requiere : Hddtemp(como demonio) , lm-sensors y nvidia-settings
# Paso 1 : instalar hddtemp lm-sensors nvidia-settings
# Paso 2 : sudo sensors-detect le damos todo por defecto y en el ultimo paso decimos YES para añadir el modulo coretemp a /etc/modules
# Contacto : makiolo@gmail.com

background yes
use_xft yes
xftfont Terminus:size=8
out_to_console no
update_interval 3.0
total_run_times 0
own_window no
double_buffer yes
draw_shades no
draw_outline no
draw_borders no
stippled_borders 8
border_margin 12
border_width 1
default_color white
default_shade_color black
default_outline_color white
alignment top_right
maximum_width 270
own_window yes
own_window_type normal
own_window_transparent yes
own_window_hints undecorated,below,sticky,skip_taskbar,skip_pager
gap_x 12
gap_y 24
no_buffers yes
uppercase no
cpu_avg_samples 2
net_avg_samples 2
override_utf8_locale yes
use_spacer none

TEXT
${color #000000}SISTEMA ${hr 2}${color}
${color #ddaa00}PC:${alignr} ${color}Linux Ubuntu, $nodename
${color #ddaa00}Kernel :${alignr}${color}$kernel
${color #ddaa00}Tiempo encendido:${alignr} ${color }$uptime
${color #000000}CARGA DEL SISTEMA ${hr 2}${color}
CPU 1 (${freq_g cpu0}Ghz): ${color #FF0000} ${color #ddaa00} ${cpu cpu1}% ${color #ff0000}${exec sensors | grep "Core 0" | cut -c15-17}$color °C ${color}${cpubar cpu1}
CPU 2 (${freq_g cpu1}Ghz): ${color #FF0000} ${color #ddaa00} ${cpu cpu2}% ${color #ff0000}${exec sensors | grep "Core 0" | cut -c15-17}$color °C ${color}${cpubar cpu2}
Temperatura tarjeta gráfica: ${color #FF0000} ${exec nvidia-settings -q gpucoretemp | grep '):' | awk '{print $4}' | cut -c -2}$color °C
${cpugraph cpu0 20,270 000000 6495ED}
${font Liberation Sans:size=9}${color #000000}PROCESO${alignc}CPU${alignr}PID${color}
${color #ddaa00}${top name 1}${alignc}${top cpu 1}%${alignr}${top pid 1}
${color #F0F8FF}${top name 2}${alignc}${top cpu 2}%${alignr}${top pid 2}
${color #F0F8FF}${top name 3}${alignc}${top cpu 3}%${alignr}${top pid 3}
${color #F0F8FF}${top name 4}${alignc}${top cpu 4}%${alignr}${top pid 4}
${color #F0F8FF}${top name 5}${alignc}${top cpu 5}%${alignr}${top pid 5}
${color #F0F8FF}...${alignr}... 	   ...  $font
${color}$processes procesos $alignr $running_processes/$processes
${color #000000}MEMORIA ${hr 2}$(color)
${color}RAM al $memperc% ${color 000066}${membar 5,00}
${color #000000}DISCO DURO ${hr 2}${color}
${color #ddaa00}Temperatura:${alignr}${color lightgrey}${exec nc localhost 7634 | cut -f 4 -d "|"}º C
${color #ddaa00}Lectura: ${alignr}${color lightgrey}$diskio_read
${color #ddaa00}Escritura: ${alignr}${color lightgrey}$diskio_write
${diskiograph 20,270 000000 941545}
${color #ddaa00}Ubuntu: ${color lightgrey}${fs_used /} / ${fs_size /} ${color 000066}${fs_bar 6 /}$color
${color #ddaa00}Datos: ${color lightgrey}${fs_used /home} / ${fs_size /home} ${color 000066}${fs_bar 6 /home}$color
${color #ddaa00}XP: ${color lightgrey}${fs_used /media/windowsXP} / ${fs_size /media/windowsXP}  ${color 000066}${fs_bar 6 /media/windowsXP}$color
${color #000000}ALIMENTACIÓN ${hr 2}${color}
${color #ddaa00}Enchufe:${alignr} ${color}${acpiacadapter}${color}
${color #ddaa00}Batería:${alignr}${color}${battery BAT1}
${color #000000}INTERNET por WIFI ${hr 2}${color}
${color #ddaa00}IP Publica: ${color #EAE52F}${alignr}${execi 7200 lynx -dump http://www.whatismyip.com/automation/n09230945.asp | grep . |awk '{print $1}'}
${color #ddaa00}IP Local: ${color }$alignr${execi 7200 ifconfig | grep 'inet dirección:'| grep -v '127.0.0.1' | grep -v '172.16.235.1' | grep -v '192.168.148.1' | cut -d: -f2 | awk '{ print $1}'}
${color #ddaa00}SSID: ${color }$alignr${wireless_essid wlan0}
${color #ddaa00}Quality: $alignr${color }${wireless_link_qual_perc wlan0}%  (${wireless_bitrate wlan0})
${wireless_link_bar wlan0}
${color lightgrey}Download:${color} ${downspeed wlan0} KB/s$alignr${color lightgrey} Upload:${color} ${upspeed wlan0} KB/s
${color}${downspeedgraph wlan0 20,200 ddaa00 ddaa00} ${color}${alignr}${upspeedgraph wlan0 20,70 ddaa00 ddaa00}
${color lightgrey}Descargado: ${color}${totaldown wlan0}$alignr${color lightgrey}Subido: ${color}${totalup wlan0}
${color slate grey}Conexiones ${color lightgrey}Entrada: ${color #ff0000}${tcp_portmon 1 32767 count}${alignc}${color lightgrey}Salida: ${color #ff0000}${tcp_portmon 32768 61000 count}${alignr}${color #ddaa00}Total: ${color #ff0000}${tcp_portmon 1 65535 count}
${color #000000}INTERNET por CABLE${hr 2}
${color lightgrey}Download:${color} ${downspeed eth0} KB/s$alignr${color lightgrey} Upload:${color} ${upspeed eth0} KB/s
${color lightgrey}Descargado: ${color}${totaldown eth0}$alignr${color lightgrey}Subido: ${color}${totalup eth0}
${color #000000}MENSAJES DE KERNEL ${hr 2}${color}
${exec dmesg | tail -n 4}

Enlaces útiles:
Web de Conky
Foro ubuntu con .conkyrc de la comunidad
Variables predefinidas por conky
Comandos de confugiración

Como hacer juegos profesionales: Linux + OGRE + PhysX 2ª Parte

1ª Parte : Introducción
2ª Parte : Nuestra Primera aplicación

Nuestra primera aplicación

Vamos a crear 2 cubos, de manera que lo dejaremos caer, y se comportan con una física real. Al principio los tutoriales serán mucho de copy & paste, para entrar a la acción rapidamente, despues se ira explicando más cada cosa.

Empezamos a escribir código

• Creamos una carpeta para empezar nuestro proyecto : mkdir -p ~/proyectos/juegosProfesionales
• Nos cambiamos a nuestro nuevo directorio de trabajo : cd ~/proyectos/juegosProfesionales
• Creamos un main.hpp : gedit main.hpp main.cpp
• En el main.hpp pegamos esto :