Archivo por meses: febrero 2011

La importancia de los logotipos

Por delante de todo el código programado, es necesaria una buena apariencia
gráfica. Normalmente, la identidad cromática queda definida en
el logotipo, por lo cual el orden correcto para el desarrollo de la apariencia
de la interfase es primero tener un logotipo y luego generar el entorno gráfico en base a él.

Una buena opción para obtener un logotipo es sin dudas, Ars Logo Design,
agencia de diseño gráfico ocupada exclusivamente del diseño
gráfico de logotipos
. Con un logotipo para identificar visualmente
al proyecto, podremos generar la interfase gráfica con la que interactuarán
sus usuarios.

Me decanto por esta gente por la calidad de sus diseños y también
por los precios de paquetes promocionales, que están al alcance de todo el mundo. Es llamativo
que profesionales del diseño ofrezcan sus servicios a precios tan económicos;
tendrán sus razones para hacerlo, a nosotros sólo nos queda aprovecharlo.

Sigamos ocupándonos del código mientras los profesionales se
ocupan de la imagen.

Comenzando nuevos proyectos

Hola, la semana pasada comenze a trabajar en Manuvo con @Michoacano y otros amigos que no me se sus nombres de usuario en twitter (ya luego se los pregunto :)).

También he decidido comenzar ya como blogger (nivel ninja ya), usar algunos de mis conocimientos SEO y abrir un segundo blog llamado PlanetaGame cuya temática principal serán los videojuegos, ahi planeo escribir junto con mas redactores, novedades, noticias, vídeos, trucos, tutoriales, etc. todo sobre videojuegos y después ir creciendo y realizar torneos multiplayer de juegos como Call of Duty.

El dominio lo compre el viernes y el sábado pasado comenze a montar el sitio e instalar plugins y cosas SEO, también he escrito algunos post para hacer pruebas y he modificado el template para que quede mas agradable.

Creo que el nombre de dominio tiene una excelente Keyword (eso espero jeje), pero estoy consciente de que tendre mucha competencia pues no es lo mismo que www.alevsk.com que contiene mi nick y nadie mas lo usa :p

Emular comando WC en C


Hola de nuevo, aquí les traigo un código que nos dejaron en la clase de Sistemas Operativos.
Básicamente tenemos que emular la salida del comando wc de linux (el que cuenta el numero de lineas, caracteres o palabras de un archivo).

Pero con unas pequeñas diferencias

  • Recibe n archivos (parámetros)
  • Cuenta el numero de lineas, caracteres y palabras de cada archivo
  • Muestra la suma total de lineas, caracteres y palabras de todos los archivos
  • Cada archivo es manipulado por un thread

#include<sys/types.h>   // fork
#include<unistd.h>      // getpid, getppid
#include<stdio.h>       // printf
#include<sys/wait.h>  // wait
#include<string.h>  // strcat
#include<pthread.h>

//Constantes
#define TIEMPO 1
//Variables globales
int total_lineas = 0;
int total_palabras = 0;
int total_caracteres = 0;

void* manejoArchivo (char* archivo)
{  
  int *a,*b,*c;
  a = &total_lineas;
  b = &total_palabras;
  c = &total_caracteres;
  char x;

  int nlineas = 0, npalabras = 1, ncaracteres = 0;
  
  
  //printf("%s\n",archivo);
  
  FILE *file;
  file = fopen(archivo, "rt");
  if (file == NULL)
  {
    puts("Error al abrir el archivo");
  }
  else
  {
    puts("Accediendo al archivo");
    while (feof(file) == 0)
    {
            //fgets(caracteres,100,archivo);
            //printf("%s",caracteres);
      x = getc(file); // Obtiene un caracter del archivo
      //putchar(x); // Lo despliega en pantalla y continua..
      if(x == 32)
      {
        npalabras++;

      }
      if(x == '\n') 
      {
        nlineas++;
      }
      if(x != '\n' && x != ' ')
      {
        ncaracteres++;
      }
    }
    ncaracteres = ncaracteres - 1;
    if(npalabras > 1){npalabras = npalabras + (nlineas - 1);}
  
    *a = *a + nlineas;
    *b = *b + npalabras;
    *c = *c + ncaracteres;
    
    printf("El numero de lineas del archivo %s es %d\n",archivo,nlineas);
    printf("El numero de caracteres del archivo %s es %d\n",archivo,ncaracteres);
    printf("El numero de palabras del archivo %s es %d\n",archivo,npalabras);
  }
}

int main(int argc, char *argv[])
{
  int n_ficheros = 0;
  int i = 0;
  char *puntero;
  
      if(argc < 2)
      {
          printf("Debes teclear el nombre de almenos 1 fichero, ej:\n");
    printf("./wc_emulado archivo.txt archivo2.txt archivo3.txt\n");
          exit(1);
      }

  n_ficheros = argc - 1; //Numero de ficheros a leer

  //creo tantos threads como ficheros haya pasado por argumentos
  pthread_t ficheros_t[n_ficheros];
  
  for (i=0;i<=n_ficheros;i++)
  {
    sleep(TIEMPO);    
    pthread_create(&ficheros_t[i],NULL,&manejoArchivo,argv[i+1]);
  }

  printf("EL numero total de lineas es: %d\n",total_lineas);
  printf("EL numero total de caracteres es: %d\n",total_caracteres);
  printf("EL numero total de palabras es: %d\n",total_palabras);
  return -1;
  
}

Aquí les dejo el código mas legible listo para que lo compilen.

salu2

Programacion: Threads en C

3GUGFVCXPCUB

De Wikipedia:

[code]]czo4NTA6XCJJbiBjb21wdXRlciBzY2llbmNlLCBhIHRocmVhZCBvZiBleGVjdXRpb24gaXMgdGhlIHNtYWxsZXN0IHVuaXQgb2YgcHJ7WyYqJl19b2Nlc3NpbmcgdGhhdCBjYW4gYmUgc2NoZWR1bGVkIGJ5IGFuIG9wZXJhdGluZyBzeXN0ZW0uIEl0IGdlbmVyYWxseSByZXN1bHRzIHtbJiomXX1mcm9tIGEgZm9yayBvZiBhIGNvbXB1dGVyIHByb2dyYW0gaW50byB0d28gb3IgbW9yZSBjb25jdXJyZW50bHkgcnVubmluZyB0YXNre1smKiZdfXMuIFRoZSBpbXBsZW1lbnRhdGlvbiBvZiB0aHJlYWRzIGFuZCBwcm9jZXNzZXMgZGlmZmVycyBmcm9tIG9uZSBvcGVyYXRpbmcgc3l7WyYqJl19c3RlbSB0byBhbm90aGVyLCBidXQgaW4gbW9zdCBjYXNlcywgYSB0aHJlYWQgaXMgY29udGFpbmVkIGluc2lkZSBhIHByb2Nlc3MuIHtbJiomXX1NdWx0aXBsZSB0aHJlYWRzIGNhbiBleGlzdCB3aXRoaW4gdGhlIHNhbWUgcHJvY2VzcyBhbmQgc2hhcmUgcmVzb3VyY2VzIHN1Y2gge1smKiZdfWFzIG1lbW9yeSwgd2hpbGUgZGlmZmVyZW50IHByb2Nlc3NlcyBkbyBub3Qgc2hhcmUgdGhlc2UgcmVzb3VyY2VzLiBJbiBwYXJ0aWN7WyYqJl19dWxhciwgdGhlIHRocmVhZHMgb2YgYSBwcm9jZXNzIHNoYXJlIHRoZSBsYXR0ZXJcJ3MgaW5zdHJ1Y3Rpb25zIChpdHMgY29kZSkgYW57WyYqJl19ZCBpdHMgY29udGV4dCAodGhlIHZhbHVlcyB0aGF0IGl0cyB2YXJpYWJsZXMgcmVmZXJlbmNlIGF0IGFueSBnaXZlbiBtb21lbnQpLntbJiomXX0gVG8gZ2l2ZSBhbiBhbmFsb2d5LCBtdWx0aXBsZSB0aHJlYWRzIGluIGEgcHJvY2VzcyBhcmUgbGlrZSBtdWx0aXBsZSBjb29rcyBye1smKiZdfWVhZGluZyBvZmYgdGhlIHNhbWUgY29vayBib29rIGFuZCBmb2xsb3dpbmcgaXRzIGluc3RydWN0aW9ucywgbm90IG5lY2Vzc2FyaWx7WyYqJl19eSBmcm9tIHRoZSBzYW1lIHBhZ2UuXCI7e1smKiZdfQ==[[/code]

En resumen

Un thread es un subproceso que corre en paralelo y que comparte la memoria y los recursos con su proceso padre (el proceso padre puede tener varios threads), esto nos permite resolver el problema de la ejecución lineal, y podemos lograr que por ejemplo 2 procesos modifiquen el valor de una misma variable (esto también se puede hacer usando forks u apuntadores :p).

A continuación ejemplifico en un código el rol de un productor y un consumidor, el productor genera Items y el consumidor los consume xD.

Funciona de la siguiente forma, cada thread apunta a una misma localidad de memoria donde va modificando los valores, pero en orden, ya que si no fuera así el valor actual podría ser modificado varias veces por un proceso (el consumidor podría consumir 2 veces seguidas o el productor producir 2 items seguidos).

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
/* Parameters to print_function.
*/

#define BUFFER_SIZE 10
//PRODUCTOS EN EXISTENCIA (memoria que compartiran los threads)
int j = 0; //in
//PRODUCTOS CONSUMIDOS (memoria que compartiran los threads)
int k = 0; //out

//TIPO DE DATO ITEM
typedef struct
{
  int dato;
}item;

//ARGUMENTOS DEL THREAD PRODUCTOR
struct propiedades_prod
{
  item buffer[BUFFER_SIZE];
  //numero de thread creado
  int n;
  int nextProduced;
};
//ARGUMENTOS DEL THREAD CONSUMIDOS
struct propiedades_cons
{
  item buffer[BUFFER_SIZE];
  int nextConsumed;
};

void* productor (void* parameters)
{
  struct propiedades_prod* p = (struct propiedades_prod*) parameters;

  int *creados;
  creados = &j;

  int *consumidos;
  consumidos = &k;
  
  while(1)
  {
    //while((*creados + 1) % BUFFER_SIZE == *consumidos) ;
    while((*creados + 1) == *consumidos) ;
    p->buffer[*creados].dato = p->nextProduced++;
    //printf("Productor: %d creo el producto: %d, %d %d \n",p->n,*creados,p->buffer[*creados].dato,*consumidos);
    printf("Productor: %d creo el producto: %d\n",p->n,*creados);
    *creados = (*creados + 1) % BUFFER_SIZE;
    //*creados = *creados + 1;    
    sleep(1);
  }
}
void* consumidor (void* parameters)
{ 
  struct propiedades_cons* p = (struct propiedades_cons*) parameters;

  int *creados;
  creados = &j;

  int *consumidos;
  consumidos = &k;
  
  while(1)
  {
    while(*creados == *consumidos) ;
    p->nextConsumed = p->buffer[*consumidos].dato;
    //printf("Consumio %d, %d %d \n",*consumidos,p->nextConsumed,*creados);
    printf("Consumio %d \n",*consumidos);
    *consumidos = (*consumidos + 1) % BUFFER_SIZE;
    //*consumidos = *consumidos + 1;    
    sleep(1);
  }
}
/* The main program.
*/
int main ()
{
  pthread_t thread1_id;//productores
  pthread_t thread2_id;//productores
  pthread_t thread3_id;//consumidor

  struct propiedades_prod thread1_prop;
  struct propiedades_prod thread2_prop;
  struct propiedades_cons thread3_prop;

  /* Creamos el 1 thread */
  thread1_prop.n = 1;
  thread1_prop.nextProduced = 0;
  pthread_create (&thread1_id, NULL, &productor, &thread1_prop);
  
  /* Creamos el 2 thread */
  thread2_prop.n = 2;
  thread2_prop.nextProduced = 0;
  pthread_create (&thread2_id, NULL, &productor, &thread2_prop);

  /* Creamos el 3 thread que sera el consumidor */
  thread3_prop.nextConsumed = 0;
  pthread_create (&thread3_id, NULL, &consumidor, &thread3_prop);

  pthread_join (thread1_id, NULL);
  pthread_join (thread2_id, NULL);
  pthread_join (thread3_id, NULL);
  return 0;
}

Para compilar el programa lo pueden guardar por ejemplo como thread.c y desde la shell de linux escriben:

gcc -lpthread thread.c -o thread

salu2

X.25 Ethical Hacking Conferences v 2.0


Debido al exito del primer X.25 se reabre el X.25 version 2.0

Se llevará a cabo del 21 al 23 de Octubre del 2011, uno de los principales eventos en Latinoamérica y primero en su tipo en México relacionado con el (Hacking Ético).

El “X.25 Ethical Hacking Conferences” permitirá reunir a investigadores reconocidos a nivel nacional y mundial quienes compartirán las nuevas tendencias de la seguridad informática a un nivel totalmente técnico quienes son provenientes de una gran variedad de universidades e instituciones de educación superior, organizaciones comerciales del sector público y privado e investigadores que por su propia cuenta han hecho descubrimientos en cuestión de seguridad informática se refiere.

Este evento se dividirá en dos etapas: los talleres de especialización enfocados a capacitar en las principales áreas de Seguridad Informática, y el ciclo de conferencias impartidas por reconocidos expertos que serán invitados a este magno evento para compartir sus últimas investigaciones y experiencias en el área.

VISION:
Ser un congreso reconocido a nivel nacional que impulse y desarrolle la seguridad informática y de igual manera promueva la educación en la misma de una forma ÉTICA y PROFESIONAL.

MISIÓN:
Este congreso esta comprometido a promover y fortalecer la seguridad informática en México, con el objetivo de dar a conocer la importancia que tiene forjar una cultura en cuanto a seguridad informática para asegurar un buen acceso, manejo y distribución de la información en el país

Consulta toda la información en la pagina del evento http://x25sec.ccat.edu.mx/

Este año probablemente si pueda asistir al evento, ya cheque las fechas y creo que no tengo compromisos para esos dias y eso sin mencionar que el paquete de $4500 del evento es muy atractivo :p.

salu2