Estos días, tras el terremoto, viajé a Santiago a visitar a mi amigo personal JuanCri. Esto me ha permitido acercarme nuevamente a la tecnología (me robaron mi MacBook Pro el viernes pasado en Concepción) y comenzar a resolver algunos asuntos pendientes.

En este viaje he tenido la oportunidad de encontrarme con un montón de geeks y entusiastas que están haciendo un aporte importante en las gestiones necesarias para ayudar a los damnificados del terremoto del pasado Sábado 27. Se trata de la gente de ChileAyuda.com. Este portal mantiene diversos servicios informativos, búsqueda de personas, canalización de ayudas, etc. que son actualizados y mejorados minuto a minuto. En las horas que he estado en las oficinas de ChileAyuda.com he podido aportar en algunas cosas también, utilizando los skills que he recibido en mi formación profesional y personal.

Les invito a visitar el sitio Web de ChileAyuda.com y colaborar en lo que puedan para que Chile se levante.

Buscando un momento en Google, encontré una fuente de instalación para el plugin que, aunque no funcionó, me permitió encontrar la fuente correcta. Lo acabo de instalar y trabaja excelente.

http://ea.ddns.com.br:8090/netbeans6.8/UML/catalog_ok.xml

Una lástima que UML ya no esté soportado por Netbeans, pero se demuestra una vez más que la comunidad es un aporte fundamental en distintos aspectos del desarrollo de software y sistemas.

Fuente: http://otroblogmas.com/instalar-plugin-uml-netbeans-6-8/

Exception in thread “main” java.lang.InternalError: Can’t connect to window server – not enough permissions.

El error anterior, oculto en el log de Apache HTTP Server, generado al intentar ejecutar Apache FOP desde PHP para generar informes para un proyecto que estoy desarrollando con Cx Networks, me mantuvo varios minutos preocupado y buscando soluciones para el problema.

Al principio parecía un simple problema de permisos de archivo. Pero tras tomar las acciones comúnmente necesarias (el ya conocido modo diabólico), todo parecía ir de mal en peor. Y es que estaba por maldecir a Steve por hacerme perder el tiempo; ya que en los servidores de Cx Net (Linux) todo funcionaba bien, pero en mi Macbook sólo veía el error en cuestión.

Tras investigar un rato en la Internet (por estos días Google), encontré que el problema se generaba por la imposibilidad de la máquina virtual de Java de acceder a ciertos dispositivos de interfaz humana como el mouse, el display o el teclado. Al parecer esto ocurre cuando llamamos indirectamente a la aplicación Java. Por ejemplo con un usuario que no tiene acceso a una shell como www de Apache (o _www en Mac OS X). También podríamos enfrentarnos a esta situación cuando ejecutamos un proceso Java de manera remota a través de SSH.

La solución es más simple de lo esperado. Al ejecutar el proceso Java, debemos indicar que estamos en un ambiente headless (sin mouse, teclado o pantalla). Para lo anterior, utilizamos el siguiente argumento:

-Djava.awt.headless=true

Para más información sobre el modo headless, les invito a visitar el siguiente enlace:

http://java.sun.com/j2se/1.4.2/docs/guide/awt/AWTChanges.html#headless

Durante estos meses que he usado la laptop, no había sido necesario usarla para desarrollar sitios o aplicaciones Web. Hasta ahora sólo había programado en C, C++, Java. Para estos 3 lenguajes Mac OS X está preparador out of the box. Sin embargo, desde algunas semanas atrás estoy desarrollando un sistema Web como parte de mi Proyecto de Título y, como (me robaron) no tengo un computador de escritorio, he tenido que desarrollar usando el notebook. Hasta ahora lo hacía todo en la nube, pero como el tiempo apremia, y no tengo Internet 3G, he tenido la necesitad de preparar un ambiente de desarrollo en la laptop.

Mac OS X 10.6 viene con Apache 2 (HTTP) instalado y listo para ejecutar (apachectl start o desde System Preferences->Sharing). Entonces sólo era necesario instalar PostgreSQL y PHP 5 con los respectivos drivers. Si bien es cierto existen packages de PostgreSQL para Mac OS X, es mucho más “lindo” compilar el código fuente.

Instalando PostgreSQL

Antes de compilar PostgreSQL necesitamos un paquete llamado readline. Para instalar esta utilidad de GNU podemos usar fink o MacPorts.

$ sudo /sw/bin/fink install readline

Una vez instalado readline, descargamos el código fuente de PostgreSQL. Nota que el siguiente enlace corresponde a la última versión estable de Postgres al momento de escribir este post, y el mirror es para Chile.

$ sudo bash
 
# cd /usr/local/src
 
# curl -O http://wwwmaster.postgresql.org/redir/394/h/source/v8.4.2/postgresql-8.4.2.tar.gz
 
# tar xvfz postgresql-8.4.2.tar.gz
 
# cd postgresql-8.4.2/

Ahora ejecutamos el script configure con los argumentos del path donde se encuentra readline.

# ./configure --with-includes=/sw/include/ --with-libraries=/sw/lib
 
# make
 
# make install

Ahora que PostgreSQL está instalado, sólo resta configurarlo. El primer paso será crear una cuenta de usuario llamado postgres. Esa cuenta la podemos crear utilizando System Preferences->Accounts. Una vez creado el usuario, debemos crear un directorio donde PostgreSQL pueda escribir datos:

# mkdir /usr/local/pgsql/data
 
# chown postgres /usr/local/pgsql/data

Ahora en otra consola, usando el usuario postgres configuramos PostgreSQL:

$ su -l postgres
 
$ /usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data

Listo, ya podemos iniciar el servidor. Pero antes, algo muy útil será configurar el PATH de ejecución, agregando el directorio que contiene los binarios de PostgreSQL (como psql):

$ export PATH=$PATH:/usr/local/pgsql/bin

Para no tener que escribir lo anterior cada vez que hagamos login, lo mejor será ponerlo en nuestro ~/.profile (el de nuestro usuario regular, no postgres).

Iniciemos el servidor, usando el usuario postgres:

$ /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data -l logfile start

Instalando PHP 5 y los drivers para PostgreSQL

Necesitamos recompilar PHP con la opción adecuada para usar PostgreSQL. Como es habitual, descargamos el código fuente desde el sitio oficial php.net. Al momento de escribir este post, la última versión estable es la 5.3.1. Una vez descargada en /usr/local/src, procedemos a configurar y compilar:

# tar xvfz php-5.3.1.tar.gz
 
# cd php-5.3.1/
 
# ./configure --with-pgsql --with-apxs2
 
# make
 
# make install

En el paso de compilación (make), en mi sistema arrojó un error relacionado a la biblioteca ICONV. Buscando en la Web encontré que se trababa de un bug (o al menos así está reportado en el bugtracker de PHP). El workaround que funcionó para mi fue hackear iconv en las fuentes de PHP (ext/iconv/iconv.c); eliminar las líneas 185-187.

Finalmente, copiar php.ini al directorio adecuado

# cp php.ini-development /usr/local/lib/php.ini

Instalando PDO para PostgreSQL

Otra cosa que necesitamos quienes usamos frameworks como PRADO o Symfony, es instalar el driver PDO. El proceso es simple:

$ pecl download pdo_pgsql
 
$ tar xzf PDO_PGSQL-1.0.2.tgz

Ahora necesitamos compilar e instalar la extensión:

$ cd PDO_PGSQL-1.0.2
 
$ phpize
 
$ ./configure --with-pdo-pgsql=/usr/local/pgsql/
 
$ make && sudo make install

Sólo resta editar la configuracion en php.ini:

extension_dir = "/usr/lib/php/extensions/no-debug-non-zts-20090626/"
 
extension = pdo_pgsql.so

Reiniciamos apache (apachectl restart) y listo, ya tenemos nuestro sistema preparado para desarrollar aplicaciones y sistemas con PHP & PostgreSQL.

This pattern is used for problems where you have a very large space and you need to search to make a decision or find an optimal solution. Of course the space is too large for enumerating every point.

In order to find the solution to the problem, this pattern has four operations:  Branching, Evaluation, Bounding and Pruning.
This kind of problems are good for parallelism, even thou synchronization is complicated. You will want to reduce communication and increase computation.

Graphical Models

This pattern gave me a bad impression, because I thought I was going to read about graphics rather than statistics and probabilities. Also as some classmates mentioned, it lacked of a good and clear example.

Structured Grids

This pattern was better written I think, at least it had several examples (thou I missed source code!). The main idea is to decompose (using geometric decomposition) the problem into smaller arrays and perform operations over the arrays in parallel.

The double buffering and adaptive mesh refinement idea was very interesting to me and seems to be very useful for image processing.

Task Parallelism

1. When you first saw this pattern title, did you feel like you knew the subject beforehand? After reading the pattern, did you confirm your impression or did it surprise you? how?
2. In what category falls this pattern?
3. What platform do you have more experience programming parallel applications on? And what Task Management Mechanism? (Jobs over Networks, OS Processes, SW Task Queue, HW Task Queue)
4. Do you think that the lack of new hardware is preventing us of reaching better run times?
5. Do you think that this patterns requires you to learn more about hardware platforms in order to make a correct implementation?
6. Do you agree with the mapping the author made for the Monte Carlo example? Can you think of something else?

Recursive Splitting

1. How to control task granularity in this pattern?
2. In which cases do you prefer to have a good load balancing rather than efficient tasks? Can we find the equilibrium?
3. Can you think of any other popular algorithm (besides Selection Sort) which this pattern can not be applied to?
4. The authors mention the idea of composing the Data Parallelism pattern inside of the Recursive Splitting pattern. Can you think of other patterns composition?
5. The authors mention that the ideas behind the Fork/Join and Task-queue strategy patterns are essential to any developer who wants an efficient implementation of the Recursive Splitting pattern. Why?

Discrete Event

1. In the context of asynchronous communication of events, the authors mention two environments: message-passing and shared-memory. Which environment are you more familiarized with? Which one you like most?
2. Can you give examples of tasks which care about the order in which events arrive? Which approach (optimistic or pessimistic) would you use to deal with the ordering constraint in each one of those examples and why?
3. Do you agree with the authors on that, often, the best approach to deal with deadlocks is to use timeouts instead of accurate deadlock detection?
4. The authors encourage us not to confuse this pattern with the Event-based, Implicit Invocation pattern. Do you see any more differences beside the mentioned by the Discrete Event pattern authors?

Thank you very much.

If I must deal with Linear Algebra when solving a problem (linear operations on vectors or matrices), I will totally use a linear algebra library rather than trying to write functions and algorithms myself. That because is pointless to reinvent the wheel when I can save a lot of time using the standard mathematical operations and routines already packed in libraries where people have put a lot effort on.

Computation can help a lot when solving a problem. Graphs are a very good approach if the problem fits with a certain algorithm or known data structure. Experiments as in the Monte Carlo pattern is a technique that might be implemented more easily today using parallelism, since it requires the generation of thousands of experiments, it execution and to aggregate the results into relevant statistical solutions.

Computational patterns and structural patterns are clearly different to me. In structural patterns you are dealing with entities and its relationships and how to come up with good and efficient designs, while in computation patterns you are pushed to come up with mathematical models.

Thinking of the above paragraph, to abstract concurrency sounds like a very good idea. Factoring out concurrency code make it easy to create and maintain a solid base. The Armstrong idea is to have a generic component which deals with all the concurrency code and different plug-ins written in pure sequential code. That way, expert programmers can code concurrency, and beginners can code the sequential parts.

Software fault-tolerance is possible to achieve using basic techniques like crash catching and timeouts. The thesis also talks about a more advanced techniques using dedicated processes called supervisors, which only task is to handle error. That create two categories of processes: workers and supervisors. That way, workers have not to worry about handling errors.

I think that both, error handling and concurrency abstraction, is possible to achieve using other programming languages (not Erlang) as well. Java could be a good example. I have no experience with those patterns thou, but seems doable.

The Erlang view of the world, everything is a process and that processes can only interact by exchanging messages, helps a lot when creating an HTTP server; spawn a new process for each connection, accept a request from the client and respond appropriately. Lighttpd is a good example: high speed io-infrastructure, scalability and effective management of CPU load by using concurrency.

At the end of the chapter Armstrong talks about Intentional Programming, a style of programming where the reader of a program can easily see what the programmer intended by their code. This style is very useful when maintainability is about.

The Map_reduce pattern aims to hide the details of the parallelism from the programmer when dealing with a large number of computation and summarizing the results. The map reduce pattern solve the problem by applying independently a map function to every object (PLPP pattern, task parallelism) and then using a collective communication pattern to collect and summarize the results (PLPP, reduction). The most famous uses of this pattern are the applications of the map-reduce framework used at Google.

• Completely modular. Each module must be independent of the other modules and should run in a different process. Of course processes must run in parallel.
• Provide fault-isolation. Failure in one process should not adversely affect other processes (unless it has been intentionally designed).
• Communication based on messages: Each process should have a unique identifier, and can communicate each other only using messages. There should be nothing shared among them. Also a communication protocol should exists and the messages passing should be asynchronous.

Armstrong also mentions the fail-stop processor. Such processor should halt on failure (if a failure occurs it is pointless to continue), communicate the cause of the failure to other processors and have both stable and volatile storage.