diego sevilla’s weblog
it is better to remain silent and be thought a fool,
than to open your mouth and remove all doubt -- groucho marx

28/10/2005

Concurso de fotografía digital Municipios de la Región de Murcia: ¡Un accésit!

Filed under: español, fotografía/photo — Diego Sevilla @ 9:25 — In English

Qué contento estoy, porque ha salido por fin la lista de premiados en el concurso de fotografía ditial de pueblos de la Región de Murcia. ¡¡Un accésit!! No está mal para no haber cogido una cámara en mi vida antes de este concurso. :) El premio me lo han dado por quizá la mejor foto que saqué de toda la serie, una llamada «Castillo». Las fotografías, según reza en el sitio web, aparecerán en breve.

Enhorabuena a todos los ganadores, y en particular al «contrincante» que ha ganado el premio para Mula, a la única ciudad que me presenté, Joaquín Molina Muliterno.

Por lo que he contado rápido, hay 35 premios de pueblos de los 45 municipios de los que se podía presentar reportaje, con lo que han quedado 10 premios desiertos.

*Actualización*: Las fotos ya están disponibles en la página web que cito arriba. La entrega de premios será el Viernes 4 de noviembre de 2005 en el aula de cultura de Cajamurcia en la Gran Vía de Murcia a las 20:00 horas.

El lenguaje Lua

Filed under: español, código/code — Diego Sevilla @ 8:55 — In English

Por casualidad he llegado de nuevo a la página del lenguaje de _script_ Lua. En su página, al ver las noticias he visto que se había publicado un libro relativamente «diferente»: Game Development with Lua, del cual también se puede ver su primer capítulo. De siempre me han fascinado este tipo de lenguajes de programación de desarrollo rápido de aplicaciones, y me encanta ver ejemplos como estos, en los que un lenguaje de _script_ se utiliza embebido para ayudar al desarrollo de un programa tan complejo como un juego. Del primer capítulo:


In our company, we recently shipped our 13th game using Lua. Our team is
small, but it has the standard mix of programmers, artists, and designers.
When we get ready to start a new project, we first identify the technology
needs of the project (what are the new things that we need to implement that
we don’t already have?) and work to design the functionality we need. The
programmers can, armed with this technical design, hunker down and focus
on the issues they know best. Simultaneously, the designers and artists can lay
out the flow of the interface and the core functionality of the game—and they
can get started, right away. Often the artists (both 2D and 3D) spend some
time capturing the needed look and feel of the game. While this process is
going on, the three designers, who are all fluent in Lua as well, dive in and
begin constructing the foundation of the game, the game data, and the core
game systems. They don’t even have to wait for the programmers; if there is
some functionality they need, they can often “sub it in” in Lua and press on.
The end result is that we can develop games much more rapidly because we’ve
got the entire team working full force from the get-go.

One project in particular stands out: while working on an election simulator
for the 2004 presidential election, we were able to prototype nearly 100
percent of the game in Lua to test our approaches to AI and game flow, and
then later go back and re-engineer the mission-critical components into C++.
The ability to prototype allowed a single developer to work through the lion’s
share of the design and development process, which is a level of efficiency rare
in this industry.

Magnífico. Desarrollan casi entero el juego con Lua y luego reescriben las partes críticas en tiempo/eficiencia en C++. Este tipo de ideas también me gusta porque compite contra la fiebre que parece haberse instaurado en el desarrollo de software según la cual hay que sacar los programas cuanto antes y como sea. Con este paso intermedio, aparte de que tu programa tendrá menos errores (doble codificación), el desarrollo final será más rápido, porque la mayoría del programa que no tiene que ser crítico en el tiempo se ha desarrollado en un lenguaje mucho más rápido de escribir (por eso se llaman RAD, _Rapid Application Development_).

25/10/2005

Ouch! Oh, well, good shots!

Filed under: english, español, fotografía/photo — Diego Sevilla @ 20:31 — In English



Ouch! Oh, well, good shots!

Originally uploaded by dsevilla.

Cuando me compré la cámara me dijeron que hací­a muy buenos disparos. ¡Ouch!

Flickr - Critique For Starters

Filed under: español, fotografía/photo — Diego Sevilla @ 12:46 — In English

Hace unos días entré como administrador en el grupo “Flickr - Critique For Starters“. Es un grupo donde la gente puede enviar sus fotos (máximo una por semana) para que el resto de miembros puedan comentarlas dando ideas de cómo mejorarlas, etc. Recomiendo a todo el que tenga una cuenta Flickr que se incluya en el grupo.

También, y dependiendo de vuestro nivel (ya sabéis el mío :) ), podeis entrar en Critique - Intermediate o en Critique - Advanced.

El creador del grupo, Timothy Hamilton, tiene también un weblog muy interesante.

23/10/2005

working

Filed under: english, fotografía/photo — Diego Sevilla @ 23:06 — In English



working

Originally uploaded by dsevilla.


22/10/2005

Sparklines

Filed under: español, crítica/critics — Diego Sevilla @ 10:37 — In English

Dándome una vuelta por el Planeta GNOME Hispano he encontrado un post de Federico Mena-Quintero en el que cita un capítulo de muestra de un libro llamado «Beautiful Evidence». El capítulo en concreto habla de los «Sparklines», gráficos del tamaño de una palabra que resumen de forma visual un conjunto de informaciones. El capítulo es genial, y podéis verlo aquí: Sparklines: Intense, Simple, Word-Sized Graphics, una joya.

21/10/2005

Sistemas Distribuidos

Filed under: General, CORBA & Component Model (CCM), español, código/code — Diego Sevilla @ 19:39 — In English

Como ya he dicho alguna vez en este weblog, imparto en la Facultad de Informática la asignatura de Sistemas Distribuidos. El otro día tuvimos la introducción a la asignatura en la que hacía un pequeño repaso en lo que han sido (y son) los sistemas distribuidos. Desde los sistemas centralizados a los sistemas distribuidos actuales, servicios Web, CORBA, etc. Esto suscitó una pregunta de un alumno, Bassman contertulio de Planet Murcia, y que no sabía que lo tenía de alumno. He aquí su pregunta (con pequeñas ediciones, ya que fue en un correo electrónico):


Todo eso está muy bien lo de CORBA, middleware y tal pero… ¿qué pasa
con los pequeños electrodomésticos o dispositivos móviles que
utilizarán servicios distribuidos? Es viable implementar esas
arquitecturas en hardware con poca capacidad? Por otra parte, las
arquitecturas middleware y los buses asíncronos de comunicación
implementan una arquitectura lógica cliente-cliente, pero sigue
existiendo la necesidad de administrar el canal común mediante algún
tipo de servidor, al igual que en redes P2P se acceden a servidores
para darse de alta en el servicio distribuido.

Todo esta duda me surge porque ya sois dos los profesores que habéis
comentado ambas tecnologías, dejando “en el aire” algo tan importante
como es la gestión de ese canal común. ¿Es tan sencilla su
implementación o está ya tan optimizada que no merece la pena
comentarlo? Quiero saber más al respecto.

En la asignatura de “Desarrollo de Aplicaciones Distribuidas” de la
intensificación del software vamos a dar de forma casi exclusiva web
services en plataforma Java, y ahí nos lo pintan todo como muy en
auge, mientras que tú nos das una imagen de decadencia.

Por último, […] sobre
programación en C++, en la carrera no nos dan NADA de NADA, ya que el
resto del profesorado prefiere usar Java por ser más “didáctico” y más
“de moda” (me supongo).

Interesantes reflexiones. Déjame que te responda en orden.

Primero, me preguntas sobre los dispositivos de poca capacidad hardware. Supongo que te refieres a teléfonos móviles/PDAs. Me encanta que me hagas esa pregunta, porque precisamente, existen varias implementaciones de CORBA para ellos. Por ejemplo, LUAOrb. Además, existen especificaciones como Minimum CORBA diseñada y pensada específicamente para este tipo de periféricos. La mayoría de implementaciones de CORBA actuales permiten compilar casi sin restricciones todos los ORBs de libre distribución en PDAs. Por ejemplo, Eduardo Martínez, también de la Universidad utiliza MICO compilado en una PDA, y muchos de los operadores de telefonía (por ejemplo Telefónica) utilizan CORBA para gestionar las conexiones telefónicas. Lo bueno de estos aparatos pequeños es que cada vez se hacen más potentes.

Hablas después de los buses de comunicación «peer-to-peer». Interesante reflexión. También hablé yo de la gestión de arquitecturas MOM («Message-Oriented Middleware»), que se basan en un bus de comunicación. ¿Qué pasa con la gestión de ese bus? Pues que se puede realizar, como bien dices y es el caso de los sistemas p2p, gracias a un servidor. Los elementos que se conectan al bus no tienen que tener un protocolo especialmente complejo, ya que sólo indican su presencia, y recogen todos los mensajes que circulan por la red, siendo capaces de enviar también sus propios mensajes. El símil de este caso con dispositivos pequeños lo tenemos en una tecnología que utilizamos todos los días: los móviles. Imagina la red GSM como un bus en el que se envían y reciben mensajes de una aplicación distribuida. Ahí tendrás la respuesta a tu pregunta sobre dispositivos pequeños. Imagina la torre receptora como gestor de los distintos canales y ya está.

El siguiente punto que mencionas es mi particular aversión a los servicios Web. Te diría que esperes a ver ambas asignaturas y decidas por tí mismo. El paradigma de servicios web se encuentra en la actualidad ante un franco estancamiento. Sí, las empresas utilizan los servicios web, al menos eso dicen. Sin embargo, en cinco o seis años de desarrollo, no han pasado de ser utilizados para servicios simples de petición/respuesta. Mi principal crítica, resumiendo, son varias. Primero, el paradigma de servicios web se basa en un protocolo (SOAP) que no está optimizado para comunicaciones distribuidas, ya que está basado en texto y es muy ineficiente (esto, por sí solo, y teniendo en cuenta que los servicios web se utilizan para realizar aplicaciones distribuidas, ya es un error grave). Después, se ha puesto mucho hincapié en que los servicios web permiten comunicar cualquier cliente y servidor sobre Internet, etc., cosa que ya se lograba con otras tecnologías (véase CORBA) hace muchos años. Además, hay un conjunto monstruoso de especificaciones, muy difíciles de comprender y sobre las que nadie llega a un consenso. Después de 5 años no han llegado a consenso en cuestiones tan simples como el «workflow» de servicios web (totalmente necesario para realizar servicios web en cascada), etc. Todo eso ya era posible en CORBA, y de una manera mucho más natural y con estándares más sencillos. Etc, etc, etc.

Por último, el problema de C++. Veo muy mal que no se enseñe C++ en una Ingeniería Informática. Sin entrar en guerras de lenguajes de programación, pienso que C++ es hoy por hoy uno de los lenguajes más importantes y más utilizados, y un Ingeniero debería conocerlo como la palma de su mano. En la asignatura procuraremos introducirlo para que a partir de ahí seais capaces de desarrollar código CORBA/C++. Es triste, pero muchos profesores ni siquiera saben programar en C++ y no conocen sus beneficios, como la STL.

Espero haber despejado algunas dudas. Un saludo.

20/10/2005

Tennessee’03

Filed under: General — Diego Sevilla @ 22:58 — In English



Tennessee’03

Originally uploaded by dsevilla.


19/10/2005

caleido2

Filed under: español, fotografía/photo — Diego Sevilla @ 0:46 — In English



caleido2

Originally uploaded by dsevilla.


caleido

Filed under: español, fotografía/photo — Diego Sevilla @ 0:45 — In English



caleido

Originally uploaded by dsevilla.


Interesting post on XML messaging by Stefan Tilkov

Filed under: CORBA & Component Model (CCM), english, código/code — Diego Sevilla @ 0:01 — In English

Just a little while after I wrote something about people talking about CORBA failure, I find this post that I wanted to link it because I have some questions that I stated in his web site. You can read the post and comments here. It refers to an article in Steve Vinoski’s weblog, that in turn refers to another one of Mark Baker claiming that CORBA has failed. By now, I’ve heard that so many times that I can assure it’s not true :) Mark itself refers to another article from John Udell that I can’t find. Mark says that the primary reasons for CORBA failure are technical ones… Well, Web Services haven’t still reached the level of maturity or technical development that CORBA has…

18/10/2005

¿Canon EOS 350d o Nikon D50?

Filed under: español, fotografía/photo — Diego Sevilla @ 17:52 — In English

Cuando uno piensa en comprarse una cámara reflex digital y no es un profesional de la fotografía, hay algunas alternativas de características parecidas. Tan parecidas y tan clásicamente competidoras que uno siempre las ve juntas en comparativas y pruebas. La mayoría de ellas están por debajo de 1000¤, algunas incluyendo dos objetivos, uno gran angular y otro teleobjetivo. Canon EOS 350d, Nikon d50, Olympus E-300, Pentax ist*DS y Konica Minolta 5D, entre otras, son las que siempre se consideran.

Al final, viendo las comparativas casi diría que me he decidido por la Canon EOS 350d. Sin embargo, siempre me cabe la duda, y siempre estoy de «peleas» con mi compañero Juan Antonio, porque él es un fan de la Nikon d50. Me gustaría saber qué experiencia tiene la gente que lea este weblog.


canon eos 350d

17/10/2005

Mantenimiento superado

Filed under: General, español — Diego Sevilla @ 22:58 — In English

Bueno, sin muchos quebraderos de cabeza (salvo alguna cuestión de configuración de mysql) he conseguido migrar el weblog. Ahora esto se ejecuta sobre la máquina que os dije…

14/10/2005

Mantenimiento

Filed under: General, español — site admin @ 11:34 — In English

Esta tarde este sítio pasará a mantenimiento. Le voy a poner un ordenador algo mejor (Pentium 630, 3GHz.) y migraré todo el sistema Debian Sid a Ubuntu. Tendré que migrar a mano también Wordpress… Espero no tener muchos problemas. Así que puede que este weblog y planet murcia estén inaccesibles durante el fin de semana. Perdón por las molestias.

13/10/2005

Más sobre lomografía

Filed under: español, fotografía/photo — Diego Sevilla @ 19:31 — In English

Después del post sobre lomografía me he lanzado a hacer la prueba. La lomografía, según puedo ver en Wikipedia tiene hasta unas reglas y todo. Yo me he limitado a aplicar el plugin, aunque estudiaré con más detenimiento eso de «_Shoot from the hip_» (dispara desde la cadera…). Ahora que lo pienso, la mayoría de fotos que he visto con efecto LOMO son así. En fin, poco a poco se aprende. Por ahora, las imágenes para su comparación:


Original ImageLomo Effect

La de la izquierda es la original, y la de la derecha es la LOMO. El _script_ tiene algunos parámetros así que el efecto final depende de los que seleccionemos, y sí, digamos que la imagen original es más fiel a la realidad, pero en eso consiste el efecto, en dar a las imágenes un color que si bien se ve que no es real, entra dentro del conjunto de colores que una persona puede apreciar como diferente pero atrayente.

Prácticas de redes

Filed under: General, español, código/code — Diego Sevilla @ 1:19 — In English

Para este año me ha parecido muy interesante la práctica de «Redes y Sistemas Distribuidos» de la cual soy profesor. Vamos a proponer un servidor de vídeo bajo demada. Para ello, hemos diseñado un formato de vídeo muy sencillo en blanco y negro, y un API que permite que los alumnos puedan leer un vídeo y lo muestren en una ventana aparte usando SDL.

He aquí el API:

/* -*- mode: C; c-basic-offset: 8; -*- */
#ifndef __GRAPHICS_H
#define __GRAPHICS_H

/* Tipo byte */
typedef unsigned char byte;

/**
 * Tipo WBImage — Encapsula una imagen.
 */
struct _WBImage
{
        /* Tamaño de la imagen */
        unsigned short x;
        unsigned short y;

        /* Datos de la imagen */
        byte* pix;
};
typedef struct _WBImage WBImage;

/**
 * Tipo WBVideo — Encapsula un video.
 */
struct _WBVideo
{
        /* Tamaño de cada imagen del video */
        unsigned short x;
        unsigned short y;

        /* Identificador del fichero abierto */
        int fh;
};
typedef struct _WBVideo WBVideo;

/**
 * Inicializacion del sistema grafico
 *
 * Se tiene que llamar al principio del programa. Antes de poder mostrar ninguna
 * imagen en la pantalla.
 */
void initGraphics();

/**
 * Creacion de la ventana.
 *
 * Crea una ventana del tamaño especificado en x e y.
 *
 * @param x int Tamaño en horizontal.
 * @param y int Tamaño en vertical.
 */
void initScreen (int x, int y);

/**
 * Carga un fichero .wb y retorna un WBImage
 *
 * @param file const char* Fichero a leer
 *
 * @return WBImage La imagen.
 */
WBImage loadWBImage(const char* file);

/**
 * Libera la memoria asociada a una estructura WBImage
 *
 * Es necesario llamarlo para cualquier imagen retornada por estas funciones.
 *
 * @param i WBImage La imagen.
 **/
void freeWBImage (WBImage i);

/**
 * Abre un vídeo para ir leyendo imagenes
 *
 * El fichero dado como parametro queda abierto y se utilizara en subsecuentes
 * llamadas a readNextImage().
 *
 * @param file const char* Fichero de video a abrir.
 *
 * @return WBVideo El video.
 */
WBVideo openVideo (const char* file);

/**
 * Lee la siguiente imagen de un video.
 *
 * Esta funcion lee la siguiente imagen de un video. En el caso de que ya no quedaran
 * imagenes en ese video, la imagen retornada tiene los valores x e y puestos a 0.
 *
 * @param v WBVideo El video.
 *
 * @return WBImage La siguiente imagen del video.
 */
WBImage readNextImage (WBVideo v);

/**
 * Cierra un video
 *
 * Libera los recursos asociados a un video abierto.
 *
 * @param v WBVideo El video a cerrar.
 */
void closeVideo (WBVideo v);

/**
 * Pone un WBImage en la ventana
 *
 * @param i WBImage La imagen a mostrar en la ventana.
 */
void paintWBImage (WBImage i);

#endif /* __GRAPHICS_H */

Y después la implementación:

/* -*- mode: C; c-basic-offset: 8; -*- */
#include "graphics.h"
#include <SDL.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>

/* Variables locales */

/* Paleta de colores */
static SDL_Color colors[256];
/* Ventana */
static SDL_Surface *screen;

void
initGraphics(void)
{
        int i;

        /* Paleta blanco y negro */
        for (i=0;i<256;i++)
        {
                colors[i].r=i;
                colors[i].g=i;
                colors[i].b=i;
        }

        /* Initialize SDL */
        if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
        {
                fprintf(stderr, "Couldn’t initialize SDL: %sn",SDL_GetError());
                exit(1);
        }

        atexit(SDL_Quit);
}

void
initScreen (int x, int y)
{
        Uint8  video_bpp;
        Uint32 videoflags;
        videoflags = SDL_SWSURFACE|SDL_ANYFORMAT|SDL_HWPALETTE;
        video_bpp = 8;

        /* Set video mode */
        screen = SDL_SetVideoMode(x, y, video_bpp, videoflags);
        if ( ! screen )
        {
                fprintf(stderr, "Couldn’t set %dx%d video mode: %sn",
                        x, y, SDL_GetError());
                exit (2);
        }

        /* Set palette */
        SDL_SetColors(screen, colors, 0, 256);
}

/* Local: carga un WBImage de un fichero abierto */
static int
_readWBImage (int fh, WBImage* i)
{
        if (0 == read (fh, (void*)&i->x, sizeof(unsigned short)))
                return -1;
        if (0 == read (fh, (void*)&i->y, sizeof(unsigned short)))
                return -1;
        i->pix = (byte*)malloc (i->y * i->x);
        if (0 == read (fh, (void*)i->pix, i->x * i->y))
        {
                free (i->pix);
                return -1;
        }

        return 0;
}

/* Carga un fichero .wb y retorna un WBImage */
WBImage
loadWBImage(const char* file)
{
        int fh;
        WBImage i;

        i.x = i.y = 0;

        fh = open (file, O_RDONLY);
        _readWBImage (fh, &i);
        close (fh);

        return i;
}

/* Libera la memoria asociada a una estructura WBImage */
void
freeWBImage (WBImage i)
{
        i.x = i.y = 0;
        free (i.pix);
}

/* Abre un vídeo para ir leyendo imágenes */
WBVideo
openVideo (const char* file)
{
        WBVideo v;

        v.fh = open (file, O_RDONLY);
        read (v.fh, (void*)&v.x, sizeof(unsigned short));
        read (v.fh, (void*)&v.y, sizeof(unsigned short));

        return v;
}

/* Lee la siguiente imagen de un vídeo */
WBImage
readNextImage (WBVideo v)
{
        WBImage i;

        i.x = i.y = 0;

        /* Si no hay más imágenes, la imagen retornada tiene tamaño 0 */
        _readWBImage (v.fh, &i);

        return i;
}

/* Cierra un vídeo */
void
closeVideo (WBVideo v)
{
        close (v.fh);
        v.fh = v.x = v.y = 0;
}

void
paintWBImage (WBImage i)
{
        SDL_Surface* sprite;
        Uint32 mask = 0xff;
        SDL_Rect area;

        /* El tamaño de la imagen no puede ser 0 */
        assert (i.x);
        assert (i.y);

        /* Generar el sprite */
        sprite = SDL_CreateRGBSurfaceFrom(i.pix, i.x, i.y, 8, i.x, mask, mask, mask, 0);
        if ( sprite == NULL )
        {
                fprintf(stderr, "Couldn’t make img: %s", SDL_GetError());
                SDL_FreeSurface (sprite);
                exit (1);
        }
        SDL_SetColors(sprite, colors, 0, 256);

        area.x = area.y = 0;
        area.w=i.x;
        area.h=i.y;

        SDL_BlitSurface(sprite, NULL, screen, &area);
        SDL_UpdateRect (screen, 0,0,0,0);
        SDL_FreeSurface (sprite);
}

12/10/2005

Lomografía para GIMP

Filed under: español, crítica/critics, blogging, fotografía/photo — Diego Sevilla @ 20:11 — In English

Magnífico plugin obtenido de la media hostia.

Six-Eyed Monster

Filed under: english, español, fotografía/photo — Diego Sevilla @ 14:09 — In English



Six-Eyed Monster

Originally uploaded by dsevilla.


Gato en ventana

Filed under: español, fotografía/photo — Diego Sevilla @ 14:08 — In English



gatoventana

Originally uploaded by dsevilla.


CORBA Reborn?

Filed under: CORBA & Component Model (CCM), english, crítica/critics, código/code — Diego Sevilla @ 12:43 — In English

I sure was expecting this. People is realizing Web Services are not the “Right way to go” ™. The other day I came trough a post in Patrick Logan’s weblog (Making it stick), CORBA redux about a conversation in ACM Queue between Roger Sessions and Terry Coatta. Contradictions comming from Sessions are noted in Patrick Logan’s weblog. Surprisingly enough, Sessions admited WS-* standards being even more complicated than the CORBA counterparts, arguing that WS-* specs. are just for Microsoft and IBM architects to be understood, not programmers.

I tend to think that people have forgotten what CORBA really is and what does it exactly do. CORBA did 10 years ago what WS specs. are not finishing to define in five years of development. Also, CORBA specs., at least many of them, are an example of well-written and complete documents.

Next Page »

Creative Commons License
This work is licensed under a Creative Commons License.
EWWV  AWStats  Site Meter 24 queries. 0.132 seconds. Powered by WordPress
406021 email messages processed in this box. 10858 were spam

0