Novanebula blog

Que sucede cuando creas un nuevo sitio web y pretendes elaborar un estrategía SEO. Lo primero que pretendes hacer es escoger cuidadosamente una grupo de palabras clave para rankear en la página de resultados de google (SERP). Diseñas la páginas y amoldas la estructura de la página (sus enlaces internos y contenido) para tratar de obtener buenos resultados en ellas. Introduces las palabras clave y sus sinónimos en el contenido de tus páginas. Finalmente marcas tus páginas con el código de google analytics y después de unos días miras los resultados.

    Para tu sorpresa detectas que muchas de los términos por los que entra la gente en tu página no son los que esperabas e incluso te preguntas porqué apareces en búsquedas que parecen no tener nada que ver con lo que aparece en tu página (si, el bounce rate, relación de rebote y el tiempo medio que pasan los visitantes en tu página se resiente). Es más tu mismo intentando buscar tus páginas por esos términos dan lugar a resultados en los que ni siquiera apareces.

    Pasado aún más tiempo tus visitantes comienzan a entrar en tu página por los términos que pretendías e incluso detectas nuevas frases por los que entran relacionadas con tus productos y así optimizas nuevamente para estos nuevos términos recién descubiertos y que te parecen interesantes.

    Pero que pasa con esos términos 'raros' que aparecían al principio. Pues nada que siguen allí atrayendo visitantes (más o menos interesados en lo que ofrece tu web). A medida que tu web se hace más grande y tiene más contenido el número de términos por los que aparecen en las páginas de resultados también aumenta. No sólo de términos extraños sino otros muchos más relacionados con tu contenido. Tus términos principales son los que optienen un mayor número de visitas pero hay otros muchos que atraen proporcionalmente un número muy pequeño de visitas pero que en su conjunto atraen una cantidad de tráfico muy respetable (aún tal vez con una cota de conversión menor). A todos estos términos se le llama la cola larga. Es fácil ver el porqué, si representásemos el % de visitas que llegan a nuestra web con cada una de nuestras palabras claves ordenadas de mayor a menor veríamos que la gráfica empezaría en valore muy altos, tus keywords principales y caería muy rápidamente ha valores mucho más reducidos pero mucho más largo que estos primeros valores.

¿Porqué el concepto de cola larga se ha vuelto tan importante?

    En primer lugar porqué sumando las aportaciones de cada una de las palabras clave que se encuentran en la cola larga tenemos una cantidad de tráfico muy importante que puede rondar el 25% o más dependiendo del tipo de página. Por ejemplo amazón es el rey de la cola larga. Para dar un ejemplo amazón factura más con pequeños libros que apenas tienen 1 o 2 ventas al año que con toda la saga de Harry Potter.

    En segundo lugar que pasa cuando has conseguido escalar puestos para tus palabras clave principales y ya no puedes subir más o porque has alcanzado la 1ª posición o porqué las páginas que están por encima tuyo parecen inamovibles (wikipedia). Pués que ha llegado el momento en el que debes concentrarte en los términos de la cola larga. Porqué es hay donde puedes mejorar tu número tu número de visitas.

¿Pero como hago para para mejorar mi cola larga?

    Como el número de keywords en la cola larga puede ser realmente gigantesco, obviamente no puedes ponerte a optimizar una por una creando por ejemplo landings específicas para cada una de ellas. Además los keywords de la cola larga pueden variar de manera importante. La única manera viable de obtener una cola todavía más larga es aumentar tu web con contenido de calidad, olvidándote de tus palabras claves principales y sus sinónimos, contenido natural (no optimizado con keywords de ningún tipo) y relevante. Muchas veces se dice que un SEO realmente bueno es el que no lo parece aquí tenemos otros buen ejemplo de esto.

Las funciones getopt y getopt_long sirven para automatizar el paso de parámetros al programa en linea de comandos. Estas funciones también pertenecen a la librería C de GNU. Sus usos y ejemplos son inmediatos en cuando comenzamos a escribir comandos en nuestra consola.

# ls -la
# find . -name "*.mp3"

    -la y -name son los parámetros que deben ser analizados cuando invocamos estos programas para su correcto funcionamiento. Getopt y getopt_long nos servirán de mucha ayuda para analizar y detectar todos esto parámetros.

    Debemos incluir el archivo de cabecera unistd.h para poder emplear getopt una vez hecho esto la firma de la función es la siguiente:

int getopt(int argc, char * const argv[], const char *optstring);

    Para getopt_long también necesitamos el archivo de cabecera unistd.h:

int getopt_long(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex);

    getopt emplea o fija varias variables, estas son:

int opterr - Si le damos un valor igual a 0 getopt no indicara imprimirá en stderr ningún mensaje de error (por defecto si que lo hará)
int optopt - Si getopt encuentra una opción no reconocida o sin un parámetro necesario, entonces almacena este caracter en esta varible.
int optint - La variable fijada por getopt nos da el indice del parámetro a ser analizado.
char* optarg - Fijada por getopt y que nos da la posición del argumento a analizar.

    La función getopt obtiene el siguiente argumento en la lista de argumentos que se le pasan al programa. Normalmente los argumentos son los pasados a la función main al comienzo de nuestro programa (argc y argv)

    optstring es una cadena que especifica todos los caracteres válidos para nuestro programa. Un carácter seguido de dos puntos ':' indica que esta opción necesita un argumento y si está seguida de dos dobles puntos '::' indicamos que ese argumento es opcional (sólo GNU), por lo tanto la cadena:

"lac:d::"

    Indica que nuestro programa acepta el parametro -l, -a el parámetro -c seguido de un argumento y -d que puede no estar seguido de un argumento esto podría ser:

-l -a -c /tmp/a.txt -d

ó

-la -d -c /tmp/a.txt

etc

    getopt va devolviendo el último parámetro analizado y al final cuando no queda ningúno más por analizar devuelve -1

    Si la opción tiene un argumento este es colocado dentro de optarg

    El argumento especial '--' termina el análisis de opciones posteriores

    Si getopt encuentra una opción que no aparece en la lista de opciones disponibles devuelve '?' e introduce en la variable externa optopt este argumento.

    Este es un ejemplo del uso de getopt:

#include
#include
#include
#include

int main (int argc, char **argv)
{
int aflag = 0;
int bflag = 0;
char *cvalue = NULL;
int index;
int c;

opterr = 0;

while ((c = getopt (argc, argv, "abc:")) != -1)
switch (c)
{
case 'a':
aflag = 1;
break;
case 'b':
bflag = 1;
break;
case 'c':
cvalue = optarg;
break;
case '?':
if (optopt == 'c')
fprintf (stderr, "Option -%c requires an argument.\n", optopt);
else if (isprint (optopt))
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf (stderr,
"Unknown option character `\\x%x'.\n",
optopt);
return 1;
default:
abort ();
}

printf ("aflag = %d, bflag = %d, cvalue = %s\n",
aflag, bflag, cvalue);

for (index = optind; index < argc; index++)
printf ("Non-option argument %s\n", argv[index]);
return 0;
}

Memcache es un sistema para almacenamiento de objetos en memoria que pueden ser solicitados por varios procesos, incluso en distintas máquinas y que actúa como caché para acelerar estas peticiones. Memcache ha sido diseñado de manera genérica aunque su mayor utilidad y para la que fue desarrollado inicialmente es para reducir la carga en sitios web debido a las solicitudes a base de datos que en muchos casos son innecesarias.

    Memcache ha sido desarrollado por Danga Interactive para livejournal en primera instancia pero luego liberado bajo licencia BSD. Hoy en día es empleado por muchos otros sitios webs debido a su gran utilidad, entre ellos: Livejournal, Slashdot, Wikipedia, SourceForge, FotoLog y un largo etc.

    El funcionamiento de memcache es de concepción muy sencilla. En lugar de acceder a la base de datos para solicitar determinada información primero se accede a memcached (el servidor de memcache) a través de tcp/ip (así se puede acceder a servidores memcache en máquinas remotas o en local). Si este tiene la información la devuelve y si no debemos hacer la petición a la base de datos e introducir los datos en memcached para que puedan ser accedidos directamente la próxima vez que los necesitemos. Además cada dato introducido en memcached tiene un tiempo de expiración, tras pasar este tiempo almacenado en el servidor este se considera descartable y se borra del servidor, dejando espacio para otros objetos.

    De una manera muy sencilla también es posible emplear varios servidores memcache, creando una cache distribuida todavía más eficiente o incluso utilizar varios niveles de caché entre máquinas locales y/o remotas.

    Memcaché está basado en libevent una librería de notificación de eventos asíncrona que permite ejecutar callbacks cuando un determinado evento es disparado (además de eventos puede reaccionar a señales o a intervalos de tiempo específicos, más adelante quizás le dedique un post a esta librería).

    Para instalar memcached en nuestro servidor debemos bajarnos las fuentes del sitio de Danga Interactive. La compilación e instalación no debería ser complicada. También es posible descargar fuentes y binario con apt-get o con el gestor de paquetes que tengamos instalado (absténganse windowzers)

apt-get install memcached

 El servidor memcached tiene unas pocas opciones en la línea de argumentos, estos son:

-d (implicito)
-v (verbose)
-vv (más verbose)
-m (memoría en megas disponible para el demonio)
-p (puerto a la escucha, por defecto 11211
-u (usuario bajo el que se ejecuta el servidor)
-l (IP de la que se espera conexiónes, es la única medida de seguridad del servidor, el valor por defecto es escuchar comunicaciones desde cualquier ip lo cual es completamente inseguro si no se está detrás de un firewall)
-c (número máximo de conexiones simultaneas)
-k (activa bloqueos)
-M (devuelve error cuando la memoria se agota)
-r (limita los core dump)

 El demonio toma toda la memoria especificada por el parámetro -m al principio y cuando no puede alamacenar más datos desecha aquellos accedidos menos recientemente (si no se le pasa el parámetro -M)

Ejemplo:
# memcached -d -m 2048 -l 10.0.0.40 -p 11211

El comando anterior iniciará el servidor usando 2GB de memoria y escuchando conexiones desde la ip 10.0.0.40 al puerto 11211. Recordemos que es posible iniciar más servidores memcache en la misma máquina.

Existen disponibles diversas APIs para conectarse al servidor escritas en diferentes lenguajes: PHP, Python, PERL, Ruby, Java, C, C#

Ejemplo en php de conexión con el servidor memcached:


$memcache = new Memcache;
$memcache->connect('localhost', 11211) or die ("Could not connect");

$version = $memcache->getVersion();
echo "Server's version: ".$version."
\n";

$tmp_object = new stdClass;
$tmp_object->str_attr = 'test';
$tmp_object->int_attr = 123;

$memcache->set('key', $tmp_object, false, 10) or die ("Failed to save data at the server");
echo "Store data in the cache (data will expire in 10 seconds)
\n";

$get_result = $memcache->get('key');
echo "Data from the cache:
\n";

var_dump($get_result);

?>

La función alloca reserva espacio en la pila de la función que lo llama, devolviendo un puntero ha este espacio reservado. Este espacio temporal es automáticamente liberado cuando la función que llama a alloca retorna.

Esta es la firma o prototipo de la función:

void *alloca(size_t size);

Su declaración está en el archivo de cabecera alloca.h. El parámetro que se le pasa es el número de bytes que se desean reservar. Alloca además devuelve un puntero nulo cuando no tiene éxito al reservar memoria.

Alloca presenta una serie de ventajas con respecto a malloc a la hora de reservar memoria. Alloca no produce segmentación en los bloques de memoria reservados, ya que el espacio se reserva en la pila. Alloca apenas malgasta espacio y es bastante rápido. Cuando la función que llama a alloca es abandonada la memoria es liberada evitando posibles memory leaks. Esto también ocurre en caso de error en la función, la memoria es liberada de inmediato.

Ejemplo de función que emplea alloca:

int open2(char *str1, char *str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
stpcpy (stpcpy (name, str1), str2);
return open(name, flags, mode);
}

Para tener un código similar empleando sólo malloc y free debemos escribir:

int open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) malloc (strlen (str1) + strlen (str2) + 1);
int desc;
if (name == 0)
fatal ("virtual memory exceeded");
stpcpy (stpcpy (name, str1), str2);
desc = open (name, flags, mode);
free (name);
return desc;
}

Alloca, sin embargo, también tiene algunas desventajas:

Si intentas reservas más memoria de la que la máquina puede reservar no obtendrás un mensaje de error claro. En su lugar tendrás una señal fatal como las obtenidas en un recursion infinita; probablemente una violación de segmento.

Algunos sistemas no-GNU no tienen soporte para alloca, convirtiendo a alloca en menos portable. Sin embargo hay algunas implementaciones en C para solventar estas deficiencias en estos sistemas.

Sigue este link para saber más de reserva de memoria

Obstack es otros de los medios que emplea la librería C de GNU para la asignación dinámica de memoria. Obstack es una pila de objetos (datos) que puede crecer dinámicamente. Es posible crear cualquier número de obstacks para, en cada uno, ir almacenando diferentes conjuntos de datos. En cada obstack el último objeto en entrar es el primero en salir.

    Obstack es pues otro de los métodos de la librería glibc para la reserva dinámica de memoria.

    A parte de esta limitación en el orden de almacenaje obstack es capaz de contener cualquier número de objetos de cualquier tamaño. Obstack está implementado con macros, de manera que la asignación de espacio es muy rápida si los objetos son pequeños. La única sobrecarga por objeto es el relleno necesario para colocar un objeto en unos límites adecuados.

    Para la creación de un obstack debes primero incluir el archivo de cabecera obstack.h. En este archivo se declara la estructura obstack de tamaño fijo y que registra el estado del obstack y como encontrar el espacio donde los objetos están localizados. No se debe intentar acceder al contenido de esta estructura directamente sino que se debe utilizar las funciones diseñadas especificamente para obstack.

    Obstack puede ser tratado como cualquier otro tipo de objetos, puedes crear obstack dinamicamente o crear obstacks que contengan a su vez otros obstacks.

    Todas las funciones que trabajan con obstacks necesitan que se les especifique el obstack a usar. Se hace esto a través de un puntero a la estructura de tipo struct obstack* .

    Los objetos dentro del obstack son empaquetados en bloques llamados chunks. La estructura obstack apunta a una cadena de chunks actualmente en uso.

    La librería obstack obtiene un nuevo chunk cada vez que debe insertar un nuevo objeto que no cabe en un chunk anterior. La librería administra automáticamente estos chunks de manera que no hay que prestarles demasiada atención, pero hay que propocionar una función a la librería obstack para que esta se haga con un nuevo chunk. Generalmente se debe proporcionar un a función que emplea malloc directa o indirectamente. También se debe proporcionar una función que libere el chunk (free).

Ejemplo:

#include //declara todas las variables, funciones y macros necesarios para obstack

//Estas dos macros definen los métodos para la generación de memoria dinámica y su liberación
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free

...

//función que se llamara en el caso de error en la reserva dinámica de memoria
void my_obstack_alloc_failed(void)
{
...
}

...

//Declaramos nuestra estructura obstack
static struct obstack myobstack;

...

//La inicializamos
obstack_init(&myobstack);

...

//Declaramos que función será llamada en caso de error al reservar memoria dinámica
obstack_alloc_failed_handler = &my_obstack_alloc_failed;

//Grabamos en nuestro obstack la cadena "hola mundo"
obstack_alloc("hola mundo",11);

Para almacenar un bloque con un contendio específico utilizamos la función obstack_copy

void* obstack_copy (struct obstack* obstack-ptr, void* address, int size)

La función obstrack_copy0 además agrega un caracter nulo (ascii 0) al final.

void* obstack_copy0 (struct obstack* obstack-ptr, void* address, int size)

En el último argumento size no debemos tener en cuenta este carácter nulo extra. Ejemplo:

char*
obstack_savestring (char* addr, int size)
{
return obstack_copy0 (&myobstack, addr, size);
}

    Para liberar objetos en el obstack se emplea obstack_free

void obstack_free (struct obstack* obstack-ptr, void* object)

    Si objeto es un puntero nulo, todo lo almacenado en obstack será liberado. Cualquier otro valor debe ser un puntero a un objeto del obstack. Ese objeto será liberado y todos los que se encuentran a continuación de él.

    Observa que si object es un puntero nulo, el resultado será un obstack no inicializado. Para liberar todos los objetos del obstack pero dejando el obstack válido para agregar nuevos objetos tenemos que pasarle como object el primer objeto almacenado.

    Recuerda que obstack está agrupado en chunks. Si se liberan todos los objetos de un chunk, obstack automaticamente liberará este chunk para que pueda ser utilizado como recurso para otros elementos del programa.

    Recordemos que los interfaces definidos en obstack pueden estar definidos como funciones o como macros. Ejemplo:

char* x;
void* (* funcp) ();
/* Use the macro. */
x = (char* ) obstack_alloc (obptr, size);
/* Call the function. */
x = (char* ) (obstack_alloc) (obptr, size);
/* Take the address of the function. */
funcp = obstack_alloc;

    Si empleas otro compilador que no sea el de GNU debes tener esto en cuenta.

Para saber más:


GNU C Library Obstacks

Como ya habiamos comentado en un anterior post sobre la asignación de memoria dinámica además de malloc que asigna un zona de memoria para nuestra programa tanto realloc como calloc hacen exactamente lo mismo pero además tienen capacidades adicionales (que las hacen maś caras computacionalmente hablando, así que si no necesitas ninguna de estas características utliliza directamente malloc. Sino estarás malgastando recursos).

La función calloc cuya firma o prototipo es la siguiente:

void* calloc(size_t nmemb, size_t size);

Inicializa la zona de memoria reservada. Como se puede observar sus argumentos son diferentes de las de la función malloc que sólo recibía el número de bytes a reservar. Para calloc es necesario dar el número de elementos a reservar y el tamaño de cada uno de esos elementos. Así tenemos que por ejemplo:

int* pi;
pi = calloc(50,sizeof(int));

Reservará espacio para 50 enteros asignando al puntero pi la dirección en memoria del primero.

La función realloc por otra parte intenta cambiar el tamaño de una zona de memoria previamente asignada dinamicamente copiando, si es posible, su contenido anterior.

Esta es su firma:

void* realloc(void* ptr, size_t size);

Si el cambio de tamaño no se puede llevar a cabo entonces la función devolverá un puntero a null

ip = (int* ) realloc ( ip, 25*sizeof(int) );

Siguiendo el primer ejemplo este redimensionará la zona de memoria asignada por la función calloc. Debemos tener en cuenta que esta función puede modificar además el valor del puntero. Recolocando la zona de memoria reservada en otra zona de la memoria de la máquina dependiendo de la situación. Incluso una disminución en el tamaño de la memoria puede dar lugar a una recolocación del segmento de memoria.

Como con malloc y calloc toda memoria reservada dinámicamente debe ser liberada con free.

void free(void* ptr);