Festival Latinoamericano de Instalación de Software Libre Flisol 2009 Montevideo - Uruguay

Bueno este próximo 25 de Abril es el Festival Latinoamericano de Instalación de Software Libre tanto en Montevideo como en otros departamentos de nuestro país (y por supuesto, del mundo).

Desde la web del sitio, ¿que es el Flisol?

Es 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.

---

Itinerario:

Anfiteatro Antel

9:00	Apertura	Agradimientos, mención de sponsor etc.
9:30-10:15	Enrique Verdes	Software Libre: guía de supervivencia.
10:30-11:15	Andrea Mangiatordi	Tecnologías de accesibilidad.
11:30-12:15	Mauricio Campiglia	Filtrado de contenidos para padres.
12:30-13:15	Macello Farias	Amenazas en Internet.
13:15-14:00	Receso: Comida,música, etc.
14:00-14:45	Nicolás Levy	Taller Básico de Ubuntu
15:00-15:45	Nicolás Levy	Taller Básico de Ubuntu
16:00-16:45	Marcelo Ramos	El lenguaje de programación Python
17:00-17:45	Nestor Flaquer y Graciela	Uso básico de la Xo.
18:00-18:30	Nestor Flaquer y Graciela	Uso básico de la Xo.
18:30	Fernando Da Rosa	Software Libre y apropiación tecnológica.

Sala Interactiva

9:30-10:15
10:30-11:15	Alejandro Segovia	Ceibal Chess
11:30-12:15	Ceibal Jam	Programación
12:30-13:15	Ceibal Jam	Programación
13:15-14:00	Receso: Comida,música, etc.
14:00-14:45	Virginia Demarco	Taller de Gimp
15:00-15:45	Nicolás Pence	*BSD Sistemas Operativos Libres Alternativos.
16:00-16:45	Carlos Moreira, Mitchel Quilici y Carlos Pirez	Promoviendo la independencia tecnológica
17:00-17:45	Ismael Castagnet Gabriela Rodríguez	Taller: "Democratización del conocimiento en la era de la información (oportunidades, amenazas y desafíos)"
18:00-18:30	Ismael Castagnet Gabriela Rodríguez	Taller: "Democratización del conocimiento en la era de la información (oportunidades, amenazas y desafíos)"
19:00	Cierre del Festival	Sorteos y mas ...

Instalación y Configuración de Apache 2.2 con PHP y MySQl

El otro día me vi en la situación de instalar Apache con PHP y MySQL en mi ubuntu 8.10 (próximamente a convertirse en el 9.1) y googleando encontré mucho material, y arme un instructivo paso a paso de como instalar Apache en Ubuntu.

Ejecutamos para instalar apache.

sudo apt-get install apache2

Ejecutamos para instalar php5:

sudo apt-get install php5 libapache2-mod-php5

Para comprobar que este bien instalado hacemos:

sudo a2enmod php5

Reiniciamos apache:

sudo apache2ctl restart

Instalamos MySQL:

sudo apt-get install mysql-server

Instalamos manejador de php mysql:

sudo apt-get install php5-mysql

Y como complemento si queremos SVN:

sudo apt-get install subversion

Ahora bien, vamos a necesitar identificar y hacer algunos ajustes al apache para que funcione con algunos elementos extras como por ejemplo, los Virtual Host (VHost en adelante).

La idea es crear sitios con virtual host distintos para que cada uno tenga una configuración aparte.

Para esta tarea primero identificaremos la estructura de directorios de apache.

En /etc/apache2 disponemos de varios subdirectorios dos de ellos importantes para nosotros.

•conf.d

•mods-available

•mods-enabled

•sites-available

•sites-enabled

Los ficheros de configuración de los VHost se configuran en sites-available.

En sites-enabled sólo contiene enlaces a aquellos VHost que queremos activar.

Supongamos que queremos crear (por ejemplo) un VHost de nombre "misitio.site" para que, cuando ponga en mi navegador http://misitio.site me lleve a la página principal de ese host.

Observar!! Si pongo http://localhost me llevará al VHost por defecto (distinto del de misitio.site).

Pero antes que nada, para que mi browser "sepa" a que ip conectarse cuando haga el request de misitio.site debo añadir unas líneas al archivo situado en: /etc/hosts

Entonces ejecuto

sudo vim /etc/hosts

Creo una nueva entrada manteniendo lo que había y añado lo siguiente:

127.0.0.1 misitio.site

127.0.0.1 www.misitio.site

En general será {IP} {serverName} à IP y nombre del servidor

Observar que esto solo es necesario para que desde mi propia máquina pueda acceder al sitio por medio del browser, en caso de montar un servidor, este trabajo lo haría el propio dominio que estaría apuntando a la ip de mi servidor.

Ahora comienzo con la creación del espacio en disco para mi sitio, creo una carpeta para el contenido dentro de la carpeta /var/www/ para este caso usaremos: /var/www/misitio.site

Notar que no interesa que como se llame la carpeta, pero es una buena práctica identificarla con el dominio que tendrá.

Pasamos a la configuración del VHost, ejecutamos

cd /etc/apache2/sites-available

Hacemos:

sudo vim default

default es un archivo donde se definen los virtual host y le agrego la línea (esto solo por una única vez) NameVirtualHost *:80

Hago una copia del archivo default ejecutando

cp default misitio.site

Edito el misitio.site y lo dejo, como por ejemplo:

<VirtualHost 127.0.0.1:80>

ServerAdmin admin@misitio.site

DocumentRoot "/var/www/misitio.site/src"

ServerName misitio.site

ServerAlias www.misitio.site

</VirtualHost>

En fin, agrego todo lo que necesite para mi VHost, como por ejemplo reglas de rescritura, etc.

Cierro el archivo y ejecuto

cd /etc/apache2

y luego

a2ensite misitio.site

El comando a2ensite (available 2 enablesite) crea un enlace en sites-enable al site que le indiquemos (es decir, activa el VHost que acabamos de crear)

Comprobamos que todo este OK ls -al sites-enabled/

Recargamos apache /etc/init.d/apache2 reload

En caso de que el VHost configurado lleve reglas de rescritura, se debe cargar el módulo mod_rewrite esto lo podemos hacer con el comando a2enmod ejecutado:

cd /etc/apache2/

y luego

a2enmod rewrite

y por último restart del apache

/etc/init.d/apache2 restart

Y con esto tendríamos pronto un sitio en apache, mediante un virtual host, podremos chequearlo con solo acceder a http://misitio.site

Proyecto de comunicaciones para XO ATI-ORT

Hace unos días, un compañero de trabajo me comentó que, para el proyecto de carrera (en la ORT) propuso hacer un software para las XO (en Uruguay más comúnmente llamadas OLPC).

La breve descripción que presenta en su página es:

Este proyecto intentara crear una red de usuarios de XO, para que esten comu

nicados de varias formas posibles, utilizando tecnologías estándares.

Las web pública del proyecto es: https://sites.google.com/site/ortatiolpccom/

Los nombres de los integrantes son:

• Fabián Bozoglilanian
• Carolina Taranto

Como agregar google analytics en un blog (blogspot)

Hace unos días me encontré con la idea de poner un contador de visitas en este blog, y empecé a buscar ciertas herramientas que me proporcionasen dicho servicio.

Analizando las diferentes opciones que encontré, creo que la más completa fue la de google analytics.

Ya se conoce mucho de esta herramienta, así que no voy a centrarme en eso, sino, en como colocar el código que ellos nos proporcionan, dentro del blog.

Primero que nada, registramos el sitio en Analytics y dejamos a mano el código a colocarse.

Luego, vamos a nuestro blog, en la solapa de Diseño, la sección de "Edición de HTML"

Es ahí que pegamos el código que nos proporciona analytics justo antes del < /body>

Una vez hecho, damos guardar plantilla, volvemos a analytics, y chequeamos que este correctamente instalado el código.

Una vez que empiece a transmitir la data hacia analytics, vamos a poder ver las hermosas estadísticas de las visitas.

Como crear un SVN Externals y no morir en el intento

Hoy se me planteó la necesidad de generar un externals en un repositotio svn de un proyecto complejo, la documentación que encontré fue bastante buena, pero siempre quedan esos "detalles" que nos pueden hacer perder un poco de tiempo

Para empezar, hacemos referencia a que el soft del svn que usamos es el tortoise y tomamos el link de la help para este caso.

Bien, según la ayuda, nos dice que la forma de agregar un externals es la siguiente:

Vamos a la carpeta contenedora de las carpetas que queremos tener como externals

• Clic derecho sobre ésta, TortoiseSVN->properties
  
  
• Clic en new(o add, depende de la versión del svn)
  
  
• De la lista seleccionamos "svn:externals".
  
  Dentro del cuadro de texto, vamos a colocar una o mas instrucciones, cada una representa un external distinto.

• El comando a introducir en el cuadro de texto tiene el siguiente formato:
  carpeta_destino http://ruta_al_repo/carpeta_origen/
  
  Observaciones:
  
  1. Todo el contenido dentro de "carpeta_origen" se copiará dentro de la "carpeta_destino" (que a su vez se creará dentro de la capeta donde definimos el external).
     carpeta_destino es un "alias" a la carpeta apuntada por el external, por lo tanto no debe existir en el repo de destino, si existe, habría un conflicto con entre las dos rutas que deberá leer al momento de hacer el update.
     
  2. La ruta debe terminar con la "/"
  3. Debe haber un espacio entre carpeta_destino y su url en el repo
     
     
• Una vez completada la lista de externals, damos clic en OK y veremos que nos queda solo una línea donde en la columna "Property" aparece el comando "svn:externals" y en "value" aparecen todos los externals definidos separados por un espacio.
  
• Paso siguiente importantísimo, debemos hacer un commit del external para que el svn se de cuenta de ello, y luego, recién allí estamos habilitados para hacer un update del repo para poder ver como (satisfactoriamente) se crean las carpetas (alias) con el contenido de los externals.

Con eso veremos satisfactoriamente como se puede generar un externals sin arrancarse los pelos :D

DFS - Depth First Search

Es muy parecido al BFS, pero más simple..

En este caso vamos a caminar hasta el último de los adyacentes de la rama más a la izquierda, para ir subieno y visitando sus ramas derechas.

Pseudo-código

  DFS(int inicio, Grafo g, int*& visitados){ 

	visitados[inicio] = 1;

	listaAdyacentes = obtenerListaAdyacentes(g, inicio);

	while(!esVacia(listaAdyacentes){

		w = listaPrimero(listaAdyacentes);

		listaAdyacentes = listaResto(listaAdyacentes);

		if(!visitados[w]){

			!visitados[w] = 1;

			DFS(w, g);

		}

	}

}

  void Recorrido_DFS(Grafo g){ 

	int n = cantidadNodos(g);

	for(i=0; i		visitados[i] = 0;

	}

	for(i=0; i		if(!visitados[i])

			DFS(i, g, visitados);

		{

	}

}

BFS - Breadth First Search

Es un algoritmo para recorrer elementos en un grafo, intuitivamente, se comienza en la raíz (eligiendo algún nodo como elemento raíz en el caso de un grafo) y se exploran todos los vecinos de este nodo.
A continuación para cada uno de los vecinos se exploran sus respectivos vecinos adyacentes, y así hasta que se recorra todo el árbol.

Formalmente, BFS es un algoritmo de búsqueda sin información, que expande y examina todos los nodos de un árbol sistemáticamente para buscar una solución.
El algoritmo no usa ninguna estrategia heurística.


En español:

Dado un vértice de inicio, tomo la lista de sus adyacentes y los recorro, antes de entrar en profundidad de los adyacentes de éstos.

Finalizado el nivel, entro a recorrer mis nuevos adyacentes no visitados aún (que son adyacentes de uno de los adyacentes del nodo inicial).

Pseudo-código:

  BFS(grafo G, nodo_fuente s)
{
   // recorremos todos los vértices del grafo inicializándolos a NO_VISITADO,
   // distancia INFINITA y padre de cada nodo NULL
   for u ∈ V[G] do
   {
      estado[u] = NO_VISITADO;
      distancia[u] = INFINITO; /* distancia infinita si el nodo no es alcanzable */
      padre[u] = NULL;
   }
   estado[s] = VISITADO;
   distancia[s] = 0;
   Encolar(Q, s);
   while !vacia(Q) do
   {
      // extraemos el nodo u de la cola Q y exploramos todos sus nodos adyacentes
      u = extraer(Q);
      for  v ∈ adyacencia[u]  do
      {
         if estado[v] == NO_VISITADO then
         {
              estado[v] = VISITADO;
              distancia[v] = distancia[u] + 1;
              padre[v] = u;
              Encolar(Q, v);
         }
      }
   }
}

El tiempo de ejecución es O(|V|+|E|). Nótese que cada nodo es puesto a la cola una vez y su lista de adyacencia es recorrida una vez también.

Fuente: wikipedia

Algoritmo de Prim

El algoritmo de Prim

Es un algoritmo de la teoría de los grafos para encontrar un árbol recubridor mínimo en un grafo conexo, no dirigido y cuyas aristas están etiquetadas.

En otras palabras, el algoritmo encuentra un subconjunto de aristas que forman un árbol con todos los vértices, donde el peso total de todas las aristas en el árbol es el mínimo posible. Si el grafo no es conexo, entonces el algoritmo encontrará el árbol recubridor mínimo para uno de los componentes conexos que forman dicho grafo no conexo.


Pseudo-código

PRIM (Grafo G, nodo_fuente s)
     // inicializamos todos los nodos del grafo. La distancia la ponemos a infinito
     // y el padre de cada nodo a NULL
      for each u ∈ V[G] do
          distancia[u] = INFINITO
          padre[u] = NULL
      distancia[s]=0
      //encolamos todos los nodos del grafo
      Encolar(cola, V[G])
      while cola != 0 do
          // OJO: Se extrae el nodo que tiene distancia mínima y se conserva la condición 
          // de Cola de prioridad
          u = extraer_minimo(cola)
          for v ∈ adyacencia[u] do
              if ((v ∈ cola) && (distancia[v] > peso(u, v)) do
                  padre[v] = u
                  distancia[v] = peso(u, v)

En español:

• Como debemos tener un vértice de partida, tomamos este vértice y armamos una lista con las aristas de sus adyacentes.
  Esa lista la confeccionamos en orden descendiente según su costo.
• Tomamos la arista de menor costo (siempre y cuando, al agregar esta arista, no generemos un ciclo) y la agregamos a nuestro árbol.
• Para el siguiente paso, vamos a tener que utilizar el vértice que acabamos de colocar, agregamos las aristas adyacentes de éste de la misma manera que lo hicimos anteriormente.
• Y así sucesivamente hasta tener todos los vértices del grafo, dentro del A.C.C.M.

fuente: wikipedia (pseudo-código) y apuntes mios

Algoritmo de Kruskal

Kruskal

El algoritmo de Kruskal es un algoritmo (ávido) de la teoría de grafos para encontrar un árbol de recubriumiento mínimo en un grafo conexo y ponderado.
Es decir, busca un subconjunto de aristas que, formando un árbol, incluyen todos los vértices y donde el valor total de todas las aristas del árbol es el mínimo

En este caso me limitaré al caso de grafos conexos con costos no negativos en sus aristas

Funcionamiento:

Se parte colocando todos los vértices del grafo separados, y se decide partir por un vértice de "Inicio".

Dado el vértice actual (en el comienzo es el de inicio), armamos una lista de todas las aristas que posee, ordenadas en forma decreciente según su ponderación (costo de la arista).

Tomamos la de menor coste, retiramos de la lista de candidatos a la arista utilizada y agregamos las nuevas aristas que nos proporciona el nuevo vértice.

Así sucesivamente, generando subgrafos conexos hasta llegar a conectar todos los subgrafos conexos formando un Árbol de cubrimiento de costo mínimo.

Un excelente ejemplo se encuentra en el artículo dedicado a este algoritmo en wikipedia

Algoritmo de Dijkstra

Dijkstra en un algoritmo voraz que sirve para hallar la menor distancia entre dos nodos en un grafo conexo, acíclico, dirijido y con costos no negativos en sus aristas.

De esto hay mucho en wikipedia, por lo que solo me voy a limitar a dar algunas consideraciones que, en el estudio de este algoritmo fueron apareciendo a mi vista :D

El algoritmo sirve para hallar el mínimo camino entre un par de nodos o bien si es aplicado a cada par de nodos, obtendremos el mínimo camino entre todo par de nodos.

El algoritmo no necesita ser recursivo, basta usar 3 for anidados (para el caso anterior).

El orden del algoritmo para encontrar el mínimo camino entre un par de nodos es O(n^2) y para encontrar el mínimo entre todo par de nodos (usando Programación dinámica) es el mismo, notar que no depende del tipo de implementación que se use (cola de prioridad ó vector de visitados)


Inicialmente S contiene únicamente el nodo origen y al final contendráá todos los nodos de G.
En cada paso se selecciona aquél nodo de C cuya distancia al origen sea mínima y lo añadimos a S.
Cuando se detiene el algoritmo todos los nodos del grafo pertenecen a S

Pseudo-código

void dijkstra(int fuente, Grafo g, matriz costoAristas){
S = {fuente}
n = cantidadVertices(g)
for(i=0; i //vector de costos
costos[i] = costoAristas[fuente, i] //inicializo el costo desde la fuente hasta los otros vértices ( infinito en el caso que no exista relación)
//vector de camino final (si acaso necesitamos recontruir el camino más corto)
caminoRecorrido[i] = fuente
visitados[i] = 0; //inicializo un vector de nodos visitados
}
visitados[fuente] = 1;//marco a la fuente como visitada

for(i=0; i if(i != fuente){
w = obtenerMinimoVerticeDisponible(g) //esto es : el minimo del conjunto (V - S)
S = S U {w} //agrego el vértice utilizado
visitados[w] = 1 //lo marco como visitado
for(j=0; j if(visitados[j] != 1){
//que es menos costoso, ir directamente -> costos [j] o ir mediante un w intermedio?
if(costos[w] + costoAristas[w, j] < costos[j]){
//es menos costoso ir mediante w
costos[j] = costos[w] + costoAristas[w, j];
caminoRecorrido[j] = w //agrego el nodo utilizado
}
}
}
}
}
}

Creación de Módulos en C

Estas entradas van dirigidas a personas que ya tienen una noción básica de las cosas tales como los módulos, creación del main, tipos de funciones, etc. Por lo que me voy a centrar solo en algunas cosas que creo, son importantes.

Los módulos en C son prácticamente iguales que los demás lenguajes, aquí no tenemos funciones public o private pero si podemos tener un manejo de eso al nivel de los .h

Entonces, la estructura de un .h es del tipo

//Estas lineas nos indican que si en el momento de la compilación no fué definido (incluído) este módulo, entónces que lo incluya.
#ifndef NOMBRE_MODULO
#define NOMBRE_MODULO

// Declaro la función, lo que devuelve y lo que recibe
void escribir(Estructura* miEstructura, char const* ruta);

Estructura* leer(char const* ruta);

//Finaliza la definición
#endif

En el código fuente de mi modulo puedo tener más funciones que las que hay en el .h, pero nunca pueden faltar las que estan declaradas en el .h de lo contrario no compilará.

Se puede tomar al .h como un módulo de definición donde solo aparecen las cabezeras públicas.

El código fuente de ese modulo debrá tener la siguiente esreuctura:

//Incluímos el módulo de definición
#include "nombre_modulo.h"

//Escribimos las implementaciones de las funciones
void escribir(Estructura* miEstructura, char const* ruta){
/*Implementacion
...
*/
}

Estructura* leer(char const* ruta){
/*Implementacion
...
*/
}

//Esta funcion es de uso privado por lo cual no podrá ser accedida desde fuera del módulo
void funcionAuxiliar(Estructura* miEstructura){
/*Implementacion
...
*/
}


Con esto ya tenemos para comenzar a crear módulos

Codificanco en C*

Hace un tiempo tuve que rendir una materia llamada Programación 3 la cuál requería codificar en C*.
Ya terminada esta materia quería compartir con el ó los que sean algunas partes de los laboratorios, así puede llegar a servirle de algo a alguno.

El lenguaje utilizado fué el C con algunas facilidades de C++ el entorno fué el cygwin con los siguientes compiladores:

• Versión de gcc: 3.4.4
• Versión de g++: 3.4.4
• Versión de gdb: 6.3.50-2004-12-28-cvs

Primero que nada, lo mas importante es saber compilar un main por lo que el primer "Tip" será dejar un makefile (archivo con instrucciones de compilación para generar el exe).

Como referencia tenemos:

• .cpp -> código fuente
• .h -> módulo de definiciones (se escriben los cabezales de las funciones que se podrán acceder desde fuera del módulo creado)
• .o -> archivo linkeditado, se genera al momento de la compilación, éstos son el/los módulos compilados en lenguaje máquina. Si no sproporcionan estos archivos sin los .cpp igualmente podremos usar las funciones que contengan (declaradas en el .h).
• makefile -> archivo son extensión que contiene las instrucciones para compilar

#CC es una variable para el makefile, así no escribo repetidas veces lo mismo. g++ es el compilador
CC=g++
#CFLAGS idem.
#-Wall -> todos los warnings, -Wextra -> Warnings extras
CFLAGS=-Wall -Wextra -ansi -pedantic -O1 -ggdb
#all nombre reservado que dice como se llamará el exe y el path del mismo
all: /home/Usuario/files/nombreDelExe

# EXE ARCHIVO, se deben listar todos los archivos .o (object) que se necesitan
/home/Usuario/files/nombreDelExe: /home/Usuario/files/modulo_1.o /home/Usuario/files/modulo_2.o
$(CC) $(CFLAGS) /home/Usuario/files/modulo_1.o /home/Usuario/files/modulo_2.o -o $@
#$(CC) $(CFLAGS) uso las variables para compilar

#generamos un object por cada modulo que tenemos
/home/Usuario/files/modulo_1.o: /home/Usuario/files/modulo_1.cpp /home/Usuario/files/modulo_1.h Makefile
$(CC) $(CFLAGS) -c /home/Usuario/files/modulo_1.cpp -o $@

/home/Usuario/files/modulo_2.o: /home/Usuario/files/modulo_2.cpp /home/Usuario/files/modulo_2.h Makefile
$(CC) $(CFLAGS) -c /home/Usuario/files/modulo_2.cpp -o $@

# Compilamos el Main
/home/Usuario/files/mainModule.o: /home/Usuario/files/mainModule.cpp Makefile
$(CC) $(CFLAGS) -c /home/Usuario/files/mainModule.cpp -o $@