/Festival Latinoamericano de Instalación de Software libre

"El Festival Latinoamericano de Instalación de Software Libre (FLISoL) es el evento de difusión de Software Libre más grande en Latinoamérica. Se realiza desde el año 2005 y su principal objetivo es promover el uso del software libre, dando a conocer al público en general su filosofía, alcances, avances y desarrollo.
Para tal fin, las diversas comunidades locales de software libre (en cada país, en cada ciudad/localidad), organizan simultáneamente eventos en los que se instala, de manera gratuita y totalmente legal, software libre en las computadoras que llevan los asistentes. Además, en forma paralela, se ofrecen charlas, ponencias y talleres, sobre temáticas locales, nacionales y latinoamericanas en torno al Software Libre, en toda su gama de expresiones: artística, académica, empresarial y social.

El FLISOL2008 se llevará a cabo el sábado 26 de abril.

¿Quién organiza el FLISoL?

La Comunidad de Software Libre en Latinoamérica, conformada por personas y grupos de diversa índole, con el apoyo de otras entidades, principalmente educativas, y algunos patrocinadores de los eventos en cada localidad.

¿A quién está dirigido el evento?

El evento está dirigido a todo tipo de público: estudiantes, académicos, empresarios, trabajadores, funcionarios públicos, entusiastas y aun personas que no poseen mucho conocimiento informático. Si posees o no conocimientos e intereses en informática, licencias, derecho de autor/copyright y demás áreas de la ciencia y la tecnología, déjate tentar, asiste y participa del evento. Nuestro objetivo es compartir conocimientos y ansias de libertad."

Por info mas detallada http://www.comunidad.org.uy/

Probablemente me de una vuelta.

vía boletin del CEI

/Visual Studio 2005 + C#

Como ya se viene Visual Studio 2008, y recordando todo lo que pasé para desinstalar la versión express para instalar VS 2005, dejo aqui, cómo desinstalar VS2005, quizás ayude.

Además, una reseña breve a una de las características mas interesantes para C# 3.0, la inicialización rápida de objetos.

/sallyIDE otro IDE para C++

En esa búsqueda de alternativas ante un problema, llego a sallyIDE (licencia GPL) para C++ para Windows 2000/XP. Lo que lo hace diferente a otros IDEs open source, es que podemos hacer desarrollo visual para aplicaciones Windows, similar al de Visual Studio, esa feature tiene como base la biblioteca SmartWin (licencia GPL) . Fue desarrollado en C# lo que hace necesario descargar el framework .NET 1.1

No lleva mucho tiempo configurarlo para Smartwin y gcc. A favor:

• multicompilador C++
• soporta otros lenguajes
• proyectos y soluciones fácilmente exportables
• plantilla de proyectos
• SmartWin++ Visual GUI Designer integrado. Permite crear aplicaciones Windows de modo visual, usando muy poco código. (Esta biblioteca debe descargarse por separado)
• Smartwin++ y extra widgets

Compiladores: MinGW, VisualC++ 2003, Borland C++ 5.5


En contra:

• No tiene un exportador
• no tiene debugger
• no tiene autocompletado de código

vía la cara oscura del desarrollo

/ubuntu 7.10

Estaba por instalar la versión anterior 7.04, pero ante el inminente lanzamiento de la próxima versión Ubuntu 7.10 (Gutsy Gibbon) el 18 de octubre (supuestamente), decidí esperar.
Estará disponible para descargar en todas sus variantes (Ubuntu, Kubuntu, Edubuntu, Xubuntu).

A parte de la reincorporación de los cambios con Debian y la actualización del Kernel, se añaden al escritorio Linux una serie de efectos visuales 3D, que son parte del proyecto Cumpiz Fusion.




Mejoras:

• "Gnome 2.19.2, con nuevas características y correcciones de errores
• Versión 2.6.22-6.13 del kernel

- reducción del consumo, permitiendo una mayor duración de la batería en los portátiles y un sistema más silencioso y fresco
- mejoras en el módulo de manejo de los dispositivos flash, como los pendrives, haciendo que los dispositivos duren más tiempo y sean menos propensos a fallos
- mejoras en virtualización
- nuevos drivers para soportar nuevos dispositivos y accesorios

• Mejoras en el reporte y reparación de errores. Gutsy incluirá entre otros un menú estilo wizard en el que ayudar al usuario con algunos de los problemas que podrían causar que Ubuntu no iniciara correctamente, como fallos en la configuración de las X.
• Nuevos paquetes desde Debian. Montones de actualizaciones de aplicaciones, así como aplicaciones totalmente nuevas.
• Última versión de X.org, ¡con su nueva herramienta de configuración gráfica!.
• Mejoras en inicio del sistema e inicio de la sesión."

Algunos screenshots y una fuerte comunidad ubuntu en español (esta es la que mas frecuento, hay otras).

Es configurable de manera muy intuitiva, y con el plus de reconocer el hardware sin grandes problemas, incluso las pantallas widescreen desde la versión 7.04, algo que suele o solía ser problemático para Linux.
Buena excusa para que el usuario comun intente con software libre, y para comenzar a aprender Linux de manera menos traumática para aquellos que quieran conocerlo.


vía vivalinux

/punteros por referencia en C/C++

Tanto C++, C#, Java, Delphi estaba olvidada de ciertos detalles de C (los que me vi obligada a refrescar). No es ningun cool trick, pero son esos detalles tontos que pueden llevarnos a depurar un buen rato, sobre todo si no tenemos un buen día o estamos cansados.
Esto es un apunte rápido que se basa en un ejemplo real, concreto, y por ende, espero que sea mas claro, que comento porque son errores (o distracciones) mas comunes de lo que uno pensaría. Quizás escribiéndolo no lo olvide, y quizás para quienes se encuentren enfrentando estos lenguajes, los ayude.

Para el árbol mencionado en este post, debía leer el árbol por niveles y cargar los hermanos que cumplieran cierto criterio.

La función es esta:

Lista* menorHermano(Arbol* arbol)
{
    Lista* listaNros = listaVacia();
    int cantHijos = arbolCantHijos(arbol);
        
    recorreArbol(arbol,cantHijos,listaNros);
 
    return (listaNros);
}

El cabezal de menorHermano estaba fijo, debía retornar una lista formada por los nodos de los diferentes niveles del arbol.

También estaba fijo el cabezal de la función Lista* listaAgregar(int dato, Lista* cola), es más, de Lista solo tenía el .o, y el .h.
Esa era la única biblioteca de la que disponía y debía usar.

La función listaAgregar realiza un insert front, y es llamada dentro de la función recursiva que recorre el árbol. La función recursiva es:
static void recorreArbol(Arbol* arbol, int cantHijos, Lista* &l)

Mi error estuvo en olvidar en pasar por referencia la Lista: el parámetro l que es el que apunta a la lista formada, o que se va formando en cada llamada recursiva.
Ese olvido provocó que al llamar recursivamente la función, el puntero al primer elemento de la lista, no se actualizara. El puntero al primer elemento de la lista siempre tenía el mismo valor, con el cual se llama a recorrerArbol por primera vez (NULL en mi caso).

Finalizado el recorrido quería leer la lista, y resulta que no tenía elementos, y claro, imposible, las inserciones se 'perdieron', porque el puntero al primer elemento nunca se actualizó.

Para evitar eso, debí pasar el puntero a la lista por referencia, ya que al insertar un elemento en la misma, y por tratarse de un insert front, la dirección del primer nodo cambia inserción tras inserción. Y si el puntero no se pasa por referencia, no se modifica.

En C:
static void recorreArbol(Arbol* arbol, int cantHijos, Lista**l)
Se invoca: recorreArbol(arbol,cantHijos,&l)

En C++:
static void recorreArbol(Arbol* arbol, int cantHijos, Lista**l)
Se invoca: recorreArbol(arbol,cantHijos,l)

/leyendo (recursivamente) con fscanf

El 29/08 escribía este post sobre mis problemas para entender fscanf. No es que haya sacado mucho mas en limpio, pero a ensayo y error y leyendo algun que otro man, pude entender al menos lo necesario para resolver el problema.
En general la información o es mas bien críptica o demasiado trivial, por eso dejo un ejemplo concreto, otro más.

La solución fue recursiva nomás. La única restricción es que debía ser llamada dentro de otra función a la cual hay que respetarle el cabezal o su firma.

Para recordar, el formato del archivo a leer es de este tipo:
(Ar 3 (C 2 (d 5) (F 6))(juan 4 )(Ale 5 (Ana 3)))
Entre dos paréntesis consecutivos )) puede haber cualquier cosa, la cual debe ser filtrada.

Arbol* leer(char const* ruta)// firma a respetar.
{
   FILE *fp;
     
   fp = fopen(ruta,"r");
   Arbol* arbol = NULL;  
           
   if (fp)  
   {       
    arbol = getArbol(fp,arbol);        
    fclose(fp);       
   }

   return arbol;
}

Arbol* getArbol(FILE *f, Arbol* a)
{
  
   char c;
   char nom[largoNombre];
   char lin[512];   
   int nro; 
      
   Arbol* arbol = NULL;
   Arbol* subArbol = NULL;
      
   if (!feof(f))
   {       
    fscanf(f,"%[^()]",lin); // leo lo que haya ANTES de ( ó )
        
    fscanf(f,"%c",&c);  // lee los paréntesis    
    if (c == '(')  // hay un nodo del arbol
        {        
            
            fscanf(f," %s %d ",nom,&nro);                
            arbol = arbolCrear(nom,nro);
              
            subArbol = getArbol(f,arbol); //llamo c/hijos           
            subArbol = getArbol(f,a); //llamo con padre a leer hnos
                                    
            if ((a != NULL) && (arbol != NULL))            
                arbolCambiarPadre(arbol,a); //agrega al arbol                          
        }    
   }  
   return arbol;
}   

Notas:

• no es necesario pasar por referencia el puntero a arbol porque la raíz no cambia.
• fscanf(f,"%[^()]",lin) puede sustituirse por fscanf(f,"*[^()]"), el * indica que lo leído no se almacene en ninguna variable. Como desconocía las consecuencias de leer asi, sin almacenar, decidí optar por la primera. El símbolo ^ saltea blancos, tabuladores, nueva línea y espacios.
• Otra forma de leer lo mismo hubiera sido fscanf(f," ( %s %d ",nom,&nro)los espacios en blanco son para contemplar el caso que el string o entero inmediato se encuentren después de una nueva línea (algo que puede darse), salvo esa restricción, no vi necesario el espacio entre %s y %d.
  
• fscanf(f," %s %d ",nom,&nro). El espacio en blanco saltea nueva línea, tabuladores, los espacios que haya, no importa cuantos, basta poner uno saltea los que haya hasta que encuentre una coincidencia que se ajuste al parámetro de lectura.
• El carácter "(" es la condición de parada de la recursividad, se terminaron de leer los hijos del nodo actual, se pasa a leer los hermanos del mismo.
  

Dada la recursividad de la estructura, la función escritura también fue recursiva.

void arbolEscribir(Arbol* arbol,FILE* f)
{
    
    char* nombre = new char[largoNombre];    
    nombre[19] = '\0';
    Arbol* hijo;
    int cant_hijos,k;    
    
    if (arbol != NULL)
    {
        fputs("(",f);
                    
        arbolNombre(arbol,nombre);                
        
        fprintf(f,"%s ",nombre);
        fprintf(f,"%d",arbolNumero(arbol));
        
        cant_hijos = arbolCantHijos(arbol);        
        
        for (k = 0; (k <>
        {
            hijo = arbolHijo(arbol,k);            
            arbolEscribir(hijo,f);            
        }            
        fputs(")",f);
    }    
}
      
// Guarda arbol en formato de s-expresión en el archivo ruta.
void escribir(Arbol* arbol, char const* ruta)
{   
   FILE *fp;
   
   if (arbol == NULL)
   {
      printf("El arbol esta vacio, no hay arbol para guardar\n");
      return;
   }      
      
   if( NULL == (fp = fopen(ruta, "w")) )
   {
      printf( "ERROR: No se pudo crear el fichero, %s\n",ruta);
      return;
   }      
   
   arbolEscribir(arbol,fp);
   fclose(fp);         
}

/otro buscador de código (C++)

Se trata de codecogs está en fase beta, de registro gratuito que permite compartir código C++ orientado a la estadística, matemática, ciencas exactas y finanzas. La idea es crear una base de datos con código Open Source. Aunque hay de varias licencias. El sitio está catalogado segun las diferentes áreas, tiene un foro, un buscador, y cualquier usuario registrado puede subir código. Digamos que por ahora es una especie de foro algo mas especializado, ideal para la enseñanza de ciertos algoritmos, vale la pena seguirlo creo.

/fscanf errático o errática yo

Estoy desarrollando una algoritmo donde debo leer la información contenida en un archivo de texto, y con ella cargar un árbol con una cantidad no determinada de hijos. Justo en el dibujo quedó binario, pero no lo es. Los nodos del árbol tienen como información un nombre y un entero, y el formato del archivo de entrada es de este tipo: (A 1 (B 4 (C 3)) (D 7))
Cada nodo se representa por el par (nombre número).

Nota: no importa lo que haya entre dos paréntesis iguales )) puede haber cualquier cosa, si la entrada fuera (A 1 (B 4 (C 3)au) (D 7)111), el resultado sería el mismo.

Es obvio que la lectura es una función recursiva, y decidí hacerla empleando fscanf (o man fscanf para mas información) porque me permite chequear expresiones.

Al principio buscaba por fscanf(f,"%[()]",&c) donde c es un char. La idea era buscar por el carácter que sea "(" o ")" y leerlo, luego chequear cual fue leído.
El pseudocódigo, después postearé la solución, sería algo asi:

if c == "("
{
    leo numero y nombre
    creo nodo
    llamo con hijo (nodo)
    llamo con hermano del padre de nodo
    asigno padre al hijo.
}

El problema con fscanf(f,"%[()]",&c) es que para leer un carácter segun entiendo no saltea blancos, tabuladores, nueva línea, etc, y si bien identificaba bien los caracteres, la lectura de los datos posteriores (nombre y número) era errática. Por ejemplo a veces incluía el "(" al nombre, o sea quedaría algo asi como (B, y en otras no. No era en todos los casos.

La forma que encontré para solucionarlo fue usar lo siguiente:

char* lin; fscanf(f,"%[^()]",lin); (1)
fscanf(f,"%c",&c); (2) // leo el paréntesis que corresponda
fscanf(f,"%20s%d",nom,nro); // leo los datos del nodo

Lo que hace (1) es leer, saltando blanco, tabuladores, etc, todo hasta que encuentre alguno de los caracteres "(" o ")", esos no los lee. Para leerlos uso (2).
El string lee hasta el primer blanco, nueva línea o tabulador.

La estructura elegida para el árbol es la siguiente (las listas entre hermanos son doblemente encadenadas, algunos requerimientos asi lo imponen) :

Aclaro que omití el puntero al padre de cada nodo por motivos de claridad, pero basta ver cuales son los hijos de cada nodo para notar a qué nodo padre apuntan.

Traducido a C:

struct Arbol
{
       int numero;
       int cantHijos;       
       char* nombre;            
       struct Arbol* hijos;       
       struct Arbol *herSig,*herAnt;
       struct Arbol* padre;
};

Disculpen los dibujos, pero espero sean claros, y como siempre cualquier sugerencia o mejora es bienvenida. Tampoco se si esta será mi solución definitiva.

/tarea de Arquitectura de Sistemas

Dejo una tarea que realizamos junto al Tata para la materia de Arquitectura de Sistemas, materia que consistía en ese entonces sobre circuitos lógicos, álgebra de boole, una introducción a la arquitectura de computadores, concepto de interrupciones, conocer assembler con el fin de programar a bajo nivel los componentes de la arquitectura 8086 (por medio de interrupciones, eventualmente recurrencia, etc), y una introducción a la arquitectura RISC y conceptos del lenguaje SPARC.

La tarea que realizamos fue una de las mejores que hice, tenía menos conciencia pero mas tiempo para dedicarle a facultad, y además porque en esta tarea se amalgaman una serie de conceptos: programación en assembler, manejo de la memoria de video y el manejo de interrupciones.

Objetivo de la tarea: implementar en ambiente DOS un controlador de un dispositivo de entrada/salida como es el mouse, y representar en la pantalla mediante un puntero los posibles movimientos que este hace, así como informar las coordenadas de dicho puntero cuando se presiona el botón izquierdo del mouse.

El trabajo fue realizado en ensamblador 8086, y está basado en la interrupción generada por el puerto serial COM1 o COM2.

Breve explicación:
El problema se divide en tres grandes tareas:

• Recepción de datos
• Procesamiento y detección de errores
• Visualización en pantalla de información relativa al ratón

Un autómata finito muestra las diferentes instancias del problema, este diagrama nos sirvió a los efectos de construir el pseudocódigo de nuestro algoritmo principal.
(En la documentación se explica la semántica de cada estado)

Para abordar esta tarea debimos conocer algo más de lo que nos dieron sobre la UART (Universal Asynchronous receiver/transmitter), dispositivo de E/S que encapsula las funciones de transmisión y recepción empleadas en la comunicación en serie asíncrona

• En serie porque los bits que representan un valor se transmiten uno a uno
• Asíncrona porque se puede recibir/transmitir en cualquier momento

Si bien en la documentación hay una plantilla con mas especificaciones sobre el funcionamiento de la UART, sus registros, la forma en que recibe o envía señales, etc, a nosotros al menos no nos fue suficiente, y debimos googlear. De todos modos, la incluyo a modo de referencia rápida.

documentacion.rar

• maquinas de estados.doc (descripción del problema, abordaje, rutinas)
• uart.pdf (mini manual sobre UART)
• arqoblig.pdf (letra del problema)
• notas.txt (parámetros de la UART, notas generales)

fuentes.rar (contiene los fuentes en assembler del problema, el propósito de cada uno de los mismos está explicado en el archivo correspondiente)

• macro.asm
• setpic.asm
• setuart.asm
• vars.asm
• rrssii.asm
• const.asm
• mouse.asm

utiliarios.rar (archivos necesarios para compliar, linkeditar, generar .com, etc)

• compilo.bat
• tasm.exe
• td.exe
• dosxnt.exe
• tlink.exe

tasm: "Turbo Assembler", ensamblador que genera un código objeto (.obj)
tlink: "Turbo Link", programa que linkedita el código objeto con otras rutinas ya compiladas, generando el programa ejecutable (.exe).
td: "Turbo Debbuger", programa que permite visualizar la ejecución de un programa, inspeccionando el valor de los registros en cada instancia del mismo en forma visual.
dosxnt: para trabajar en terminales Windows NT.

"Para ejecutar el Turbo Assembler en modo de compatibilidad con el código escrito para el Microsoft Macro Assembler, se le debe poner como parámetros:
tasm /jmasm archivo.asm
Como se debe generar un archivo ejecutable de dos .COM, al ejecutar el linker se le pasan los parámetros /t, o sea: tlink /t archivo.obj, luego de esto se habrá generado el archivo.com"

(Sobre el uso de los utilitarios está mas explicado en la letra de la tarea)

Paralelamente, no relacionado con la tarea pero sí con programación assembler, también hay un código que hicimos para preparar el examen y aprender a implementar recurrencia, implementamos el conocido problema de las Torres de Hanoi. (archivo: Hanoi.asm)

Lo pueden descargar desde la sección Fuckultad o aqui:

/otro buscador de código fuente

Naslu es una aplicación web para compartir código fuente entre usuarios, permite la posibilidad de agregarlos a tu blog/sitio para difundirlo.


vía wwwhatsnew

/buscadores de código fuente

Estoy padeciendo con una tarea para facultad, codificar en Perl para encontrar patrones en textos mediante expresiones regulares. Se supone que a esta altura podemos agarrar un manual, arremangarnos y comenzar a 'laburar', y es así, en parte, porque la realidad es que todo funciona a base de mucho ensayo y error.
La verdad que disponemos de poca ayuda sobre el lenguaje y su metodología de uso por parte de la cátedra (pero este es otro tema). Y los manuales generalmente no explican el trick salvador, ni ese detalle que se gana con la experiencia, van a lo general y mas descriptivo. Así que decidí obtener algo de código ejemplo para ir entendiendo (y consultar en foros, otra herramiente que puede ser util).

Hay varios sitios desde donde podemos descargar ejemplos con código fuente disponible.
En los que menciono aqui se puede encontrar código catalogado por tipo de licencias, de lenguajes y por un problema específico a resolver (threads, base de datos, applets, protocolo TCP/IP, etc), una diversidad interesante.

A alguno de ellos llegué googleando o gracias a una extensión de Firefox que me permite usar Stumble Upon.

Consulté en:

• Google CodeSearch
• Codesearch
• Krugle
• Koders

También está Hotscripts, mayormente orientado a código para la programación web (Java, Javascript, Perl, Python, ASP, PHP, etc).

Para buscar código fuente por proyecto, o aplicaciones open source, (o aprender eventualmente) está Sourceforge , pero esto son palabras mayores.
Aunque lo recomendaría para buscar aplicaciones open source, sin problemas de licencia con total funcionalidad, como Gimp, Azureus, Ares, o 7Zip, creo que mucha gente desconoce el origen de estos proyectos.