Archivo

Archivo para Junio, 2009

Fluxbox + KDE

Jueves, 11 de Junio de 2009 admin 4 comentarios
Fluxbox

Fluxbox, un gestor de ventanas ligero, personalizable y productivo

Éste es mi escritorio normalmente, desde hace años utilizo Fluxbox como gestor de ventanas, entre otras cosas por lo ligero que es, y permite utilizar teclas para todo: acciones comunes como lanzar programas, cambiar de escritorio hasta cambiar la capa donde está la ventana, moverla o redimensionarla.

Por otra parte, no es que tenga configuración gráfica ni nada, todo va por archivos de texto, al principio impone, pero una vez que te acostumbras no cuesta nada abrir un editor de texto para configurar las teclas, es una sintaxis muy sencilla, por lo que tiene muchas posibilidades. Y todo esto hace verdaderamente sencillo programarse ciertos scripts para acciones comunes (aunque por ejemplo, muchas cosas que vienen de serie con KDE o Gnome, por ejemplo uso de teclas multimedia, tienes que programártelo tú). En futuros posts publicaré algunos de los scripts.

La mayoría de las aplicaciones que me gustan y que más utilizo son para KDE (he pensado alguna vez en cambiarme, pero aún no), y casi siempre tengo un Konqueror y Kontact en ejecución; en la Slit (barra de la derecha) tengo mini aplicaciones muy útiles (más adelante listo todo lo que se ve).

Aplicaciones que se ven en la captura:

  • Fluxbox - Este gran gestor de ventanas
  • Xpad - Programa para los post-its de escritorio (usa GTK)
  • Kontact - Gestiona contactos, citas, reuniones, tareas, etc…
  • Konqueror - Gestor de archivos y navegador web
  • Xterm - Terminal
  • Gimp - Editor de imágenes… está escondido.
  • Pidgin - Mensajería instantánea… también está escondido
  • Gkrellm - Está a la derecha, es un monitor de sistema
  • Gkrellm Wifi - Monitor Wifi para Gkrellm (La página ya no existe, pero podemos encontrar el proyecto, tal vez en el repositorio de nuestra distribución)
  • Wmcalc - Calculadora rápida, sólo poniendo el ratón encima podemos escribir las operaciones y sale el resultado
  • Wmwork - Gestor de tiempo de trabajo, muy pequeño y útil
  • Wmsmixer - Mezclador de sonido
  • Dwgo - Don’t want to go outside, nos dice la temperatura y las condiciones climáticas en espacio reducido (en desarrollo). Éste último es mío :)
Categories: General Tags: , , , , , , , , , , , , , ,

Bing… el nuevo buscador de Microsoft

Miércoles, 10 de Junio de 2009 admin 2 comentarios

Hace poco Microsoft lanzó su nuevo buscador, los que tengáis cuenta Live seguro que os habréis enterado, porque están promocionandolo bastante.

Sinceramente, creo que si querían sorprender al mundo van unos 15 años tarde, y aunque los fallos garrafales que surgen en los primeros días de vida incluso le dan promoción gratuíta no creo que resulten una competencia tan grande a Google, al menos en ciertos países.

Hubiera sido distinto que inventaran un clon de Wolfram Alpha, hubiéra sido un motivo para no cerrar Encarta entre otras cosas.

Aunque la verdad es que no encontré el enlace para añadir mis webs al buscador, ya que en Google, buscas “añadir a google” y lo primero que sale es cómo añadir una web, pero en Bing, no encontré nada a primera vista. Fue necesario volver a Google y buscar: “añadir a Bing” donde encontré la explicación en el blog PC Digital. El tema está en entrar aquí y logearse con la cuena Live.

Categories: Interneteando Tags: , , , , ,

Modelos de negocio

Miércoles, 10 de Junio de 2009 admin 1 comentario

Hace un par de años en una conferencia de emprendimiento organizada por la Universidad de Málaga, conocí a una persona que era acérrima defensora del software comercial, porque le parecía muy falso, según el, lo que “hacía el software libre“. Según él, era inmoral que ciertas personas quisieran cobrar dinero por instalarte y darte soporte de un software.

Yo estuve alucinando un buen rato, y estuve explicándole un poco lo que era el software libre, y que éste no tenía por qué ser gratis, aunque no terminó convenciéndole demasiado, al menos creo que dejó de ser tan maligno para él.

Pero es más, hablando del caso del soporte, pasa con todo tipo de software, en ocasiones tu compras una licencia y ésta incluye soporte técnico y está muy bien que una empresa se encargue de las incidencias de un software o de unos equipos informáticos… es más, si yo comprara un software determinado, me gustaría tener un servicio técnico competente, aunque eso es otro cantar.

En principio estoy de acuerdo de que haya soluciones cerradas y de pago, es más, en ocasiones es necesario, si una empresa se ha dedicado a investigar sobre un tema durante años y ha desarrollado el mejor producto en un campo, y lo quiere vender, está en todo su derecho, es más, yo invito al usuario a que lo compre si ve que lo necesita; pero es verdad que el hecho de que sea una gran empresa, no significa que el programa que haya desarrollado sea el mejor en su campo, y si hay algo que no te gusta, como mucho puedes contactar con la empresa y decirlo, pero eso no significa que te vayan a hacer caso. Y el hecho de que hayas comprado un software no significa que sea tuyo, en ocasiones sólo compras el permiso a utilizarlo en unas determinadas condiciones (todo eso viene en el contrato que muy poca gente lee).

Por otra parte, es verdad que el mundo lo mueve el dinero, y que a lo mejor las soluciones de software libre son un poco menos monopolísticas, en el sentido de que hay muchas empresas que se pueden encargar del mantenimiento… bien por el cliente, porque si una empresa no le convence cómo trabaja, contrata otra; mal por la empresa, tal vez tenga que hacerse valer, y ofrecer un servicio decente, lo cual es bueno para el cliente. Está claro que todos tenemos que ganarnos la vida, y si algo no tiene intereses económicos por ningún lado, no tendrá éxito (nadie invertirá dinero porque nadie nunca va a recibirlo).

Y volviendo al tema de la elección, cada uno es libre de utilizar el software que quiera, pero con ciertas elecciones hay que tener cuidado, porque no hay vuelta atrás.

Categories: General Tags: , , , ,

Controlar señales

Viernes, 5 de Junio de 2009 admin Sin comentarios

A veces, se nos presenta la necesidad de modificar el comportamiento de nuestro programa por ejemplo cuando el usuario pulse Control+C, o cuando terminemos nuestra aplicación, o cuando… dividamos por 0, o más cosas… podemos ver un listado de las diferentes señales con:

man 7 signal

Podemos utilizar para probar este programa (signals.c):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
void salir(int recib);
void alarma(int que);
int tmp=0;
int divi=5;
int main()
{
    signal(SIGINT, salir);  /* Control+C */
    signal(SIGKILL, salir); /* kill */
    signal(SIGFPE, salir);  /* división por 0 */
    signal(SIGALRM, alarma);    /* alarma */
    signal(SIGUSR1, alarma);    /* definido por el usuario */
    int numero=4;
    while (1)
        {
            usleep(1000);       /* Le damos un respiro a la CPU mientras estamos en el bucle */
            tmp++;
            if (tmp%1000==0)
            {
                tmp=tmp/divi;
                printf("tmp = %d\n", tmp);
            }
        }
}
void salir(int recib)
{
    printf("Salgo porque ");
    switch (recib)
        {
        case SIGINT: printf("has pulsado Control+C...\n"); break;
        case SIGTERM: printf("alguien me ha terminado\n"); break;
        case SIGFPE: printf("he dividido por 0 y eso no se puede hacer\n"); break;
        default: printf("yo que sé !!");
        }
    printf("Sólo quería decirte que me quedé contando por %d\n\n", tmp);
    exit(0);
}
void alarma(int que)
{
    switch (que)
        {
        case SIGALRM:
            printf("Voy contando por %d\n\nDivi vale %d\n", tmp, divi); break;
        case SIGUSR1:
            divi--; break;
        }
}

Para aprovechar su funcionalidad, tenemos que ejecutarlo desde un terminal, y abrir otro terminal al lado, para ir ejecutando ciertas cosas:

killall signals (o el nombre que le hayáis dado al ejecutable)
killall -14 signals (alarma)
killall -SIGUSR1 signals (varias veces)

Observaremos que con “killall signals” cerraremos directamente, igual que con Control+C, pero antes de salir del programa, nos dará cierta información (función salir); también veremos que con “killall -14 signals” veremos información en pantalla (función alarma), y que con killall -SIGUSR1 signals” veremos que tmp se va dividiendo por un número menor cada vez que la pulsamos, y cuando lo hemos hecho varias veces, dividirá por 0 (y también capturaremos ese error).

Esto puede servir, por ejemplo, por si estamos grabando un informe de lo que estamos haciendo y se cancela la ejecución, pero queremos cerrar el archivo, queremos mostrar un resumen, capturar errores, ignorar las señales… o comunicarnos con otras aplicaciones de forma sencilla

Categories: C/C++ Tags: , , , ,

Intercambiar valores

Jueves, 4 de Junio de 2009 admin Sin comentarios

Cuando queremos hacer que una variable a sea igual a una variable b y viceversa (intercambiar los valores), lo primero que se viene a la mente, es utilizar una variable auxiliar, como en este ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
void intercambia(int *x, int *y);
int main()
{
    int a=50;
    int b=90;
    printf("a=%d t b=%dn", a, b);
    intercambia(&a, &b);
    printf("a=%d t b=%dn", a, b);
}
void intercambia(int *x, int *y)
{
    int tmp;
    tmp=*x;
    *x=*y;
    *y=tmp;
}

Aunque puede que queramos (o que nos pidan) hacerlo sin variable temporal, podemos hacer un intercambiador con sumas y restas:

1
2
3
4
5
6
void intercambia2(int *x, int *y)
{
    *x=*x+*y;           /* x=x+y */
    *y=*x-*y;           /* y=x-y */
    *x=*x-*y;           /* x=x-y */
}

Y con las propiedades de la operación XOR también podemos jugar:

1
2
3
4
5
6
void intercambia3(int *x, int *y)
{
    *x ^= *y;           /* x = x xor y */
    *y ^= *x;           /* y = y xor x */
    *x ^= *y;           /* x = x xor y */
}

Pero lo bueno de estos dos últimos métodos es que los podemos utilizar desde macros de preprocesador, y con eso nuestro código se ejecutará mucho más rápido:

1
2
3
4
5
6
7
8
9
#define interc(x,y) x=x+y; y=x-y; x=x-y;
int main()
{
    int a=-50;
    int b=40;
    printf("a=%d t b=%dn", a, b); /* a=-50 b=40 */
    interc(a, b);
    printf("a=%d t b=%dn", a, b); /* a=40 b=-50 */
}

Para ver lo rápido que se ejecuta, he hecho el programa intercambiando continuamente en un bucle for de unos 300000000 (trescientos millones) de iteraciones lo siguiente:

Para la macro de preprocesador interc(a,b),

gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./interc
a=-50 b=40
a=-50 b=40

real 0m8.027s
user 0m7.461s
sys 0m0.022s

Para intercambia(a,b) (con variable auxiliar):

gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./intvaux
a=-50 b=40
a=-50 b=40

real 0m8.691s
user 0m7.058s
sys 0m0.022s

Para intercambia2(a,b), con sumas y restas:

gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./intsyr
a=-50 b=40
a=-50 b=40

real 0m12.331s
user 0m10.508s
sys 0m0.024s

Para intercambia3(a,b) con xor:

gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./intxor
a=-50 b=40
a=-50 b=40

real 0m11.882s
user 0m10.516s
sys 0m0.031s

Por lo tanto vemos, que el método de la variable auxiliar es bastante rápido, mucho más que haciendo sumas y restas y xor (por lo tanto estos métodos no sirven de mucho, sobre todo ahora, que la memoria es barata), aunque, con las sumas y restas nos acercamos en tiempo al método de la variable auxiliar cuando lo hacemos desde una macro.

Ahora bien, es una cosa un poco sucia, pero es un buen experimento: crear una variable global c, y una macro que haga el intercambio ayudándose de la variable auxiliar c:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#define interca(x,y) c=x; x=y; y=c;
int c;
int main()
{
    int a=-50;
    int b=40;
    long i;
    printf("a=%d t b=%dn", a, b); /* a=-50 b=40 */
    for (i=0; i<300000000; i++)
        {
            interca(a, b);
        }
    printf("a=%d t b=%dn", a, b); /* a=-50 b=40 */
}

Con éste método, obtenemos estos tiempos:

gaspy@XiKiTiN ~/proyectos/poesiabinaria $ time ./inter
a=-50 b=40
a=-50 b=40

real 0m3.087s
user 0m2.901s
sys 0m0.005s

Bastante menos :) De todas formas estos tiempos son aproximados.

Categories: C/C++ Tags: , ,

Decimal a Binario (y negativos en Complemento a 2)

Martes, 2 de Junio de 2009 admin 4 comentarios

Aquí traigo un fragmento de código que nos puede ayudar bastante a la hora de hacer cambios de base de decimal a binario, sobre todo porque para manejarnos con los números negativos utilizamos el Complemento a dos.

En principio, antes de hacer esta función miré un poco el blog Static Zero, y luego me decidí simplificar un poco el código. Así ha quedado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
int *decToBin(int decimal, int nBits, int binary[]) {
    int i;

    int flag = 0;
    /* Si es un número negativo, lo hacemos positivo y le restamos 1(*), */
    /* además activamos el flag para saber que es negativo */

    /* (*) El complemento a 2 es igual que el complemento a 1, que es cambiar */
    /* 1->0, 0->1, y luego sumando 1 en binario. Aquí restamos 1 en decimal y */
    /* luego pasamos a binario. */
    if (decimal < 0)
        {
            flag = 1;
            decimal = -decimal-1;
        }

    /* Pasamos a binario, atendiendo a lo que vale flag, en lugar de añadir (decimal%2) */
    /* como es normal, le hacemos un XOR con flag, vemos la tabla de verdad de XOR */
    /* |    A    (xor)   B       =   X   |  */
    /* |     0      |        0       |   0   |  */
    /* |     0      |        1       |   1   |  */
    /* |     1      |        0       |   1   |  */
    /* |     1      |        1       |   0   |  */
    /* ------------------------------   */
    /* Por tanto, cuando flag vale 0, al encontrar un 0, pondremos un 0, y al encontrar un 1, ponemos un 1 */
    /*           Pero cuando flag vale 1, al encontrar un 0, pondremos un 1, y al encontrar un 1, ponemos un 0 */
    while (decimal > 0)
        {
            binary[--nBits] = flag^(decimal%2);
            decimal/=2;
        }

    /* Con esto terminamos de llenar el array, con 0 a la izquierda si es un número positivo */
    /* y con 1s si es un número negativo */
    while (nBits>0)
        binary[--nBits] = flag;
   
    /* Devolvemos el array */
    return binary;
}

Para descargar este código y un pequeño programa de prueba:
Pasar de decimal a binario (Negativos en complemento a 2)

Categories: C/C++ Tags: , , , ,

Correcciones

Martes, 2 de Junio de 2009 admin Sin comentarios

He estado echando un vistazo a mis tres últimos posts y vi que no salieron bien algunas cosas, ahora creo que estan bien.

Disculpad las molestias

Categories: General Tags:
Easy AdSense by Unreal