sábado, 31 de enero de 2009

Paralelismo con AJAX

La idea de probar con un tema así, me vino a principios de curso, por un miniproyecto libre que nos pidió un profesor relacionado con el paralelismo, había probado PVM, MPI (a nivel de librería) en C y me animé a probar hacerlo con AJAX a ver que pasaba.
Lo malo de AJAX es la plataforma sobre la que se mueve, hay que pensar que los clientes (los usuarios) tendrán como ésta su navegador, por lo que no puedes esperar la velocidad de C.
Lo bueno es, aparte de la multiplataformidad (hasta las neveras tienen navegador de Internet), la cantidad de aplicaciones cliente que pueden entrar. Con los navegadores de Internet pasa un poco como con los zombies: Son lentos. Son débiles. Son tontos. Pero ante todo, son MUCHOS.
Hice dos aplicaciones, una para calcular números primos a base de fuerza bruta, y luego otra que consistía en adaptar un algoritmo de RayTracing en javascript a una versión paralela, para la comunicación utilicé la librería DWR para poder utilizar Java y las páginas en JSP.
He subido ambos miniproyectos a mi cuenta en Box.net (debajo del post lo tenéis) para que podáis probarlos si queréis, tienen la documentación tal cual se la envié al profesor con las pruebas. De todos modos os pongo una pequeña explicación:

Números primos
Por la parte del servidor hay una base de datos en MySQL y sus funciones son las de etiquetar a los que entran (algo así como un ID para saber quien hace qué), bajo petición decirles qué valor deben mirar y recibir resultados... simple. Claramente ante la preguntas ¿ya pero si entran dos a la vez? o ¿cuando hay tanta distancia entre dos primos que no recibe datos y siempre va a pedir empezar desde el mismo valor a todos los que entren? o ¿no sería preferible enviar varios valores a mirar a enviar valor por valor de forma individual? hay una fácil respuesta: esto es para probar hacer paralelismo con AJAX, no para calcular todos los números primos del mundo, obviamente fuerza bruta no es la mejor forma de hacer las cosas, pero sí experimentar con tecnologías que permiten la creación de grids sin necesidad de descargar software de terceros, con los riesgos que ello suele conllevar.
El cliente por otra parte, lo que hace es entrar, recibir el id y pedir números para empezar a calcular como loco, por cada resultado que reciba lo manda junto con su id al servidor, y punto.

RayTracing

El algoritmo de raytracing va pixel por pixel, calculando el recorrido que hace un rayo de luz desde ese punto hasta un cierto número de niveles que se especifica en el código.
Me explico, desde un punto, se lanza un rayo hacia delante, si se topa con un objeto (por ejemplo una esfera) calcula la dirección que tomaría el rayo dependiendo del material de dicho objeto, si por ejemplo es transparente o semitransparente, habría reflexión y refracción, este rayo se prolongaría rebotando entre el número de objetos que desees (niveles) y así pixel por pixel, al final de tanto rebote obtendrías una información de color en tres valores (rojo, verde y azul).
Pues la idea era que los clientes hicieran la fila que el servidor les dijese y devolviesen la información de todos esos colores en un array de X elementos, donde X se corresponde con la anchura de la imagen.
Tal y como se programó, básicamente el maestro ante de hacer una fila pregunta al servidor ¿esta fila está hecha?, si es que sí, recibe la información de los colores, si no los calcula él. Los clientes calculan partiendo desde la parte inferior de la imagen y el master desde la parte superior, hice esto, mas que nada para ver hasta que fila se llega con los clientes, es una forma de medir cuanta mejora hay añadiendo clientes al sistema.
Recuerdo pensar que habría ido mejor si hubiese granulado más las filas de la imagen, por ahora se pide a cada cliente que vaya dibujando una fila de pixels, una fila entera, pero cuando la imagen es muy ancha, tiene que calcular un array de X elementos, que a su vez tiene tres elementos más en coma flotante (los tres colores). Total, que al final tienes X*3 elementos para enviar por Internet, por lo que no salía rentable, ya que el ordenador maestro también va calculando y en casos de tardar mucho en llegar la información, sale mejor que haga todos los cálculos éste. La idea era dividir bajo algún concepto esa fila, de modo que realmente se pediría un rango de pixels al cliente.
Buff, madre mía que mareo de palabras, el caso era símplemente que hay mucho potencial en Internet respecto al tema del paralelismo y más aún con herramientas como puede ser AJAX o Comet, lo único es echarle imaginación.


jueves, 29 de enero de 2009

Síndrome de Diógenes cibernético

Tras el paso por alguna que otra party (o lan-party como también les llaman), siempre me he dado cuenta de detalles que me han llamado la atención. No me refiero a la capacidad del ser humano de dormir sobre su propio ordenador (hecho que me ha demostrado la capacidad de aguantar peso de los teclados), o a la de los amiguetes que juegan a poner cosas sobre el que duerme y el que lo despierta pierde, o a la capacidad de correr muerto de sueño detrás de los amiguetes que te han puesto esas cosas mientras dormías, o que te toque aguantar despierto los tres días, solo por el hecho de no querer darle la oportunidad a un amigo cabroncete, que se dedica a tirarte fotos mientras duermes, para luego mostrar al mundo una de tus facetas mas tiernas (siempre y cuando sean fotos y no se dedique a grabar tus ronquidos).

Lo que me ha sorprendido siempre, y me incluyo en el conjunto de seres humanos que lo realizan, ha sido la capacidad de acumular el montón de información (resumamos el amasijo de fotografías, vídeos, películas, series, imágenes chocantes, porno, música y software en la simple y llana palabra información). Al final resulta enfermizo, entrar en todas esas carpetas compartidas o las listas personales del DC++ (o programas similares) de los amigos, ves basura a raudales. Te pones a ver todo lo que comparten y preguntas al poseedor ¿pero todo esto lo has visto o vas a verlo alguna vez? la respuesta suele ser típicamente que no a ambos tiempos verbales (o no y no sé), el caso es que acabas descargándolo todo por si acaso. A veces no sé, parece que se quiera guardar por si viene una glaciación y nos toca quedarnos atrapados en casa, me imagino la escena:

- ¡¡Oh!! ¡vamos a estar semanas sepultados en la nieve!
- ¡Tranquilos, tengo las cuatro temporadas de House!

Claro, ya nada puede pasar, si viene un oso polar a comernos, pues nada se le invita a ver House y quien sabe... quizá traiga algún hallazgo... o quizá sea el oso que sale en Lost, por lo que habrá que usar palanca y un poco de paciencia para poder meter al oso polar en tu disco duro, pero vamos, nunca se sabe, el mundo es un lugar misterioso.

El caso es que te das cuenta que la gente descarga por el simple hecho de coleccionar, también por el mero hecho de tener disco duro suficiente, quizá también porque vas a una party y te mola decir, así como el que habla de golondrinas, Na... pues pasaba por aquí y me he dicho, "pues mira voy a compartir estos cinco teras de hallazgos con los plebeyos estos" y quedas como Dios.

También, porque la gente que comparte estas aficiones se pica a comentar hallazgos que... como no, necesitas tener en tu frágil soporte de información, para algún día poder disfrutarlo... tengo mi móvil repleto de nombres de películas y series raras para.. ejem, comprarlas. Pero conforme vas recibiendo información sobre nuevos hallazgos, empiezas a cambiar de soporte esos que te metiste anteriormente, que te prometiste ver algún día y aún no lo has hecho, por otros que te prometes ver antes de volver a hacer un trasiego de datos de ese tipo y que por cierto, te adelanto que no verás. Vamos... acumular basura por si algún día me pasa algo y me quedo en casa atrapado.

Mi conclusión tras todos estos años de ver la evolución de buscar servidores ftp en Yahoo, o usar el protocolo Archie, la aparición de Napster, gnutella, limewire, el eDonkey2000, Morpheus, eMule, Bittorrent, Pando... buff.. la solución es que da igual, borra, no pasa nada, siempre podrás volver a bajar o pedirlo a un amigo... (eso sí, siempre que sus derechos no hayan sido comprados en tu país).

miércoles, 28 de enero de 2009

Comet o Reverse AJAX, o como más os guste llamarlo...

Muy buenas :), una vez mas vuelvo a escribir para hablar de algún tema que ha suscitado mi interés (la verdad es que tengo varios para escribir y demasiado poco tiempo :P).
El caso es que una vez un amigo mío me comentó que había salido algo que era como AJAX pero en versión push, antes una aclaración, una conexión pull es que tu tiras de los datos hacia tí de algún modo (en el caso de AJAX tu naveador hace una petición y el servidor en base a eso da una respuesta), y con una push es que el servidor te manda información (la empuja) cuando ocurra algún evento interno suyo o necesite dar algún tipo de información.
Pues he estado buscando y resulta que el inventillo, obviamente, existe y se llama Comet y como no, lleva ya un tiempo existiendo...
Básicamente Comet se basa en la idea de que, a diferencia de AJAX para el que cada vez que quieres recibir datos, debes hacer una petición. Con Comet la cosa cambia, funciona de modo que haces una petición de tipo multipart, que lo que significa es que se va a abrir un canal de comunicación que va a ir recibiendo el dato en varias partes, por lo que no se cierra y para lo cual el servidor tiene la posibilidad de ir enviando datos a cascoporro.
Esta técnica de programación tiene cabida en muchas salidas en el mundo de la comunicación por Internet, desde programas de chat, como el Google Talk para el que ya no tienes que ir mandando peticiones para ver si alguien ha escrito algo, también para servidores de correo en los que pasa parecido a los programas de chat, sistemas de estadísticas en tiempo real, sistemas para ver el estado de los servidores... y un sinfín de utilidades.
He encontrado un esquema de comunicación comparando AJAX y Comet, se nota la disminución de peticiones y, por lo tanto, de ancho de banda así como de sobrecarga del navegador por la eliminación de timers, podéis hacer click en él para verlo en grande.
Si queréis probarlo (yo aún no lo he hecho, escribiré un post con las pruebas que haga), el Toolkit de Dojo lo implementa.

Una frase..

Al principio no había ordenadores en las casas, tuvimos que hacer que la palabra ordenador fuera compatible con las casas.

Steve Wozniak

lunes, 26 de enero de 2009

clases javascript para json

En el trabajo, decidí utilizar JSON para el trasiego de datos, que la verdad, es bastante grande y por lo tanto lo mejor es organizarse, buscar alternativas a ir creando parámetros de forma dinámica para enviar por POST y sobre todo, ligeras (XML acaba metiendo muchos caracteres).
Por si alguno aún no sabe lo que es JSON, nada más que decir que es un formato de intercambio de datos ligero y fácilmente entendible para el ser humano (a menos que el chorizo sea muy grande claro :P). Un ejemplo de dato es:
["nombre":"Manolo","apellido":"Kabezabolo"]

Y un ejemplo de array y luego los mezclo:
["hola",4,"foo","bar","etc]
["nombre":"Manolo","array1":["hola",4,"foo","bar","etc],"objetoJSON":{"obj":"valor"}]

Como habéis visto, se puede encadenar entre objetos también, bueno, símplemente se manda como una cadena por un único parámetro y luego accedes como el objeto JSON que es, podéis utilizar la librería oficial o alguna librería que haga alguien, yo para javascript me he un par de clases simples para la crearme objetos y arrays:

function JSONObject(){
this.key = new Array();
this.value = new Array();
this.addObject = function(key, value){
if(key==null)
key = "";
if(value==null) value = "";

this.key.push(key);
this.value.push(value);
};
// función que pasa a string
this.toString = function(){
var string = "";
for(var i=0; i<this.key.length; i++){
if(i!=0) string+=",";
string+='"'+this.key[i]+'":';
// si es un string, se pone entre comillas
if((typeof this.value[i]) == "string")
string+='"'+this.value[i]+'"';
else
string+=this.value[i];
}
return "{"+string+"}";
};
// función para obtener un objeto de una posición concreta
this.getObject = function(index){
var ret = null;
if(0<=index && index<this.key.length)
ret = "{"+this.key[index]+":"+this.value[index]+"}";
return ret;
};
// Función para devolver una clave de una posición
this.getKey = function(index){
var ret=null;
if(0<=index && index<this.key.length)
ret=this.key[index];
return ret;
};
// Función para cambiar una clave que está en una posición concreta
this.setKey = function(index,key){
if(key==null) key = "";
if(0<=index && index<this.key.length)
this.key[index]=key;
};
// Función que cambia una clave a partir de otra (cambia la primera que ve)
this.setKeyByName = function(old_key,new_key){
if(new_key==null) new_key = "";
for(var i=0; i<this.key.length; i++)
if(this.key[i]==old_key){
this.key[i]=new_key;
// salgo porque solo modifica
// el primero que encuentra
break;
}
};
// obtiene el valor de una posición
this.getValue = function(index){
var ret=null;
if(0<=index && index<this.value.length)
ret=this.value[index];
return ret;
};
// Modifica el valor de una posición
this.setValue = function(index,value){
if(value==null) value = "";
if(0<=index && index<this.value.length)
this.value[index]=value;
};
// Modifica el valor de un objeto con un valor concreto (el primero que se encuentre)
this.setValueByName = function(old_value,new_value){
if(new_value==null) new_value = "";
for(var i=0; i<this.value.length; i++)
if(this.value[i]==old_value){
this.value[i]=new_value;
// salgo porque solo modifica
// el primero que encuentra
break;
}
}
// para ver el tipo de objeto que es
this.getType="JSONObject";
}

function JSONArray(){
this.elements = new Array();
// añade un item al array
this.addItem = function(value){
// si es un string lo entrecomilla
if((typeof value) == "string")
value = '"'+value+'"';
this.elements.push(value);
};
// pasa a string el array
this.toString = function(){
return "["+this.elements.join(",")+"]";
};
// devuelve un item
this.getItem = function(index){
var ret = null;
if(0<=index && index<this.elements.length)
ret = this.elements[index];
return ret;
};
// cambia el valor de un item
this.setItem = function(index,item){
if(item==null) item="";
if(0<=index && index<this.elements.length)
this.elements[index] = item;
};
// obtiene unos valores en un rango pedido: array.getRange(2,4)
this.getRange = function(from,to){
var ret = null;
if(from<=to && 0<=from && to<this.elements.length)
// a slice hay que decirle en el "to" que uno mas, porque es a partir
// de donde corta
ret = this.elements.slice(from,to+1);
return ret;
}
// para ver el tipo de objeto que es
this.getType="JSONArray";
}
// Ahora probamos ambas clases
// creamos el objeto: '{"obj1":"valor1","obj2":"valor2","obj3":"valor3"}';
// creamos el array: '["item1","item2","item3","item4"]';
var object = new JSONObject();
object.addObject("key1","value1");
object.addObject("key2","value2");
object.addObject("key3","value3");
object.addObject("key4","value4");
var array = new JSONArray();
array.addItem(2);
array.addItem("item1");
array.addItem(4);
array.addItem("item2");
document.write(object.toString()+"
");
document.write(array.toString()+"
");
object.addObject("array!",array);
document.write(object.toString()+"
");
object.setKeyByName("key3","3yek");
document.write(object.toString()+"
");

Las salidas que se obtienen son las siguientes:

{"key1":"value1","key2":"value2","key3":"value3","key4":"value4"}
[2,"item1",4,"item2"]
{"key1":"value1","key2":"value2","key3":"value3","key4":"value4","array!":[2,"item1",4,"item2"]}
{"key1":"value1","key2":"value2","3yek":"value3","key4":"value4","array!":[2,"item1",4,"item2"]}


No solo para enviar datos entre cualquier plataforma y lenguajes sirve JSON, usando esto con AJAX, tenemos lo que llaman JSON-RPC, sí las llamadas a procedimientos remotos utilizando como plataforma de intercambio de datos a JSON. De modo que, por ejemplo con el mundo Java, tenemos JSON-RPC-Java que es una tecnología que permite realizar comunicaciones Ajax entre el cliente y el servidor J2EE, hacer llamadas a funciones de clases Java desde JavaScript, con capacidad para serializar objetos Java y convertirlos en objetos JavaScript y todo ello, de forma transparente al programador. He encontrado un ejemplo bastante exhaustivo sobre este tema, con el cual veo una tontería escribir nada aquí, de modo que os pongo el enlace y si tenéis curiosidad pues le pegáis un vistacillo :D:
http://www.ateneatech.com/blog/json-rpc-java-comunicaciones-ajax-transparentes-tutorial-completo-y-ejemplos

viernes, 23 de enero de 2009

Extendiendo javascript con prototype y herencia

Hay una forma de extender los objetos de javascript, me explico, digamos que tienes que hacer algo tan simple como es borrar un elemento de un tipo Array, es decir, hacer un array.remove(1), o quieres obtener la posición de un elemento, por ejemplo array.indexOf("string").
Para ello se puede hacer uso de una propiedad llamada prototype, es un objeto que se utiliza como constructor para poder añadir propiedades a los objetos que se crean en este lenguaje.
Por ejemplo para los dos anteriores casos tendríamos algo como:

// remove: elimina un elemento de un array situado en una posición dada,
// o un rango de ellos dando el de inicio y fin
Array.prototype.remove = function(desde, hasta) {
var rest = this.slice((hasta || desde) + 1 || this.length);
this.length = desde <>desde : desde; return this.push.apply(this, resto);
}

// indexOf: devuelve la posición del primer elemento que coincida con el parámetro
Array.prototype.indexOf = function(elemento) {
var retorno = -1;
for(var i=0;i<this.length;i++)
if(this[i] == elemento)
{
retorno = i;
break;
}

return retorno;
}

De modo que cada vez que quieras eliminar algo, en lugar de escribir algo tan sencillo como
var_array.remove(3);
o cuando te interese si un elemento existe y de paso su posición
var_array.indexOf(elemento);
.

El paradigma Prototype permite herencia entre objetos de tipo Prototype Chaining, el cual no permite herencia múltiple, veamos..
Como bien sabréis, en javascript, para definir una clase no hay mas que crear una función:

function objeto()
{
this.atributo1 = "valor";
this.atributo2 = "valor";
this.metodo1 = function(){ ... };
}
var varible = new objeto();


Fácil, ¿no? bueno, al grano, si hiciéramos un objeto que tuviera que heredar de éste, utilizando prototype, la cosa quedaría así:

function objeto2()
{
this.atributo3 = "valor";
this.metodo1 = function() { ... };
}
objeto2.prototype = new objeto();


Quedando así que si te creas un objeto de tipo objeto2 tendrás los atributos de ésta clase, de la de su padre (objeto) y tendrás sobrecargado el metodo1(), por lo tanto utilizarás el del objeto2.
Tal y como he dicho, esto no permite herencia múltiple, para ello existe otro modo de heréncia, el llamado Object Masquerade.
Este tipo de herencia, hace uso del objeto this, cuando se crea el constructor, se le asigna a ese objeto todas las variables y métodos internos de esa clase (a la que llamaremos Base). Pero en javascript, el constructor no es más que una función, por lo cual, puede usarse como método en otra clase que derive de Base (a la que llamaremos Derivada), de modo que las variables y métodos que se creaban en Base, se crean en Derivada. Voy a poner un ejemplo para aclarar:

// Tenemos la clase Base
function Base(valor)
{
this.valor = valor;
this.mostrarValor = function()
{
alert(this.valor);
}
}

// Y ahora la Derivada
function Derivada(valor)
{
this.base = new Base;
this.base(valor); // al hacer esto, el this al que se refiere Base es el this que tiene Derivada
delete this.base;
}


De modo que puedes hacer eso con todas las clases que quieras, luego permite heréncia múltiple.

WP-Cumulus: plugin para mostrar la nuve de tags en Wordpress

Navegando por una página he podido observar un plugin que me ha encantado (a pesar de estar hecho en flash). Se llama WP-Cumulus es para mostrar la típica nuve de tags, pero de forma esférica que rueda conforme mueves el ratón, un ejemplo que muestra la página es el siguiente:





¿habrá algo para blogger?

miércoles, 21 de enero de 2009

Cross browser SVG: gráficos vectoriales en tu navegador

Esta semana he estado experimentando con SVG, es un lenguaje para la creación de gráficos 2D vectoriales y aplicaciones gráficas XML creado por la w3c. Es bastante fácil de utilizar y permite manejo de eventos y animaciones, incluso animaciones rollo imagen que recorre una ruta y elementos tipo spline y cosas así.
Obviamente, en Explorer no va, para el cual existe otra especificación llamada VML, para ello hay dos visores que se pueden instalar, uno de Adobe, y otro llamado Renesis... bueno, no es nativo como en otros navegadores, pero si funciona... aunque para obligar a un cliente a instalarse un plugin, antes le digo que se instale un navegador que vaya bien. Pero vamos, eso son formas de pensar.
Existen varias librerías y frameworks que permiten la creación de este tipo de gráfico, yo he probado tres y al final me he quedado con la tercera, aquí os las pongo con alguna anotación sobre mi punto de vista:
  • jQuery: he visto dos soluciones:
    • La de una página llamada openstudio: con este no tuve problemas de compatibilidad, utiliza el anterior y si es Explorer utiliza el método de uno llamado Walter Zorn. Pero tuve que rechazarla por no permitirme trabajar con eventos, no sé por qué pero cuando hacía, por ejemplo:
      variable.onclick = function(){alert("como molo!!");};
      Nada mas arrancar el navegador me ejecutaba el alert y ya no me iba :|.
  • Raphaël: ¡no! no es el cantante ese de "yo soy aqueeel.." por el que nuestras madres se derretían cuando sonreía, es una librería que la verdad me ha gustado bastante. Es compatible con los navegadores que he podido probar, Explorer 6, Firefox y Opera. La combiné con prototype y scriptaculous (esta última por necesitar el efecto de dragndrop) y la verdad es que muy bien, es simple, pero era lo que necesitaba para lo que tenía que hacer. En su web hay ejemplos que parecen hechos por flash o algo similar, pero no, está hecho todo a base de javascript.
Mientras buscaba una librería que me gustara, dí con algunas específicas, como PlotKit especializada en la creación de gráficos, en su página encontramos una demo que muestra distintos tipos de gráficos que se pueden hacer.


La w3c tiene un programita llamado Amaya que es gratuito, para la realización de los gráficos de forma visual. Uuumm... tendré que probarla..

En futuros posts os pondré pruebas que voy haciendo.

viernes, 16 de enero de 2009

Google Maps

Desde que lo conocí, Maps (de Google) siempre me ha guiado cada vez que voy a algún sitio, para trazar la ruta, antes usaba otras soluciones como la guia michelín o no recuerdo cual mas... el caso es que siempre me ha parecido genial, te traza rutas tanto a coche, transporte público y andando.

Una prima mia que es muy fan de Stephen King me comentó que se marcaba en un mapa los lugares donde ocurrían las historias que escribía este escritor, la mayoría de los lugares para ver los recorridos que realizaban los personajes y poder buscar coincidencias entre las historias según el lugar, vamos algo que yo haría si no fuera porque yo suelo leer ciencia ficción y no tengo el mapa de Marte ni Coruscant ni Trantor..

El caso es que se me ocurrió que para esto sería genial Google Maps, veamos, tenemos un mapa, quizá desactualizado obtenido de la página oficial de este escritor y Google maps al lado:



Ver mapa más grande

La cosa sería ir poniendo rutas y puntos clave de las historias.

¿Alguien lo ha hecho alguna vez con alguna saga de libros o algo parecido?

Streetview


Hace un tiempo conocí streetview, es una aplicación de Google que agrega a los maps. Por lo visto la gente esta va con un coche que tiene unas camaras para tomar imágenes a 360 grados por todo el mundo.

De ese modo nosotros, humildes usuarios, podemos decir "vaya, pues quiero ir a ver el recorrido que haré en el coche por Valencia para poder" saber, más o menos, como son las calles y todo eso.

Pues nada, no hay mas que ir a Maps y buscar la ciudad, vemos sobre la regla que tenemos a la izquierda, para acercar o alejar el mapa, un muñequito amarillo, no tenemos mas que arrastrarlo a donde queremos y.. tachaaan!.


Ver mapa más grande

Pero ojo, no se puede con todas las ciudades (la gasolina es cara!), sólamente por donde hayan decidido hacerlo y claro.. la mayoría está en Estados Unidos..  No obstante no deja de ser un recurso curioso.. ¿tendrá el API liberado?

¿ha probado con reiniciar?

Bueno, creo que antes de seguir escribiendo, debería explicar las razones y de dónde saqué la idea de ponerle este estúpido nombre al blog:
Razones:
  1. No estaba disponible el nombre generalfailure (por lo del chiste ese de "¿quién será ese tal general failure que está husmeando en mi disco duro?"), ni controlaltsupr ni alguna otra variante parecida.
  2. Poner un acrónimo tal como el que iba a poner: ispronute (queriendo englobar los temas a tratar en el blog: ingeniería del software, programación y nuevas tecnologías) era un poco feo y no daba pié a poder explayarme con artículos como el anterior.
Tras esto, recordé los primeros tres minutos de una de mis series favoritas I.T. Crowd, tras la cual añadí a mi lista de cosas factibles a hacer en mi vida el que tenía que, en una situación real decir a alguien did you try to turning off and of again?, y conseguí hacer hace cosa de un año, pero bueno, esto de la lista de cosas factibles a hacer en mi vida os lo explicaré con más detenimiento otro día o en el otro blog. El caso es que esa frase era un poco larga para ponerla como nombre, de modo que preferí ponerla en castellano... y voliá!
Para los que no conozcan esta serie, aparte de merecer morir (es coña), os pongo el trozo inicial del primer episodio, para verlo subtitulado en castellano pincha aquí:

El teorema de los infinitos monos



Ayer, un compañero de trabajo me dió a conocer la existencia del Teorema de los infinitos monos, consistente en, básicamente la idea de que si juntas infinitos monos tecleando (bueno, aporreando) una máquina de escribir (supuse que una por mono), casi seguramente podrá escribir finalmente cualquier libro que se halle en la Biblioteca Nacional Francesa.
Por lo que he leído en la wikipedia, el caso es que se realizó un experimento, sin monos, por si los ecologistas decían algo, esta gente prefiere matar las especies trayendo a sus familiares provenientes de otros continentes (tal como está pasando con el cangrejo de río autóctono). Bueno, que me hierve la sangre, el caso es que se ve que se puso en marcha el uno de julio de 2003 un applet en un sitio web llamado
the monkey shakespeare simulator, el cual simula una laaarga problación de monos escribiendo al azar, para ver sobre cuanto tardarían en escribir una obra de Shakespeare de principio a fin. En 2005, concretamente el tres de enero, se miró a ver cómo iba la cosa y se encontraron con la sorpresa de hallar veinticuatro letras consecutivas que formaban un pequeño fragmento de Enrique VI, parte 2:
“RUMOUR. Open your ears; 9r"5j5&?OWTY Z0d "B-nEoF.vjSqj[..."

Posteriormente, el mismo experimento, logró 30 letras de Julio César de Shakespeare:

Flauius. Hence: home you idle CrmS3RSs
jbnKR IIYUS2([;3ei'Qqrm'

Debido a limitaciones en la capacidad de procesamiento, el programa usa un modelo probabilístico (mediante el uso de un generador de números aleatorios) en lugar de generar texto aleatorio y compararlo con Shakespeare. Cuando el simulador detecta una similitud (esto es, cuando el generador de números aleatorios genera un determinado valor dentro de un determinado rango), el simulador emula la coincidencias generando el texto de la misma.

En 2003, científicos en Paignton Zoo y la Universidad de Plymouth, en Devon, Inglaterra, reportaron que dejaron un teclado de computadora en la jaula de seis macacos durante un mes. No sólo los monos no hicieron más que producir cinco páginas consistentes en una larga serie de la letra S, sino que comenzaron a atacar el teclado con una piedra y siguieron orinando y defecando sobre él.

Seguro que no pensaron en simular esto anterior cuando realizaron el applet. Pero creo que es lo más seguro que podría pasar, han pasado millones de años y creo que el
planeta de los simios está aún un poco lejos, aunque, vistas algunas teorías como la que se ha presentado en este post, no creo que sea imposible.. símplemente lejos :)

Símplemente decir... hola!

Bueno, tenía ganas de comenzar un blog sobre temas de nuevas tecnologías y programación, en un principio iba a enfocarlo a símplemente web, que es lo que más estoy tocando en estos últimos años, pero me agobia encasillarme, así que mejor tomar un tema más general para ir poniendo cosas que, o bien investigo, o bien me encuentro por ahí y me llaman la atención o símplemente las pongo como anotaciones por si pueden hacer falta para un futuro.
El por qué decidirme en este preciso momento.. he aprovechado un curso sobre creación de blogs, la verdad es que me imaginaba que era más enfocado a programación, pero bueno, la verdad es que si también se tenía que enfocar para gente que no fuera informática, lo normal es usar una herramienta que ya funciona bien y con la que te ahorres horas de dedicación y esfuerzo (aparte de enfrentarte a los problemas por despistes o usuarios malintencionados). Como bien enseñan en la carrera... ¡¡hay que reutilizar!!
El por qué añadir nuevas tecnologías es símplemente porque soy un gran amante de todo lo que sea tecnología, robótica, gadgets... ¡no solo de programación vive el informático!
También he llegado a pensar el incluir temas de ingeniería de software, son también temas que me interesan y que cambian y evolucionan muy rápidamente.
Bueno, tras esta pequeña introducción, ya podéis haceros una idea de más o menos los temas que se tratarán, ahora.. ¡¡agrégame a tus favoritos/netvibes/igoogle/loqueseaa!!