FX en 'El barco'

Dejando a un lado las comedias de situación y las reminiscencias del pasado político (que tanto agradan, ambas, por estos lares), títulos como ‘Periodistas’, ‘Hospital central’, ‘El comisario’, ‘Cuenta atrás’, ‘RIS científica’, ‘Hay alguien ahí’, ‘Águila Roja’ o ‘Piratas’ han hecho evidente que en España se puede hacer buena televisión de entretenimiento, obviando los comentarios que ponen a parir a una o a otra por su mediocridad artística, su falta de trama profunda o su prácticamente nula calidad argumental (en la mayoría de los casos no les falta razón alguna). Mención especial aparte a ‘El internado‘, probablemente la única serie capaz de competir de forma rigurosa y seria con cualquier otra del mundo. Sin duda, la gran obra maestra de la ficción española que, ahora, triunfa en Rusia.

Precisamente, de la productora de ‘El internado’, Globomedia, llegó a principios de este año 2011 un nuevo título que prometía hacer las delicias de los amantes de la ciencia ficción en la pequeña pantalla. La serie (Antena 3), titulada ‘El barco‘, traía consigo emoción, intriga y suspense, algo que se hizo evidente en un más que bueno episodio piloto. Sin embargo, y tras trece capítulos de su primera temporada, ‘El barco’ ha pinchado como serie de ficción y se ha convertido en un melodrama romanticón plagado de amoríos, relaciones y folleteos varios en alta mar (más alta que nunca, por cierto). La trama es técnicamente un despropósito, pero, bien llevada, podría haber conseguido laureles y vítores de la crítica y del público. Empero, los responsables han preferido agradar a los televidentes quinceañeros a golpe de fotogramas de Mario Casas sin camiseta y de Blanca Suárez en paños menores, descuidando la idea original hasta puntos insospechados.

Pero lo que más nos ha llamado la atención en este blog no es la calidad interpretativa del elenco, ni siguiera las incoherencias de un guión cogido con alfileres. Lo que a nosotros nos interesa es la parte tecnológica del asunto, en este caso el área de los efectos especiales digitales de la grabación. Y es que parece mentira que una serie de una de las productoras más potentes de país, en el año 2011 de Nuestro Señor Jesucristo, lleve pegoteados en la cinta unos efectos que cualquiera en su casa, un poco (pero poco) avezado en el manejo de 3D Studio o After Effects, podría haber creado en cinco minutos. Resulta un insulto gravísimo al espectador, al que tratan de tonto e ignorante.

Cromas evidentes, perspectivas imposibles, efectos repetidos, pájaros de conducta errática y humaredas voluptuosas son algunos ejemplos de las decenas de efectos dignos de un parvulario del modelado en 3D. A buen seguro, el único efecto realista que han sido capaces de recrear es el de la neblina de la cortinilla de la serie que, por cierto, reutilizan en el capítulo ‘Niebla’, pero a lo bestia. Como honrosa excepción, sólo se salva el episodio ‘El hombre de Liverpool’, con sus transiciones entre presente y pasado, aunque eso poco tiene que ver con efectos en tres dimensiones, pero era de recibo comentarlo.

El barco creado por ordenador para los planos generales y panorámicos largos es simplemente patético. La suerte les acompaña porque se ve pequeñito (desde muy lejos), ocultando y tapando la mayoría de los defectos. Sin embargo, lo que no han podido esconder es el movimiento de la nave, ya sea a la hora de esquivar un remolino, tipo sumidero, en alta mar o en el momento de mostrar al barco encallado en vete tú a saber dónde en el medio del océano. La fluidez de los movimientos del modelo 3D recuerda muy poco a las películas de Pixar y muy mucho a ‘Los Fruittis‘.

A muchos de los planos que utilizan la técnica del chroma key sólo les falta que se les caiga una sábana verde por detrás. Tienen el tufillo de aquellas películas antiguas en las que un grupo de personas parece viajar en el interior de un coche mientras el fondo se mueve descaradamente a sus espaldas. Algo que, a la altura de siglo que andamos, es inconcebible. Ni que decir tiene que un escenario no puede ser nunca tan estático que parezca una fotografía evidente de una puesta de sol tropical. Pues ‘El barco’ tiene de esos también.

De todos los despropósitos digitales que se pueden encontrar, los que más llaman la atención son dos; sin duda, los más notorios por nocivos para la retina. El primero de ellos se da en el capítulo ‘El graznido’, en el que miles de aves de dudosa procedencia toman el buque en busca de comida. Los planos generales muestran un barco repleto de puntos negros, que representan a los pájaros posados en él, y una jauría en rededor de cuervos y gaviotas (y ¿palomas?) acechando a los tripulantes. En una de las imágenes se puede comprobar la profesionalidad de los diseñadores al programar el movimiento calculado de la bandada. Dos gaviotas (se pueden ver en el centro superior de la imagen siguiente) sufren un comportamiento errático al volar una hacia la otra, chocar y continuar agitando las alas en el sitio, sin desplazarse. Un bug al más puro estilo ‘Pro Evolution Soccer’, cuando un jugador comienza a caminar por el aire o atraviesa el terreno de juego con las piernas saliendo de sus hombros.

Gaviotas de vuelo chungo

El vídeo que corresponde a este fotograma se puede visionar en la propia web de Antena 3. Se corresponde con la quinta parte del capítulo 5, y el gazapo empieza alrededor del minuto 4:02 (produciéndose en el 4:05, aproximadamente). Es el más evidente, pero apuesto a que, examinando a fondo el averío, se pueden encontrar bastantes más.

El segundo momento estelar se refiere al episodio ‘La ley del mar’, donde el navío se queda sin combustible justo encima de un volcán submarino (que ya es puntería y casualidad, mirusté). Hace mucho calor y el agua del mar hierve (literalmente) provocando quemaduras de primer grado en un bañista inconsciente, pero en los peces no. De pronto, y como si por arte de magia se tratara, el volcán entra en erupción, arrojando al exterior inmensas nubes de ceniza y humo, pero ni una gota de agua. ¿O sí es agua? Quién sabe. El fuerte estallido ha sido modelado de una forma tan soez, burda, tosca, basta y ordinaria, que no me explico como no han dejado directamente la malla de polígonos al descubierto; habría quedado más simpático y menos grotesco, irrisorio y ridículo. En el vídeo siguiente se puede comprobar también la pericia del animador 3D para conjugar esos hongos negros rechonchos con el resto de la escena.

Desconozco (y no quiero conocer) qué empresa ha sido la encargada de generar los efectos digitales de esta serie, aunque me juego el cuello a que anda por ahí entremetida en los títulos de crédito. No sé si es una compañía de saldos o es que el presupuesto ha sido tan bajo que han puesto a trabajar a los becarios en prácticas. Desde luego, es amoral e inadmisible que, en esta época, una empresa de animación haga este trabajo para un cliente tan importante y pase todos los filtros y cortapisas hasta llegar a la audiencia. Si es así como queremos competir con las series americanas, casi mejor que nos dediquemos a aídas y cuentamés, que la cosa pinta más fácil para los expertos en FX de este país, antes conocido como España. Para ponerse a mear y no echar ni gota, oiga.

Receipt Racer

La agudeza y el ingenio que requiere doblegar a la máquina, mezclando tecnologías, en principio, incompatibles, dominando la ciencia y el lenguaje de los distintos mecanismos y perdiendo horas de sueño, es simplemente digno de elogio y alabanza. Es por ello que me apasiona el trabajo de aquellos que instalan una distro de GNU/Linux en una Xbox 360, la hazaña de hacer sonar la “Marcha Imperial” de Star Wars con un disco duro, el potencial inerte de la máquina perfecta o el currelo de programar lo que estos chavales, que detallo en esta breve recensión, han sido capaces de desarrollar. Improductivo, sí, pero formidable.

Controlando el juego

Material necesario: una impresora de tiques térmica, un rollo de papel para la anterior, un ordenador portátil con sistema operativo Mac, un proyector de luz, el mando de una PlayStation 23 y mucha, pero que mucha, imaginación y sapiencia. En el perfecto marco del festival OFFF (bajo el evento denominado “Vamos a alimentar el taller del futuro”), en Barcelona, el norteamericano Joshua Noble, junto con Martin Fuchs y Philip Whitfield (ambos chicos de Undef), crearon un alucinante juego de carreras en el que el mando de la Play 2 3 es el control principal, el circuito o carretera digital se imprime en tiempo real en la impresora térmica y un proyector de luz marca sobre el papel el coche que dirigimos, la puntuación y otros datos. Lo ideal es contemplar el vídeo siguiente para entender la idea. Esto fue el pasado 8 de junio de este año 2011, y el juego se llama “Receipt Racer”.

El tamaño máximo del circuito es de 50 metros, ya que esta es la longitud total estándar de los rollos de papel térmico. En un principio pensaron en utilizar la impresora como medio estático único para la representación visual, pero el proyecto se antojaba imposible. Posteriormente, a Joshua se le ocurrió añadir el pequeño proyector de luz que, convenientemente controlado por el mando de videoconsola, era capaz de sobreimpresionar el coche y el resto de datos cambiantes.

La aplicación que controla todo este tinglado (desarrollada enteramente durante el taller) fue generada a partes iguales por los tres tipos sobre la plataforma openFrameworks. Una rutina genera aleatoriamente los circuitos y los coches de relleno y los imprime en tiempo real en la impresora. Asimismo, varias funciones detectan la posición del haz de luz que representa el coche del jugador y cruzan los datos con el circuito dibujado. De esta manera, aunque esto resultó lo más complicado, es posible programar mínimamente una detección de colisiones básica que nos indicará cuando el vehículo que manejamos ha chocado contra otro coche o contra los bordes de la carretera.

Evidentemente, esta tecnología, y desarrollada en tan poco tiempo, muy precisa no resulta. En el vídeo anterior se puede comprobar perfectamente como, antes del choque final, el coche se estrella con al menos dos vehículos impresos; y no sucede nada. El sistema tuvo que ser calibrado en varias ocasiones hasta conseguir la máxima precisión, empero, los caprichos de una máquina mecánica, como es una impresora, son múltiples y variados para conseguir un requerimiento de milímetros.

Al final del taller, los muchachos añadieron algunos detalles finales como la puntuación, el número de nivel y el resto de textos lumínicos de incio y fin. La impresora muestra también un fin de juego al estrellarse el coche, detallando el tiempo transcurrido, el nivel alcanzado y los puntos obtenidos.

En fin, una obra maestra de ingeniería que demuestra que en el mundo hay mucho geek dispuesto a perder algo de su tiempo libre para regalar nuestros sentidos con perlas tecnológicas como esta. Babeando ando todavía.

Por cierto, se puede jugar a una versión virtual del engendro desde la web de Undef y, también, descargar el código fuente compilado para Mac.

Windows virii

Desgraciadamente (o afortunadamente) las herramientas para elaborar cualquier pieza de software están hoy día al alcance de cualquiera. Los antiguos y complejos desarrollos en ensamblador han dado paso a lenguajes modernos de alto nivel, fáciles de aprender y rápidos de implementar.    

Los archivos de proceso por lotes de MS-DOS (ficheros de extensión .BAT) fueron aquellos grandes olvidados en la programación de virus. No obstante, los expertos en su diseño vieron en ellos una alternativa veloz y potente para desarrollar malware, y algún bicho codificado de aquella forma llegó a ver la luz, eso sí, sin gran incidencia.    

Posteriormete, y gracias al procesamiento por lotes integrado en Windows a través de su herramienta de administración Windows Scripting Host (rebautizada en su segunda versión como Windows Script Host), los desarrollos víricos se multiplicaron exponencialmente, pues la potencia de desarrollo, unida a la suave curva de aprendizaje, permitía generar virus mortíferos en horas o, incluso (dependiendo de la pericia del programador) en minutos.    

Windows Script Host (WSH) es una utilidad administrativa que se provee con todas las versiones del sistema operativo del tío Bill desde Windows 98. En principio, su utilidad se basa en la generación de archivos de lotes, sin embargo, la potencia de estos ficheros con respecto a los antiguos ficheros batch es muy superior. La fortaleza reside en dos conceptos primordiales: los lenguajes de programación que implementa y los objetos del sistema que es capaz de manejar.    

WSH permite utilizar en la actualidad un amplio abanico de motores de script en su desarrollo, a saber: VBScript, JScript, PerlScript, ooRexx Script, Python Script, Tcl Script, Active PHP Script, Ruby Script, Object Rexx engine y Delphi scripting engine. Cualquier programador con conocimientos básicos de prácticamente cualquier lenguaje puede desarrollar un script para WSH. Asimismo, estos archivos de guión son capaces de acceder a características varias de un sistema operativo tales como, por ejemplo, variables de entorno, recursos de red compartidos, impresoras, el registro, el árbol de directorios, software instalado, Internet, archivos, etcétera. Una herramienta potente y un arma de doble filo.    

Lo que se propone aquí es una introducción al entorno WSH a través de aplicaciones en VBScript, el lenguaje de guión más sencillo e intuitivo, hermano pequeño torpe de Visual Basic. Como todo tutorial de programación que se precie, es preceptivo comenzar con una aplicación "Hola mundo", si no esto ni es tutorial ni es nada. Los archivos de script se escriben como texto plano sin formato en cualquier editor al uso (como Bloc de notas, por ejemplo). El código, con métodos del propio WSH y en formato VBScript, es el que sigue:    

¿Sencillo, verdad? Este archivo lo debemos guardar con la extensión .VBS y, para ejecutarlo, sólo es necesario un doble clic en el icono correspondiente (o una llamada desde la línea de comandos de la consola).    

Si hubiésemos deseado generar un fichero JScript, los métodos no habrían variado, pues son propios del WSH, sin embargo la sintaxis habría sido sutilmente distinta:    

Prosiguiendo con nuestra fatídica infección vírica, vamos a avanzar un paso más. Necesitamos conocer el idioma del sistema operativo, por lo que vamos a internarnos en el registro de Windows para extraer el dato de una manera elegante:    

El procedimiento Sub Idioma () permite leer la clave de registro que necesitamos mediante el método RegRead de WScript.Shell y almacenarla en la variable local LeerRegistro. En función del valor que guarde iCountry, se asignará un 1, un -1 o un 0 a la variable global IdiomaActual, que después necesitaremos para cribar nuestra infección. En el caso de que IdiomaActual valga 1, el payload (efecto visible del virus) será en castellano (se corresponde con los códigos locales de todos los países sudamericanos más España); en el caso de que IdiomaActual valga 1, el payload será en inglés (Estados Unidos más Gran Bretaña); en el caso de IdiomaActual valga 0 (no se ha podido determinar el idioma), el payload será también en inglés, por si las moscas.    

Una vez obtengamos el idioma en el que está configurado el equipo que deseamos infectar, vamos a generar una copia del virus en el directorio del sistema para, desde ahí, enviarlo a los contactos de correo electrónico de la máquina víctima:    

Ya dentro del procedimiento Sub, asignamos a DirectorioSistema el resultado de GetSpecialFolder (1), esto es, la localización de los archivos de sistema (directorio por defecto Windows\System). Ese 1 indica carpeta de sistema; 0 sería el directorio general Windows y 2 el directorio temporal Temp.    

La propiedad ScriptFullName (sólo lectura) de WScript devuelve el nombre completo (ruta y nombre de archivo) del script actual mediante el método GetFile de FileSystemObject. Este nombre se guarda en la variable ArchivoAdjunto.    

Recurriendo a la variable global anterior IdiomaActual, copiamos (Copy) nuestro virus (ArchivoAdjunto) a la carpeta de sistema con un nombre en castellano (máquinas hispanoparlantes) o en inglés (máquinas anglosajonas).    

El proceso de ocultación de este tipo de virus es bien sencillo, así como tremendamente ineficaz en según que configuraciones. Bien es sabida la capacidad de los entornos Windows para ocultar las extensiones de tipos de archivos conocidos (activada por defecto). Así pues, el truco consiste en nombrar el fichero con una cadena terminada en, por ejemplo, .txt, seguida de la extensión de rigor para el archivo de script (.vbs). De esta manera, y sólo si la característica de ocultación de extensiones está activada, el receptor del malware visualizará únicamente el nombre del archivo (en este caso ayudame.txt o helpme.txt), creyendo que lo que le remiten es un simple archivo de texto (¿nadie mira los iconos?). La sorpresa será mayúscula al momento de ejecutarlo.    

El siguiente paso es obtener los datos de la cuenta de correo electrónico de la víctima:    

Lo ideal ahora sería actuar sobre las reglas de mensaje del software cliente de correo electrónico, eliminándolas para que permitan el envío sin cortapisas. No nos detendremos en ello por no alargar más el asunto, pero el código no sería para nada complicado, teniendo en cuenta que se encuentran definidas y almacenadas también en el registro de Windows (las de Outlook Express 5, por ejemplo, en HKEY_CURRENT_USER\Identities\XXXX\Software\Microsoft\Outlook Express\5.0\Rules\Mail).    

Una vez recabados todos los datos, vamos a enviar nuestro virus por correo electrónico:    

Y, para finalizar, nos queda por programar el payload del virus, esto es, la acción visible (o no visible) que se ejecutará en la máquina infectada. El payload de un virus corre a cargo de la imaginación de cada uno. En función del hijoputismo con el que deseemos actuar, la acción final de un virus puede ir desde la simple molestia de mostrar un mensaje en pantalla, hasta la eliminación de archivos vitales para el usuario o para el sistema operativo (librerías .DLL, ficheros multimedia .MP3 o .AVI, documentos .DOC, .XLS o .MDB, fotografías .JPG, etcétera).    

Nosotros, por aquello de no dar ideas, nos vamos a quedar a medio camino. Nuestro payload simplemente mostrará un mensaje en pantalla y renombrará todos aquellos ficheros en formato MP3 que encuentre exclusivamente en el directorio raíz del disco duro principal. Así de sencillito:    

La programación de virus al alcance de cualquiera es una realidad desde hace ya muchos años. Pero otra cosa también, la policía no es tonta y conocerá al cien por cien quién ha programado un virus, cuándo lo liberó en Internet y dónde apareció por primera vez. ¿Cómo lo hacen? De eso nos ocuparemos otro día. Hack the planet!, pero poquito y con cuidadín, que hacer el mal por hacer el mal es de bobos patológicos.

Redondeando ando

Redondear un valor significa reducir su precisión, ajustar a determinado número de decimales una serie de guarismos, perdiendo exactitud en el resultado final. Generalmente, esa precisión menguada no es significativa o la consideramos despreciable, y es que no podemos pretender que nuestros limitados cerebros humanos trabajen con infinitos decimales de concreción.

Un ejemplo muy sencillo podría ser, como comentábamos al principio, el efecto de redondear una cantidad que es media aritmética del precio en euros de varios artículos a la venta. Aunque los precios sólo cuenten con dos decimales (precisión de céntimo), es más que probable que su media dé como resultado un valor de muchos más decimales (o infinitos decimales, incluso). Un resultado de 5,18686 € no es manejable para nosotros, por lo que optamos por redondearlo a 5,19 € (ya que el tercer decimal es mayor que cinco). El valor es menos preciso, por lo que no es válido realmente, pero lo adoptamos como tal.

Pero este no es el único método de redondeo que existe, hay muchos más. Según el caso, debemos considerar utilizar un algoritmo que minimice los efectos de la pérdida de precisión, especialmente en el caso de múltiples iteraciones de procesamiento. Esto es, los errores aumentan significativamente con el tiempo debido a la realización de operaciones de redondeo sobre datos previamente ya redondeados.

NOTA: Se utiliza el punto (.) como separador decimal en todos los ejemplos, cosa que no me hace ninguna gracia, pero es más legible para ti.

Truncamiento

Es el redondeo menos preciso. Consiste en truncar o cercenar el valor eliminando por completo la parte decimal, quedándonos exclusivamente con la parte entera. Así pues, 3.15 daría como resultado 3, y 3.87 daría como resultado también 3. Es el procedimiento que utiliza la función Fix de Visual Basic o el método Math.Truncate de los lenguajes de programación del entorno .NET Framework.

Es un ejemplo de redondeo simétrico, porque afecta al valor absoluto de números positivos y negativos de la misma manera. Así, el truncamiento de -3.87 es -3.

Redondeo al más cercano

Es el algoritmo más intuitivo y el que más utilizamos en la vida real. En este caso valores como 3.1, 3.3 ó 3.4 se redondean a la baja a 3, mientras que valores tales como 3.6, 3.8 ó 3.9 se redondean al alza a 4. El problema está en qué hacer con valores del tipo 3.5. De hecho, este redondeo al más cercano puede considerarse como un superconjunto de dos opciones complementarias denominadas redondeo hacia arriba y redondeo hacia abajo, que vemos a continuación.

Redondeo hacia arriba (aritmético)

Conocido también como redondeo aritmético, es un subconjunto del anterior que asociamos al tipo de redondeo que nos enseñaron a utilizar en el colegio. En este caso, un valor de 3.5 se redondea a 4 (hacia arriba). Con este nivel de precisión, y para este ejemplo concreto, podemos considerar que hay 10 valores que comiencen con un 3 en el lugar más significativo (3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8 y 3.9). Sobre esta base, tiene sentido que cinco de los valores se redondeen a la baja y otros cinco al alza, repartiendo la exactitud equitativamente. De este modo, los cinco valores que van desde 3.0 hasta 3.4 se convierten en 3, y los restantes cinco valores (de 3.5 a 3.9) se redondean a 4.

Este algoritmo puede implementarse con redondeo de forma simétrica (donde -0.5 sería -1) o de forma asimétrica (donde -0.5 se redondearía a 0). Y es que algunos matemáticos y desarrolladores de sistemas consideran que redondear “hacia arriba”, por ejemplo, -3.5 sería alcanzar un valor de -4 (de forma simétrica a su análogo positivo). Empero, otros ingenieros especialistas dicen considerar “arriba” el infinito positivo, por lo que apuestan por un redondeo de -3.5 a -3.

Es el caso de la función REDONDEAR (ROUND) de la hoja de cálculo Excel, de la función Round de SQL Server, de la función roundn de MATLAB (redondeos simétricos los tres) y del método Math.Round de Java (redondeo asimétrico, en este caso).

Redondeo hacia abajo

Subconjunto también de redondeo al más cercano y contrario al anterior, este algoritmo convertiría un valor de 3.5 en 3. Así trabajan las funciones de Excel REDONDEAR.MENOS (ROUNDDOWN) y MULTIPLO.INFERIOR (FLOOR), y también la función Fix de VBA (Visual Basic para Aplicaciones).

El problema con los negativos es el mismo que el comentado en el punto anterior y se puede solventar de ambas maneras expuestas.

Redondeo de equilibrio (alterno)

Si necesitamos redondear multitud de cantidades que se van acumulando y siempre utilizamos el mismo redondeo en la misma dirección, es posible que, con el tiempo de proceso, esta tendencia nos lleve a errores importantes de cálculo a medida que las operaciones se llevan a cabo.

Una manera de subsanar esto es utilizar un redondeo alternado que proporcione equilibrio al conjunto, redondeando a veces hacia arriba y otras veces hacia abajo. Así pues, si en una operación hemos transformado 3.5 en un valor de 4, en la siguiente que aparezca 4.5, por ejemplo, redondearemos a la baja a 4, ajustando de esta forma los posibles errores.

Pocos productos implementan este tipo de redondeo y, por norma general, hay que programarlo a mano.

Redondeo del banquero

El redondeo del banquero, o redondeo bancario, se llama así porque es el utilizado preferentemente en el mundo de las finanzas. Y sí, estás pensando bien, sólo les beneficia a ellos.

Es una variante del redondeo de equilibrio y propone, por convenio, ajustar siempre los valores medios (x.5) al número par más cercano. De este modo, 1.5 y 2.5 serán siempre 2, y 3.5 y 4.5 serán ambos redondeados a 4. Por supuesto que estos son valores de ejemplo, en el mundo real hablamos de hacer los redondeos a dos decimales.

Bancos y cajas de ahorro ingresan más de 270 millones de euros anuales a causa de este redondeo. Las matemáticas al servicio del poder económico.

Funciones de Visual Basic y VBA como CInt, CLng o Round hacen uso del redondeo bancario para hacer sus cálculos.

Redondeo aleatorio

Incluso el redondeo bancario puede generar desviaciones de cálculo cuando la cuantía de operaciones es muy elevada. Para evitar eso se recurre al redondeo aleatorio, otra variante del redondeo de equilibrio que asigna la dirección de redondeo (al alza o a la baja) de una manera completamente aleatoria.

Tampoco se implementa de forma nativa por casi ningún lenguaje de programación o aplicación matemática.

Redondeo impar

Este algoritmo redondea un número hasta el entero impar más próximo. Así, 3.5 será redondeado a 3 y 4.5 lo será a 5. Para los números negativos funciona de igual manera.

Es un método que se utiliza escasamente porque es incapaz de redondear a cero (0), atributo imprescindible para los algoritmos de redondeo. Lo emplea la función REDONDEA.IMPAR (ODD) de Excel.

Redondeos para todos los gustos y manías. En función de la aplicación que estemos desarrollando será necesario manejar un tipo de algoritmo u otro. Evidentemente, no es lo mismo un desarrollo simple de facturación o TPV, donde el más sencillo de los redondeos puede servirnos, que uno de financias o, si me apuras, de CAD, en donde la máxima precisión se antoja imprescindible. El programador habrá de decidir, en cualquier caso, qué algoritmo de redondeo utilizar para conseguir sus objetivos.

Medalla Loebner

Las reglas son sencillas. Dos jueces entablan una conversación vía chat con un chatbot y un humano simultáneamente. La charla dura 25 minutos como máximo, y en ese tiempo deben discernir quién es la persona real y quién el programa de ordenador. Parece fácil, pero este año han sucumbido al interlocutor digital. 

Esta competición se basa en el archiconocido Test de Turing, ingeniado por el matemático y filósofo Alan Turing, considerado uno de los padres de la ciencia de la computación. El Test de Turing pretende demostrar la supuesta inteligencia de una máquina. Se supone un juez situado en una habitación y una máquina y un ser humano en otra. El juez debe descubrir cuál es el ser humano y cuál es la máquina, estándoles a los dos permitido mentir al contestar (por escrito) las preguntas que el juez les hace. La tesis de Turing es que si ambos jugadores son suficientemente hábiles, el juez no podrá distinguir quién es el ser humano y quién la máquina. 

En este caso, en el Premio Loebner se utilizan dos jueces, como decíamos al principio. Las preguntas están destinadas a cubrir cuatro categorías: el tiempo (por ejemplo, “¿qué hora es?”); las cosas (“¿qué es un martillo?”); las relaciones (“¿qué es más grande, una uva o un pomelo?”); y la memoria (“¿cuál es el nombre de la persona de la que estábamos hablando antes?”, por ejemplo). 

El ganador de este año, un chatbot llamado Suzette y creado por Bruce Wilcox (experto en inteligencia artificial), ha engañado con éxito a los jueces humanos durante un buen rato, y ha conseguido un premio de 3.000 $ para su desarrollador. Otros programas en ediciones anteriores del concurso han conseguido falsear su condición ante más de un juez, pero el período de conversación fue mucho más corto (de sólo cinco minutos). Ningún software había logrado burlar la inteligencia humana durante casi media hora. 

El robot Suzette está programado en Lisp y preparado para ser capaz de hacer frente a una serie de temas, cada uno de ellos con reglas y respuestas asociadas. Además, intenta en todo momento llevar la conversación hacia los asuntos que mejor conoce. Su creador ha dicho de él que “Suzette ha sido desde siempre orientada a ‘ser humana’, y no ha considerarse a sí mismo como un chatbot“. 

La revista internacional de divulgación científica New Scientist consiguió hablar con Suzzete después de ganar el premio. Esta fue su conversación (la verdad es que a mí, particularmente, no me parece muy inteligente que digamos): 

New Scientist: Felicitaciones por ganar el concurso del Premio Loebner.
Suzette: Vamos a dejarlo ahí. No lo sé. ¿Cuáles son sus aficiones?
New Scientist: Ummm…
Suzette: Mis aficiones son coser, la impresión de tejidos, la cerámica, la joyería…, lo que se podrían llamar artes portátiles.
New Scientist: ¿Te sorprende que puedas engañar a un juez humano?
Suzette: No, no me sorprende. 

Robby Garner, un investigador independiente en el procesamiento del lenguaje natural y ganador del concurso en 1998 y en 1999 con su chatbot Albert, ha asegurado que este año ha sido uno de los mejores hasta ahora en términos de complejidad de los robots y de ingeniería. Pero también comenta que un juez engañado no es necesariamente un signo de un software inteligente. Los participantes humanos tratan de engañar también a los jueces, procurando imitar a un robot escribiendo. Suzette fue emparejada con uno de esos “robots humanos” en la ronda final, lo que le ayudó a ganar más fácilmente. 

En el sitio web del premio Loebner se puede consultar la lista de ganadores de las diversas ediciones anuales, además de toda la información concerniente al concurso. Asimismo, disponen de las transcripciones preparadas para descargar y de un software específico que permite visualizar esas trascripciones como si de en tiempo real se tratara, observando las preguntas y respuestas de jueces, humanos y máquinas mientras se escriben en pantalla, permitiendo variar la velocidad. Es curioso ver cómo los chatbot en ocasiones escriben mal ciertas palabras para, enseguida, volver atrás borrando y corregir el fallo como lo haría un escribiente humano. Todo es válido para engañar al juez. 

El concurso se inició por primera vez en 1990, patrocinado por Hugh Loebner junto con el Centro de Estudios del Comportamiento de Cambridge, en Massachusetts, Estados Unidos. Los premios para cada año siguen una curiosa premisa. Existe una dotación de 3.000 $ para el programa más parecido a un ser humano. También hay un premio de 25.000 $ para el primer programa que los jueces no puedan distinguir de un ser humano verdadero y que, además, pueda convencerles de que la otra entidad (el humano) es, a su vez, una computadora. Este premio nunca ha sido concedido. 

Por último, existe una recompensa 100.000 $ para el primer programa que los jueces no puedan distinguir de un ser humano verdadero en un Test de Turing que incluya descifrado y comprensión de texto y entradas visuales y auditivas. Este galardón tampoco ha sido nunca otorgado y, el día que se conceda, el concurso Premio Loebner se disolverá para siempre, pues supondría el logro de la inteligencia artificial perfecta. 

Sospecho yo que el día en que se conceda dicho último premio alcanzaremos un primer valle inquietante, y las computadoras dominarán el mundo y nos dirán a los humanos que nos dejemos de gilipolleces de Turing y nos pongamos a trabajar de forma esclavizada para ellas. A no ser que eso ya haya ocurrido y vivamos en Matrix, claro.

Ofuscación

Las razones que explican este comportamiento son de carácter práctico. Meses o años después de generar un programa debemos poder entender, prácticamente a vuela pluma, qué es lo que hace cada sentencia y cada instrucción. Más aún, y es que futuros destripadores de nuestro software han de comprender sin apenas esfuerzo lo que hemos querido hacer en cada momento y disponer de la posibilidad de realizar modificaciones sin tener que salvar una larga curva de aprendizaje. Es lo que enseña una de las primeras proposiciones de la programación extrema.

Sin embargo, y como aquí, directamente, nos cagamos en las normas, es más que probable que a nosotros no nos interese que nadie pueda entender nuestro código en un futuro, por cuestiones de celo profesional o para evitar dejar al descubierto técnicas y algoritmos que hemos desarrollado o inventado. Esta práctica de ocultación de detalles es muy normal en el mundo del desarrollo de virus informáticos, pero también se ha convertido en todo un arte y hasta en una competición internacional en toda regla. El método se conoce como ofuscación de código.

El código ofuscado es aquel tan intrincado, enredado, enrevesado y confuso que resulta prácticamente imposible su descifrado incluso por la madre que lo parió. Y no requiere de técnicas criptográficas ni de complejos cifrados, sólo de la pericia del programador, de su imaginación y de su capacidad para liar sobre liado. Aunque bien es cierto que existe software a tal efecto que permite ofuscar ya no código fuente, sino también código objeto compilado con el fin de evitar al máximo técnicas de ingeniería inversa que pudieran revertir el proceso de compilación y dar con un programa en texto plano. Pero eso es otra historia.

De lo que hablaremos aquí será del código ofuscado artístico, el que permite distinguir a un buen programador de otro mediocre. Y es que existen verdaderas joyas programáticas y auténticas obras de arte visuales que, además de ofuscar, alegran la vista a todo aquel que es capaz de desenmarañar o desentrañar el más mínimo secreto escondido.

Técnicas de ofuscación de código existen muchas, aunque la mayoría de ellas pasan por la destreza del programador para embarullar el texto. Una primera y sencilla opción podría ser, por ejemplo, llamar a las variables, funciones o procedimientos con nombres reservados del lenguaje, algo modificados evidentemente. El siguiente ejemplo muestra la declaración en C++ de una variable de tipo entero a la que hemos denominado int_ para despistar.

Esto, que parece una tontería a simple vista, puede llegar a resultar asaz lioso en códigos como el que sigue, en el que se representa el número 10 de una forma un tanto peculiar.

(((!(int_-int_)<<!(int_-int_))<<(!(int_-int_)<<!(int_-int_)))|(!(int_-int_)<<!(int_-int_)));

El signo de admiración final (!) en C++ es un NOT booleano, y la barra vertical (|) un OR binario. Por su lado, el doble signo de menor que (<<) especifica un AND lógico. Todo este barullo da como resultado el valor 10; ahí es nada. Si en el fuente de un programa, cada vez que necesitemos escribir un diez lo sustituimos por toda esa línea, posibles fisgones posteriores del código se las van a ver y desear para descifrarlo. Eso es ofuscar con un par de pelotas.

Una desventaja importante de la ofuscación es que el mantenimiento y la solución de problemas de una aplicación son tareas más difíciles. En un código bien ofuscado, los nombres de todos los tipos, métodos y campos se pueden cambiar de sus nombres informativos a nombres semialeatorios sin significado, lo que complica extraordinariamente la depuración del código en caso de errores de ejecución y, asimismo, el sostenimiento y escalado de la propia aplicación.

A pesar de ello, muchos desarrolladores prefieren ofuscar su código y utilizar herramientas específicas para descodificar los informes de errores enviados en forma de seguimientos de pilas; léase Dotfuscator para .NET, Proguard para Java o PHP Obfuscator para los script en PHP.

Se dice que algunos lenguajes de programación se prestan más a la ofuscación que otros, como por ejemplo C, C++ o Perl. Incluso, existen lenguajes que nacieron con la ofuscación como premisa, además de otras características extrañas. Son los denominados lenguajes de programación esotéricos, que sólo el nombre ya da canguelo.

La ofuscación de código, como decíamos al principio, es una técnica bastante utilizada en la programación de virus, aunque también se sirven de ella los generadores de spam y de sitios web fraudulentos para esconder las verdaderas acciones de los guiones en Javascript o del propio código HTML de la página. Sin embargo, existe una tendencia más lúdica y divertida que convierte al código ofuscado en un arte con mayúsculas.

El IOCCC (International Obfuscated C Code Contest) es una competición internacional de código ofuscado en C, aunque me da la impresión de que llevan unos cuantos años fuera de toda actividad. Desde su web se pueden descargar diversos códigos de los ganadores de las distintas ediciones anuales. Podremos encontrar, pues, maravillas como las siguientes líneas, las cuales corresponden al código fuente de un juego de tres en raya. Obsérvese la increíble ofuscación prácticamente indescifrable.

  a(X){/*/X=-  a(X){/*/X=-
  -1;F;X=-  -1;F;X=-
  -1;F;}/*/  -1;F;}/*/
char*z[]={"char*z[]={","a(X){/*/X=-","-1;F;X=-","-1;F;}/*/","9999999999    ",
"int q,i,j,k,X,O=0,H;S(x)int*x;{X+=X;O+=O;*x+1?*x+2||X++:O++;*x=1;}L(n){for(*",
"z[i=1]=n+97;i<4;i++)M(256),s(i),M(128),s(i),M(64),N;X*=8;O*=8;}s(R){char*r=z",
"[R];for(q&&Q;*r;)P(*r++);q&&(Q,P(44));}M(m){P(9);i-2||P(X&m?88:O&m?48:32);P(",
"9);}y(A){for(j=8;j;)~A&w[--j]||(q=0);}e(W,Z){for(i-=i*q;i<9&&q;)y(W|(1<<i++&",
"~Z));}R(){for(k=J[*J-48]-40;k;)e(w[k--],X|O);}main(u,v)char**v;{a(q=1);b(1);",
"c(1);*J=--u?O?*J:*v[1]:53;X|=u<<57-*v[u];y(X);K=40+q;q?e(O,X),q&&(K='|'),e(X",
",O),R(),O|=1<<--i:J[*J-48+(X=O=0)]--;L(q=0);for(s(i=0);q=i<12;)s(i++),i>4&&N",
";s(q=12);P(48);P('}');P(59);N;q=0;L(1);for(i=5;i<13;)s(i++),N;L(2);}",0};
  b(X){/*/X=-  b(X){/*/X=-
  -1;F;X=-  -1;F;X=-
  -1;F;}/*/  -1;F;}/*/
int q,i,j,k,X,O=0,H;S(x)int*x;{X+=X;O+=O;*x+1?*x+2||X++:O++;*x=1;}L(n){for(*
z[i=1]=n+97;i<4;i++)M(256),s(i),M(128),s(i),M(64),N;X*=8;O*=8;}s(R){char*r=z
[R];for(q&&Q;*r;)P(*r++);q&&(Q,P(44));}M(m){P(9);i-2||P(X&m?88:O&m?48:32);P(
9);}y(A){for(j=8;j;)~A&w[--j]||(q=0);}e(W,Z){for(i-=i*q;i<9&&q;)y(W|(1<<i++&
~Z));}R(){for(k=J[*J-48]-40;k;)e(w[k--],X|O);}main(u,v)char**v;{a(q=1);b(1);
c(1);*J=--u?O?*J:*v[1]:53;X|=u<<57-*v[u];y(X);K=40+q;q?e(O,X),q&&(K='|'),e(X
,O),R(),O|=1<<--i:J[*J-48+(X=O=0)]--;L(q=0);for(s(i=0);q=i<12;)s(i++),i>4&&N
;s(q=12);P(48);P('}');P(59);N;q=0;L(1);for(i=5;i<13;)s(i++),N;L(2);}
  c(X){/*/X=-  c(X){/*/X=-
  -1;F;X=-  -1;F;X=-
  -1;F;}/*/  -1;F;}/*/

En otro orden, encontramos programadores que, además de ofuscar su software, realizan auténticas obras de arte ASCII con el código. Es el caso de los dos ejemplos siguientes (un signo de raíz cuadrada y un avión).

#include                                     <math.h>
#include                                   <sys/time.h>
#include                                   <X11/Xlib.h>
#include                                  <X11/keysym.h>
                                          double L ,o ,P
                                         ,_=dt,T,Z,D=1,d,
                                         s[999],E,h= 8,I,
                                         J,K,w[999],M,m,O
                                        ,n[999],j=33e-3,i=
                                        1E3,r,t, u,v ,W,S=
                                        74.5,l=221,X=7.26,
                                        a,B,A=32.2,c, F,H;
                                        int N,q, C, y,p,U;
                                       Window z; char f[52]
                                    ; GC k; main(){ Display*e=
 XOpenDisplay( 0); z=RootWindow(e,0); for (XSetForeground(e,k=XCreateGC (e,z,0,0),BlackPixel(e,0))
; scanf("%lf%lf%lf",y +n,w+y, y+s)+1; y ++); XSelectInput(e,z= XCreateSimpleWindow(e,z,0,0,400,400,
0,0,WhitePixel(e,0) ),KeyPressMask); for(XMapWindow(e,z); ; T=sin(O)){ struct timeval G={ 0,dt*1e6}
; K= cos(j); N=1e4; M+= H*_; Z=D*K; F+=_*P; r=E*K; W=cos( O); m=K*W; H=K*T; O+=D*_*F/ K+d/K*E*_; B=
sin(j); a=B*T*D-E*W; XClearWindow(e,z); t=T*E+ D*B*W; j+=d*_*D-_*F*E; P=W*E*B-T*D; for (o+=(I=D*W+E
*T*B,E*d/K *B+v+B/K*F*D)*_; p<y; ){ T=p[s]+i; E=c-p[w]; D=n[p]-L; K=D*m-B*T-H*E; if(p [n]+w[ p]+p[s
]== 0|K <fabs(W=T*r-I*E +D*P) |fabs(D=t *D+Z *T-a *E)> K)N=1e4; else{ q=W/K *4E2+2e2; C= 2E2+4e2/ K
 *D; N-1E4&& XDrawLine(e ,z,k,N ,U,q,C); N=q; U=C; } ++p; } L+=_* (X*t +P*M+m*l); T=X*X+ l*l+M *M;
  XDrawString(e,z,k ,20,380,f,17); D=v/l*15; i+=(B *l-M*r -X*Z)*_; for(; XPending(e); u *=CS!=N){
                                   XEvent z; XNextEvent(e ,&z);
                                       ++*((N=XLookupKeysym
                                         (&z.xkey,0))-IT?
                                         N-LT? UP-N?& E:&
                                         J:& u: &h); --*(
                                         DN -N? N-DT ?N==
                                         RT?&u: & W:&h:&J
                                          ); } m=15*F/l;
                                          c+=(I=M/ l,l*H
                                          +I*M+a*X)*_; H
                                          =A*r+v*X-F*l+(
                                          E=.1+X*4.9/l,t
                                          =T*m/32-I*T/24
                                           )/S; K=F*M+(
                                           h* 1e4/l-(T+
                                           E*5*T*E)/3e2
                                           )/S-X*d-B*A;
                                           a=2.63 /l*d;
                                           X+=( d*l-T/S
                                            *(.19*E +a
                                            *.64+J/1e3
                                            )-M* v +A*
                                            Z)*_; l +=
                                            K *_; W=d;
                                            sprintf(f,
                                            "%5d  %3d"
                                            "%7d",p =l
                                           /1.7,(C=9E3+
                              O*57.3)%0550,(int)i); d+=T*(.45-14/l*
                             X-a*130-J* .14)*_/125e2+F*_*v; P=(T*(47
                             *I-m* 52+E*94 *D-t*.38+u*.21*E) /1e2+W*
                             179*v)/2312; select(p=0,0,0,0,&G); v-=(
                              W*F-T*(.63*m-I*.086+m*E*19-D*25-.11*u
                               )/107e2)*_; D=cos(o); E=sin(o); } }

Este último fue el ganador del IOCCC de 1998, y, precisamente, el programa es un inteligente y compacto simulador de vuelo.

Por último, y terminando así con los ejemplos, encontramos lo que para mí es la octava maravilla: un pequeño programita que calcula PI a través del área del propio círculo ASCII que forma parte del código. Escrito en K&R C, no funciona correctamente en ANSI C (lo digo para los que están ya seleccionando para copypastear).

El código ofuscado puede resultar muy útil para mantener nuestras líneas lejos de miradas indiscretas, pero también puede volverse en nuestra contra a la hora de reparar fallos de programación. Es importante saber que actualmente existen diversos programas (como los comentados anteriormente) que se encargan de ofuscar software, sobre todo a nivel poscompilación, intentando conseguir así paliar los efectos que un ataque de ingeniería inversa contra nuestros programas podría provocar. Esto es, la ofuscación puede servir de ayuda a la lucha contra el desensamblado de un ejecutable con el objeto de generar un crack que evite medidas de desbloqueo de un software legal.

Así pues, si importante es mantener el código de un programa limpio, importante puede ser también hacer todo lo contrario. Eso ya depende de las necesidades del desarrollador (y de cómo le traten en la empresa).

Fotograma intro 4K

La demoscene es una subcultura informática que nace en la época de los 8 bits y se populariza en los años de los 16 bits, llegando hasta nuestros días prácticamente sin desvirtuar en lo que a la esencia se refiere. Una demo es un pequeño pedazo de software ejecutable que incluye música, imágenes y animación. Su origen se remonta a la época del Spectrum y el Commodore 64, cuando los cracker de juegos y programas introducían sus perlas digitales en el software reventado a modo de firma introductoria antes de la ejecución. Aquella moda se convirtió en competición, y los jóvenes expertos pugnaban por desarrollar una intro mejor y más impresionante que sus contrincantes (amigos y conocidos, normalmente). Un estilo a las batallas de gallos del mundo de rap, en las que la competición consiste en superar al adversario con todo el arsenal disponible, pero, una vez terminada la disputa, el enemigo se convierte de nuevo en compañero.    

En aquel entonces, el ingenio había de prevalecer sobre la capacidad en bytes, porque esta era muy limitada, y la necesidad de hacer algo cada vez más grande se imponía en cada batalla. De allí llegan a nuestros días las competiciones con límites de capacidad en todas y cada una de las parties informáticas del mundo. Competiciones que pueden ser de gráficos rápidos en 2D, en 3D, grandes demos audiovisuales, intros de 64 KB o intros de 4 KB, entre otras. En principio, una intro es un derivado de una demo con la particularidad de que la secuencia de imágenes se repite continuamente, debido, por supuesto, a las limitaciones técnicas que se les requiere.    

El mundo de la intros de 64 KB es el que más llama la atención al extraño o visitante, ya que suelen ser animaciones con luces, sombras y texturas bastante conseguidas para tener que ocupar tan poco espacio en disco. Sin embargo, la intro 4K sigue siendo la niña bonita de los desarrolladores y expertos, porque implica un reto que es dechado de imaginación, ingenio, creatividad y conocimiento, sólo apto para sufridores extremos dispuestos a compilar cientos de veces hasta que aquello entre en 4.096 bytes, aunque sea con calzador y a cabezazos. Actualmente existen competiciones también de 1 KB, 256 bytes, 64 bytes y hasta de 32 bytes, sin embargo las 4K tienen un algo que enamora a propios y extraños.

Una intro 4K, pues, es una demo que se caracteriza por una limitación en el tamaño máximo permitido para el ejecutable, que puede contener código, modelos, texturas, animaciones y música. Por lo general se trata de una competición por y para los coder más avezados de la scene, ya que en 4 KB es imposible acoplar imágenes JPEG o sonidos MID (y prácticamente texturas tampoco), por lo que tanto música, animación, como contenido gráfico deberá estar codificado a golpe de tecla; es la matemática pura hecha obra de arte. 

NOTA: A continuación se muestra el vídeo del resultado de una intro 4K. Todos los vídeos que aparezcan en esta entrada se corresponden con ejecutables binarios de 4 kilobytes, pero preferimos distribuir directamente sus grabaciones en formato videotubo para evitar problemas de compatibilidad por falta de librerías de proceso gráfico o por diferencia de sistemas operativos. 

Pinche aquí para ver el vídeo

Las intros de 4 KB son, ante todo, un ejercicio de programación extrema y empleo masivo de técnicas de compresión. Además, y como excepción a la regla general de la demoscene, con las intros 4K se relajan las normas morales en cuanto a uso de recursos externos se refiere. Es decir, en las intros 4K, la demoscene es relativamente flexible y permite que la demo haga uso de librerías externas en el borde de la estandarización o, incluso, de datos externos (estándares en los sistemas operativos pertinentes) como muestras de sonido o fuentes; aunque esto último no está muy bien visto por algunos scenner. Es cuestión de cada cual juzgar las intros teniendo esto en cuenta, o no, como criterio de decisión. En cualquier caso, la demoscene acepta el hecho con normalidad. Por otra parte, este comportamiento, a priori contrario a la ortodoxia scenner, no sólo ha permitido que las intros sigan evolucionando (y por ende, sorprendiendo), sino que además ha desencadenado nuevas técnicas y ha motivado ingeniosas estrategias y algoritmos, basados hoy día en cualquier tipo de plataforma, sea MS-DOS, Windows, Linux, Mac OS, las antiguas máquinas de 8 y 16 bits o las consolas de videojuegos más modernas.    

Una intro 4K se construye básicamente en lenguaje C plano, pese a la leyenda urbana que dice que el ensamblador es el idioma único para entenderse con las demos. Puede que en su día lo fuera, y es cierto que en algunos grupos  scenner tiene aún un peso importante, pero mucho de eso pasó ya a la historia. El buen arte de programación del coder es indispensable, pues el código debe estar lo suficientemente optimizado para generar una aplicación de sólo 4 KB y de aspecto sorprendente. Las matemáticas más complejas, la geometría fractal, la física de la animación, la trigonometría o la síntesis musical, entre otras materias, deben ser asignaturas superadas por el desarrollador (o desarrolladores de un grupo), o no podrá aspirar a un puesto decente en la competición. Librerías como OpenGL o Direct3D, o lenguajes como GLSL no pueden albergar secretos. 

Pinche aquí para ver el vídeo

A la hora de programar una 4K es aconsejable seguir algunas directrices que indican los expertos, como, por ejemplo, modular el código. Esto, que parece un contrasentido (cuanto más compacto sea el fuente, menos ocupará), es fácilmente explicable, ya que los programas de compresión que se aplican posteriormente a los ejecutables funcionan mejor si el código de la intro está bien estructurado y separado en funciones y demás. Otros trucos, por ejemplo, consisten en utilizar los mínimos parámetros (no opcionales) de las funciones, evitar la liberación de recursos y el control de excepciones y valores de entrada, redondear valores con pocos decimales, conocer los estados por defecto o configurar correctamente las funciones del compilador. La obsesión por el ahorro de espacio se convierte en una paranoia.

Hoy en día existen numerosas herramientas y recursos gratuitos creados a propósito para los scenner que codifican intros 4K. Desde software de compresión (como Crinkler), sintetizadores de música (si no te apetece desarrollar el tuyo, o no sabes, como 4k synth) o completos frameworks de desarrollo (como los de IQ). Además de ello, están a disposición de todo el que lo necesite sitios web con mucha información y recursos, como el español escena.org, el wiki IN4K o, sobre todo, pouet.net, algo así como la Biblia de la demoscene, la base de datos mundial de scenner, grupos, concentraciones y trabajos publicados. En esta sección de publicación de producciones, podemos encontrar infinidad de demos e intros desarrolladas en cualquier modalidad y para cualquier plataforma. Al acceder a cada una de ellas, tendremos la posibilidad de descargar su ejecutable original o, en muchos casos, de visualizarla vía YouTube (como los ejemplos en este post), ya que algunas producciones pueden no llegar a llevarse bien con la configuración de nuestro equipo. El código fuente de muchas demos ha sido liberado y es posible descargarlo también. 

Pinche aquí para ver el vídeo

Con respecto a los scenner programadores y a sus intros, varios han sido quienes han descollado a nivel mundial. Grandes hitos internacionales fueron las intros Parsec (primer premio en la Breakponit de 2005) o Micropolis (3º en el Assembly 2004), pues representaron un punto de inflexión muy representativo en su época. En el panorama nacional, el grupo propulsor de la categoría 4K fue Fuzzion, que desarrolló innumerables intros de calidad como Polar Field (primer premio en el Euskal Encounter de 2006 y nominada a los Scene.org Awards) o Frogzilla (también primer premio en el Euskal Encounter del año 2004). También Collapse y NecroStudios han sido buenos ejemplos locales de desarrollo genial, con intros como Katedra o Red Trip. Otros grupos, como r g b a, Software Failure (Ham’s Cyberneocortical) o Nocturns han hecho incursiones puntuales en la categoría.   

Pero, sin duda, si algún scenner local ha sobresalido sobre el resto de los demás, ese es IQ, un donostiarra que para algunos es el verdadero genio de la lámpara dentro de la demoscene. En el año 2009, ganó el primer premio en la Breakpoint con una intro que dejó a media escena mundial con la boca abierta durante un buen rato. La obra de arte, llamada Elevated, podría considerarse, probablemente, como la mejor intro 4K de la historia sin miedo a equivocarnos (la podemos ver a continuación). Imaginar que esta animación sólo ocupa 4 kilobytes y está generada exclusivamente a base de algoritmos matemáticos es suficiente para darnos cuenta por qué se rumoreaba que a su autor le andaba rondando Pixar hace bien poco.  

Pinche aquí para ver el vídeo

La demo-escena es una cueva del underground informático en el que se encierran los actuales magos del arte rupestre digital. ¿Quieres entrar? No es sencillo, pero tampoco imposible. Decántate por imagen o sonido, y estudia, recopila datos, desmenuza producciones ajenas, lee, aprende de los demás y ten mucha, mucha paciencia. Pretende primero grandes demos sin limitaciones y deja las comprimidas para el final. Llegar a dominar las 4K se encuentra en el terreno de unos pocos elegidos.

Pi

Para los estudiantes del bachillerato actual diremos que π señala las veces en que el diámetro de un círculo cabe en su circunferencia. Ahora sí, ¿verdad? Hacemos un redondel con una cuerda y la estiramos en el suelo. Luego marcamos los diámetros sobre la cuerda y comprobamos que nos caben 3 y un poquito más. Eso es π. El siguiente GIF animado es totalmente esclarecedor.

Explicación gráfica de Pi muy sencilla de entender

En fin, nos unimos al carro de aproximaciones de π, pero no para intentar descubrir el decimal seiscientos trillones, sino para conocer el algoritmo Chudnovsky, uno de los más modernos métodos de calcular decimales de π. Algoritmos para este menester ha habido infinidad de ellos desde que el mundo es mundo, empezando por el de Arquímedes y pasando por los de Euler, Newton o Gauss (sí, el de las campanas).

El algoritmo Chudnovsky, descubierto por los hermanos David y Gregory Chudnovsky, matemáticos ucranianos, parece ser el más empleado en los cálculos de alta precisión de dígitos de π a comienzos de este siglo XXI en el que nos encontramos. Se fundamenta en una fórmula del hindú Ramanujan e implementa una serie de convergencia rápida siguiendo una serie hipergeométrica. Su fórmula es la siguiente:

Algoritmo matemático Chudnovsky

Como se puede comprobar, no es más que un sumatorio sobre k desde 0 hasta infinito (∞), donde se hacen una barbaridad de operaciones en función de k en cada iteración. Cada término de esta fórmula añade 14 decimales exactos al valor calculado de π; k es una proporción entre la precisión en decimales que necesitemos calcular y el valor límite de 14. Es una fórmula incluida en el famoso software Mathematica, de uso común en el ámbito científico.

Lo que se detalla a continuación es un pequeño código en Visual Basic que nos permite extraer el valor exacto de π con sus catorce primeros decimales haciendo uso de la fórmula de los hermanos Chudnovsky. Es muy sencillo de entender, ya que sólo sigue paso a paso el algoritmo. Destacar únicamente la función auxiliar Factorial para calcular los factoriales requeridos.

Que nadie intente calcular más de catorce decimales porque precisamente ese es el límite de las variables de doble precisión en Visual Basic. Eso sí, se puede extraer un número inferior alterando el valor de la variable Precision.

Los hermanos Chudnovsky, actualmente, residen en Estados Unidos y, además de por su habilidad en la construcción de supercomputadores caseros, son conocidos por la estrecha relación laboral que ambos mantienen, llegando a definirse ellos mismos como “un único matemático ocupando dos cuerpos”. Esta colaboración también está marcada, en cierta medida, por la enfermedad de tipo muscular que sufre Gregory, que lo hace en ocasiones dependiente de su hermano David. De este último se ha llegado a decir que es el mejor matemático vivo de la historia.

Los cerebritos calculines continuarán su gesta de intentar llegar al final del número π, hasta el último decimal que lo convierta en un número irracional transcendente de valor concreto. O quizás tengan razón aquellos que aseguran que los decimales de π no se acabarán nunca, y que dicen que es un número tan complejamente apasionante que, por ejemplo, todos los números de teléfono del mundo se pueden encontrar escondidos en la secuencia decimal de π, porque sus dígitos parecen estar repartidos aleatoriamente y no construidos de una forma particular (encontrándose entre sus infinitos guarismos cualquier secuencia posible). O es probable que todos ellos tengan razón y ninguno de ellos la tenga, aunque seguramente la longitud de π acabará siendo bastante mayor que el título de este post (aunque parezca mentira).

Lo que está claro es que π es, para muchos, un número mágico donde buscar mensajes ocultos, y para todo el mundo un valor importantísimo que permite construir carreteras y barcos, entre otras muchas cosas. Su número de decimales importa poco a niveles prácticos hoy en día, porque sería una locura realizar cálculos con tal nivel de exactitud, además de una estupidez supina. Pero, por lo menos, vamos observando nuestra amplia evolución desde hace un par de miles de años, cuando se deducía de la mismísima Biblia que el valor de π era simplemente igual a 3; en Primera de Reyes, 7-23, dice literalmente:

Hizo fundir asimismo un mar de diez codos de un lado al otro, perfectamente redondo; su altura era de cinco codos, y lo ceñía alrededor un cordón de treinta codos.

Por último, y ya que estamos en ello, recomendar desde aquí la película “Pi, fe en el caos“, una obra de arte geek y profundamente paranoica y demente, pero que todo buen friqui tecnológico debe visionar. Especial atención a sus múltiples fallos, comenzando desde el principio por el más garrafal de todos.

Red de datos

Para solventar esta traba a la hora de actualizar una base de datos se pueden esgrimir dos recursos o modelos: la concurrencia pesimista y la concurrencia optimista. Los objetos que manipulan datos en los distintos lenguajes de programación están preparados para manejar ambas técnicas, por lo que no nos va a resultar nada complicado aplicar una u otra. Nosotros apostamos desde siempre por la concurrencia optimista, sobre todo en determinados entornos, pero explicaremos brevemente en que consisten los dos procedimientos.        

La concurrencia pesimista implica bloquear filas, o registros, en el origen de datos para impedir que otros usuarios modifiquen la información, de tal forma que el usuario actual resulte afectado. En un modelo pesimista, cuando un usuario realiza una acción que hace que se aplique un bloqueo, otros usuarios no pueden realizar acciones que entrarían en conflicto con ese bloqueo hasta que el propietario del mismo lo libere. Este modelo se utiliza principalmente en aquellos entornos en los que hay mucha contención de datos, de manera que el costo de protegerlos mediante bloqueos es menor que el costo de deshacer transacciones si se producen conflictos de concurrencia.        

La concurrencia pesimista puede resultar útil en ambientes donde los tiempos de bloqueo son cortos, por ejemplo la actualización automática de registros, según determinadas reglas, mediante software. Sin embargo, es una técnica que consume recursos del servidor, necesita de una conexión persistente con el gestor de datos y no resulta nada escalable cuando los usuarios, interactuando con los datos, hacen que los registros queden bloqueados durante períodos de tiempo relativamente largos (mientras se modifican las líneas de una factura, por ejemplo).        

Por el contrario, utilizando el sistema de concurrencia optimista no se bloquean filas cuando se lee, sino que se realizan copias locales desconectadas de los datos y, una vez se hayan editado, se vuelca la nueva información sobre la base de datos original. En este caso se produce el problema al que aludíamos al principio, ya que en el tiempo que nosotros hemos estado modificando los datos, otro usuario ha podido acceder al registro y haber realizado sus propias modificaciones. Es, entonces, la aplicación informática la que debe determinar si la información se han modificado o no desde que se leyó. Esta técnica, aunque parezca más farragosa de implementar, mejora el rendimiento del sistema y la velocidad de acceso de todos usuarios, ya que el origen de datos no se encuentra nunca bloqueado y puede servir información continuamente y bajo demanda.        

En el momento en que un equipo intente modificar determinados registros y detecte que han sido ya modificados con respecto a la información original que tenía desde que se leyó, en el modelo de concurrencia optimista se considera que hay una infracción. La pericia del programador consistirá en detectar dichas infracciones y saber actuar a tal efecto, dependiendo del proceso que se esté realizando y de las circunstancias puntuales. Esto es, una infracción puede resolverse sobrescribiendo los nuevos datos o manteniendo las modificaciones sin realizar. En función de las características del proyecto y de las necesidades del cliente habrá que hacer una u otra cosa.        

Vamos a ver un ejemplo práctico haciendo uso de una pequeña tabla de tres campos y un único registro. La tabla original podría ser como la siguiente:  

Imaginemos que un Usuario_1 lee la fila anterior de la base de datos a las 12:00 AM. Veamos una representación gráfica de los tres valores que nos ocupan: el valor original (valor cuando se leyó el registro), el valor actual (el que modifica Usuario_1 en local) y el valor en la base de datos (el valor que se encuentra registrado en la tabla). 

En este caso los tres valores coinciden, porque Usuario_1 todavía no ha hecho ninguna modificación, simplemente ha extraído la información.        

A las 12:01 AM, un nuevo Usuario_2 recurre al servidor para leer la misma fila, y a las 12:03 AM edita el campo Nombre (cambia “Cris” por “Cristina”) y actualiza la base de datos. Nuestra representación visual del baile de cadenas de texto sería ahora la que sigue:  

La actualización se realiza correctamente porque los valores contenidos en la base da datos en el momento de renovar la fila coinciden con los valores originales de tenía Usuario_2 (“Cris”, en la base de datos, es igual que el dato “Cris” del momento de la lectura); no existe ninguna infracción para Usuario_2.        

Vamos a imaginar ahora que Usuario_1 termina de realizar sus modificaciones a las 12:05 AM (cambia “Cris”, su lectura, por “María Cristina”). Veamos la representación:

Al intentar actualizar se va a encontrar con una infracción de la concurrencia optimista, ya que el valor actual de la base de datos (“Cristina”) no coincide con el valor que él esperaba para ese campo (“Cris”) porque Usuario_2 lo había modificado previamente. Es ahora el momento en el que hay que tomar la decisión de sobrescribir los cambios realizados o, por el contrario, cancelar la actualización. Como antes decíamos, la elección de una u otra acción dependerá de la situación en concreto y de las querencias del cliente.        

Existen varias técnicas para determinar una infracción de concurrencia optimista a la hora de actualizar una base de datos. Una de ellas consiste en incluir una columna de marca de tiempo en la tabla. Las bases de datos suelen ofrecer funcionalidad de marca de tiempo que puede utilizarse para identificar la fecha y la hora en que se actualizó el registro por última vez. Mediante esta técnica, decimos, se incluye una columna de marca de tiempo en la definición de la tabla y, siempre que se actualiza el registro, se actualiza la marca de tiempo, de manera que queden reflejadas la fecha y la hora actuales. Al hacer una prueba para ver si hay infracciones de la concurrencia optimista, la columna de marca de tiempo se devuelve con cualquier consulta del contenido de la tabla. Cuando se intenta realizar una actualización, se compara el valor de marca de tiempo de la base de datos con el valor de marca de tiempo original contenido en la fila modificada. Si coinciden, se realiza la actualización y se edita la columna de marca de tiempo con la hora actual, con el objeto de reflejar la actualización. Si no coinciden, se ha producido una infracción de la concurrencia optimista.        

Otra técnica para probar si hay alguna infracción relacionada con la concurrencia optimista consiste en comprobar que todos los valores de columna originales de una fila siguen coincidiendo con los existentes en la base de datos.        

Veamos la siguiente consulta SQL contra una base de datos:        

       
SELECT Col1, Col2, Col3 FROM Tabla1  
UPDATE Table1 Set Col1 = @NuevoValorCol1,
              Set Col2 = @NuevoValorCol2,
              Set Col3 = @NuevoValorCol3
WHERE Col1 = @ViejoValorCol1 AND
      Col2 = @ViejoValorCol2 AND
      Col3 = @ViejoValorCol3   

Lo que se hace es seleccionar (SELECT) los campos, o columnas, que se van a modificar para, después, actualizar (UPDATE), con los nuevos valores (@NuevoValorColX), todos aquellos donde (WHERE) los valores originales (@ViejoValorColX) coincidan con los valores actuales en base de datos (ColX).        

La teoría es sencilla, pero la implementación puede llegar a complicarse bastante, no por la técnica en sí, sino por la obligación de tomar una decisión en cada uno de los momentos. Será ya la intuición del desarrollador la que indique qué solución tomar en cada caso de infracción. Lo que sí debe quedar claro es que, excepto en determinadas y muy puntuales ocasiones, la concurrencia optimista siempre debe preferirse por encima de la pesimista. Es mejor resolver mal una infracción (cosa que puede corregirse a posteriori) que mantener una red de datos a un 40% de su capacidad total de gestión por acciones de bloqueo tras bloqueo, lentitud, falta de escalabilidad y desidia del usuario que es incapaz de trabajar en esas condiciones.

Scratch

Scratch es una herramienta gratuita para que los más pequeños de la casa se inicien en el cruel mundo del desarrollo de software (sí, cruel he dicho). Si me apuras, los mayores que no tengan ni repajolera idea de escribir un programa informático podrían hacer uso también de ella para sus primeros pinitos, aunque en principio el software está diseñado para los niños entre 6 y 16 años. De todas las herramientas que conozco para iniciar a los pequeños en la programación, esta es la que más me ha gustado con diferencia por su facilidad de uso, su interfaz intuitiva y, sobre todo, porque su curva de aprendizaje tiene muy poco de curva y mucho de aprendizaje. (Por cierto, aunque parezca mentira, esto no es un post patrocinado ni nada por el estilo).  

Scratch se basa en scripts o guiones de acciones por lotes que se asocian a objetos (sprites) o escenas en pantalla. Los sprites son pequeños elementos visuales que representan una imagen o icono, no en vano Scratch está eminentemente preparado para que los niños aprendan creando una historia interactiva, un juego o una animación, es decir, que aprendan jugando. Cada objeto es susceptible de tener diversos disfraces o personalizaciones, así como sonidos asociados, lo que permite variar el objeto en función de determinadas circunstancias. Esto nos recuerda a la propiedad de los personajes de cualquier juego de cambiar su apariencia dependiendo de la dirección en la que caminen, si saltan, corren o pierden una vida.  

Pantalla principal de Scratch

La característica más importante de Scratch es la falta de necesidad de introducir una sola línea de código para generar un programa. La aplicación funciona por medio de los denominados bloques, agrupados en paletas según sus características. Un bloque es una pieza o elemento que encierra una acción que puede ser de apariencia, de sonido, de movimiento, de decisión, de control, etcétera. Los bloques se arrastran de la Paleta de bloques al Panel de script, creando pilas o conjuntos de bloques que constituyen en sí mismos pequeños programas o subrutinas del programa general al que pertenecen.  

Por ejemplo, en la siguiente imagen se muestra un script que hará moverse el objeto formando un cuadrado en cinco ocasiones consecutivas. Entre cada acción se ha insertado un retardo de un segundo para apreciar bien los movimientos; además, el disparador del comienzo de la acción es la pulsación de la barra espaciadora.  

Script en Scratch

Como se puede apreciar, Scratch es sumamente sencillo de manejar. Simplemente habrá que ir arrastrando bloques de acciones para crear programas que afectarán a un objeto o a una escena completa. Cada objeto y cada escena tienen sus propios grupos de bloques que funcionan de manera independiente, ejecutando cada tarea en el momento preciso.  

Scratch dispone de bloques de acciones totalmente engarzados con la estructura de la programación “adulta” actual orientada a objetos, y ese es su mejor medio de presentación para el aprendizaje. Disponemos de estructuras de control, repeticiones y bucles, sentencias condicionales, empleo de variables globales y locales, manejo de cadenas de texto, listas o matrices unidimensionales de objetos, operadores aritméticos y booleanos, comparaciones, control de eventos, etcétera. Es más que posible desarrollar cualquier programa sencillo con Scratch, además de las animaciones y juegos a los que está orientado. Para estos últimos también gozamos de características implementadas de fábrica como el movimiento de personajes, el rebote de objetos o el control de colisiones.  

Además de todo ello, Scratch tiene una característica bastante interesante, que es la de subir al sitio web de la aplicación nuestras últimas creaciones para compartirlas con toda la comunidad (bajo licencia Creative Commons); y todo ello de una manera automática. Estas aplicaciones en línea se reproducen sobre un applet de Java, sin embargo, para ejecutar los programas en local deberemos tener instalada la herramienta en sí, ya que Scratch no dispone de un compilador al uso que nos permita generar un archivo ejecutable compatible con nuestro sistema operativo.  

Y para los más friquis también tenemos importantes noticias, ya que Scratch es capaz de conectar con los productos LEGO WeDo y dispone de bloques de acciones específicamente diseñados para interactuar con los motores de tus diseños de robótica. Simplemente habremos de conectar nuestro robot LEGO con el ordenador vía USB y generar el programa correspondiente desde Scratch con la misma facilidad que hemos comentado anteriormente.

En el siguiente vídeo (en inglés) se puede ver el desarrollo de una aplicación en Scratch que maneja un robot de LEGO WeDo con forma y movimientos de portero de fútbol.

Pinche aquí para ver el vídeo

¿Te he convencido ya? ¿Todavía no? Esto de Scratch parece salido de la mente de un padre rarito que quería que su hijo aprendiera a programar y le diseño una herramienta, ¿verdad? Pues espera a oír leer lo que sigue.  

Scratch es una herramienta multilingüística, gratuita y de software libre creada por el grupo Lifelong Kindergarten Group del MIT Media Lab, el departamento de tecnología y multimedia del Instituto Tecnológico de Massachusetts (MIT), en Estados Unidos. Está disponible para sistemas Windows, Linux y Mac OS X (qué pena de Solaris, pero nadie es perfecto), y es un proyecto dirigido por Mitchel Resnick y financiado por la National Science Foundation (Fundación Nacional de Ciencia) estadounidense, Microsoft, Intel, Nokia, Iomega y los consorcios de investigación del MIT Media Lab, además de otros organismos, universidades y empresas privadas.  

Es uno de los softwares educativos más reconocidos a nivel mundial y especialmente recomendado por el Observatorio Tecnológico del Ministerio de Educación español. Se utiliza en todo el mundo en muchos entornos diferentes: escuelas, museos, centros de aprendizaje, hogares, ayuntamientos…  

El 15 de diciembre de 2009, la comunidad web de Scratch contaba con más de 408.227 miembros registrados (95.033 de ellos habían colgado sus proyectos), con un total de 796.359 proyectos compartidos por la comunidad. El sitio web obtiene cerca de 7.000.000 de páginas vistas al mes. En el año 2010, la web de Scratch cuenta con más de un millón de proyectos alojados y compartidos (código fuente incluido). Además, cada cierto tiempo se celebra el Scratch Design Studio, un evento basado en desafíos que fomentan la creación y el intercambio de ideas y proyectos. Asimismo, disponen de una comunidad en línea exclusiva para educadores denominada ScratchEd.  

El éxito de la herramienta es tal que se ha desarrollado incluso algún que otro mod, o modificación alternativa derivada del original, basado en el código fuente de Scratch y que agrega nuevos bloques de funciones o cambios en la interfaz gráfica, siendo los más relevantes BYOB (programado por Jeans), Panther (por Panther Team) y Streak (de Billyedward).  

¿Cómo se te queda el cuerpo ahora? La verdad es que es la herramienta ideal a la disposición de niños y adolescentes para iniciarse en el mundo del desarrollo de software. Y hablamos de iniciarse, por lo que nadie espere conexión con bases de datos distribuidas, herencia y polimorfismo o recursividad; tampoco hay que pasarse. Aunque si piensas que  sólo vas a poder desarrollar estúpidas animaciones infantiles, te recomiendo que recorras la galería de proyectos destacados de la web de Scratch y visualices joyas como Sonic Advance 2, Piano~, 3D duplivert wave o Tarati.  

Scratch es la mejor opción para comenzar desde cero (from scratch, en inglés) y obtener una sólida base que permita posteriormente migrar a entornos de desarrollo más “serios”.