Publi

  • Fluxbox + KDE

    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.… Leer artículo completo

  • Bing… el nuevo buscador de Microsoft

    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.… Leer artículo completo

  • Modelos de negocio

    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.… Leer artículo completo

  • Controlar señales

    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...
    Leer artículo completo
  • Intercambiar valores

    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.… Leer artículo completo

  • Decimal a Binario (y negativos en Complemento a 2)

    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.
    Leer artículo completo
  • Correcciones

    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