Logo de Winphone Metro

Difoosion

Me llena de orgullo y satisfacción que me hayan acogido en Difoosion como editor en su blog sobre noticias de Windows Phone: Winphone metro.

Logo de Winphone Metro

Tienen una red de blogs bastante interesante sobre el mundo móvil, no sólo de Windows Phone:

Logo Andro4all

Andro4All: Noticias sobre la plataforma Android.

Logo Applesencia

Applesencia: Noticias sobre Apple.

Logo Xombit

Xombit: Noticias sobre ciencia, tecnología, cultura, gadgets, series y juegos.

Logo XombitGamesXombit Games: Noticias sobre videojuegos de todas las plataformas

Uyuyuy, una sorpresa de última hora y es que ayer se lanzó:

Logo SportAdictosUn blog sobre deporte, salud y nutrición.

La verdad es que es una red de blogs muy recomendable para estar al tanto de lo que se cuece sobre estos temas y es que se actualizan bastante a menudo y creo que a los que me leéis os puede interesar.

Espero que os gusten.

Windows Azure Media Services

Windows Azure Media Services

Hace un mes que se anunció la salida de Windows Azure Media Services.

Es el servicio en la nube que nos permite construir y publicar soluciones multi-media a nuestros clientes. Ofrece un montón de servicios listos para codificar, almacenar, proteger y lanzar por streaming (tanto live como bajo demanda) de video. También integra y expone servicios de nuestros partners - permitiendo una pila de funcionalidad increíble.

Podéis usar Windows Azure Media Services para entregar soluciones a cualquier dispositivo o cliente - como HTML5, Silverlight, Flash, Windows 8, iPads, iPhones, Android, Xbox, y Windows Phone. Windows Azure Services soporta una gran variedad de formatos de streaming - como Smooth Streaming, HTTP Live Streaming (HLS), y Flash Media Streaming.

Uno de los aspectos que hacen único a Windows Azure Media Services es que todas sus características están expuestas usando una API REST HTTP. Esto es así tanto para los servicios multimedia, como para los servicios de nuestros partners. Esto hace que sea muy fácil automatizar workflows multimedia e integrar los servicios en nuestras aplicaciones. Como el resto de Windows Azure, sólo hay que pagar por los servicios de Windows Azure Media Services que usemos - haciendo que el coste sea muy interesante.

Windows Azure Media Services

Windows Azure Media Services usa el mismo backend que se usa para ofrecer eventos de deportes en vivo - como los juegos Olímpicos de Invierno de 2010, el Mundial de Fútbol 2010, los Campeonatos de Wimbledon 2011 y la SuperBowl 2012. Con Windows Azure Media Services podremos montar y automatizar soluciones en la nube que sean capaces de ofrecer soluciones a una gran audiencia.

Aprende más

Hemos usado Windows Azure Media Services en el 2012 National Association of Broadcasters (NAB) Show, los asistentes pudieron hablar con el equipo y ver demos en directo.

También podéis visitar windowsazure.com media para ver las características que ofrece, y pasaros por los recursos para desarrolladores de windowsazure.com para a ver cómo podemos usarlo. También podéis registraros para una cuenta de prueba enviando un email a mediaservices@microsoft.com (junto con los detalles del escenario para el que lo queréis usar).

Estamos deseando ver las cosas que sois capaces de hacer.

Scott.

Traducido por: Juan María Laó Ramos.

Artículo original.

Primer camino para alcanzar el Nirvana del Garbage Colector

Para ponernos en contexto y verlo más claro debemos saber que lo que vamos a ver es realmente importante en el mundo de los videojuegos ya que en este mundo el consumo de memoria y de recursos es algo crucial y hay que optimizarlos al máximo. En este sentido el proceso de recolección de basura es algo importantísimo ya que consume recursos del sistema y si se ejecuta en mitad del juego se puede producir una bajada de rendimiento importante.

En este primer post de la serie vamos a ver una de las formas de evitarlo.

Este es el post original de Shawn Hargreaves:

En este post vimos cómo saber si el recolector de basura de nuestra Xbox está tardando mucho. Vimos que el tiempo que tarda el recolector de basura es el resultado del producto del número de veces que se recolecta por la latencia misma de la recolección.

Esto nos hace pensar en dos formas de mejorar el rendimiento del proceso de recolección de basura. Podemos reducir el número de recolecciones, o podemos reducir la latencia del proceso de recolección. Con que consigamos reducir uno de esos valores se notará una mejora bastante notable en el rendimiento total.

En este post vamos a ver el primer caso:

Elegir una frecuencia de recolección adecuada

La frecuencia con la que se produce la recolección de basura es directamente proporcional al número de veces que reservamos memoria. Si nunca reservamos memoria, el proceso nunca se lanzará.

Para reducir el número de recolecciones, debemos reservar memoria para aquello que vamos a necesitar mientras cargamos los niveles, y evitar reservas de memoria en el tiempo de juego, evitando así que el recolector de basura entre en acción en mitad del juego.

Hay varias formas para evitar la reserva de memoria:

No reserves memoria (jah!)

Es simple, no hagas news de tipos por referencia. Está bien cuando lo hacemos con tipos por valor como Matrix, Vector3, Color y demás.

Cada vez que queramos hacer un new de un tipo por referencia, debemos usar un pool de objetos para reusar sus referencias. Los ejemplos de Particle y Audio 3D de creators.xna.com usan esta técnica, y SwampThingTom escribió sobre un pool genérico y reusable.

No uses clases que reserven memoria por sí mismas.

Cuando añadimos datos a una colección como un List<T> o un Dictionary<K,V>, se reserva memoria cuando se quieren ampliar. Podemos evitarlo usando el constructor existente en el que se indica el tamaño específico de la colección. Usando este constructor hacemos que se reserve la memoria necesaria para toda la colección haciendo que esta no tenga que ampliar ni disminuir la memoria que necesita.

Ten cuidado cuando formatees cadenas. Es difícil manipular cadenas en .NET sin causar reservas de memoria.

Evita que el CLR reserve memoria.

El CLR reserva memoria cuando ocurre el boxing. ¡Evítalos como si de una plaga se tratase! El boxing puede ocurrir por muchas razones, algunas son obvias, otras no tanto, veamos cuándo ocurre el boxing.:

  • Si asignamos un tipo por valor a una variable Object.
  • Si guardamos tipos por valor en una colección no genérica.
  • Si accedemos a tipos por valor a través de una interfaz.
  • Si usamos un enumerado como clave de un diccionario, las operaciones internas del diccionario generan boxings. Podemos evitarlo usando claves enteras (de tipo int), y hacer casting a los valores de nuestro enumerado antes de añadirlas al diccionario.

No dejes que el compilador de C# reserve memoria.

Puedes ser realmente tricky usar delegados (especialmente los que están definidos "inline") sin hacer que el compilador reserve memoria. Esto es todo un mundo por sí solo, pero en caso de duda evita el uso de delegados o eventos

Los yield hacen que el compilador reserve siempre memoria.

Los foreach pueden reservar memoria sin cuidado. Pero ojo, esto no significa que tengamos que evitarlos. Suele ser la forma más rápida de recorrer una colección.  Aprended las reglas para usarlos de manera adecuada

Todo lo que no reserve memoria está bien.

A los discípulos del camino de la frecuencia se les permite tener estructuras de datos complejos. Pueden reservar cientos de miles de objetos mientras su juego carga, llenar el heap con una malla de objetos referenciados entre si. Siempre que no reserven nada después de que termine de cargar, el recolector de basura nunca se ejecutará, así que no hay problema ninguno en mantener en memoria objetos complejos.

Resumen

Hemos visto una forma de hacer que el recolector de basura no se ejecute mientras se está jugando al juego: evitando hacer reservas de memoria durante el juego, en vez de eso las hacemos en el proceso de carga y se mantiene todo en memoria.

En el próximo post veremos la segunda opción: Elegir la latencia adecuada.

Juan María Laó Ramos.

Post original.

La “locura” de las optimizaciones en los juegos.

¿A quien no le preocupa que su código no sea óptimo? Eso de "funcionar funciona ... pero tarda mucho" no es escusa para no preocuparse por optimizar las partes optimizables. Una de las mejores formas de evitarse problemas desagradables cuando el sistema está "terminado" es interiorizar los conceptos y aplicarlos en la práctica de manera casi automática.

Para ponernos en contexto y verlo más claro debemos saber que lo que vamos a ver es realmente importante en el mundo de los videojuegos ya que en este mundo el consumo de memoria y de recursos es algo crucial y hay que optimizarlos al máximo. En este sentido el proceso de recolección de basura es algo importantísimo ya que consume recursos del sistema y si se ejecuta en mitad del juego se puede producir una bajada de rendimiento importante.

Estos conceptos no son sencillos, ya que involucran "gran cantidad" de detalles que se suelen pasar por alto.

En un afán de mejorar y compartir lo aprendido vamos a ver en detalle un par de posts de  Shawn Hargreaves que he encontrado y que publicaré en varios posts para no saturar y podamos interiorizarlos mejor.

- Primer camino para alcanzar el Nirvana del Garbage Colector.

- Segundo camino para alcanzar el Nirvana del Garbage Colector y cual elegir.

- Delegados, eventos y basura. (Próximamente).

Espero que os sirva.

Juan María Laó Ramos

¿Veremos en The Windows Phone Developer Conference a WP Apollo?

Dentro de unos meses se cumplen dos años de la salida de Windows Phone 7 y un año de la de  Mango. Como no deja de ser una ciencia, la estadística nos dice que en Octubre estará disponible Windows Phone 8 Apollo.

Entre los días 22 y 24 de Octubre de 2012 también está programado el evento “The Windows Phone Developer Conference”   que en WPCentral  anuncian como el primer ciclo de conferencias de Windows Phone que no está patrocinado por Microsoft.

WPDevcon

En el programa del evento podemos ver la gran cantidad de sesiones sobre WP7. Sin embargo, en la noticia de WPCentral destacan que el gran artista invitado será Apollo, nombre en clave que los de Redmon han dado a Windows Phone 8. En WPCentral destacan que habrá una sesión específica para aprender todo lo que traerá Apollo, como resoluciones de pantalla, los cambios que habrá en el Marketplace,  las características que tendrá el nuevo emulador y se verá cómo migrar las aplicaciones de Mango a Apollo.

Todo un caramelo para desarrolladores, sin embargo si nos vamos a la web del evento y vemos el pdf con el programa no se hace referencia a Apollo en ninguna parte.  Lo que me ha llamado la atención es que en los comentarios de la noticia se han fijado en la fecha de creación y modificación del pdf. Así que parece que han eliminado las referencias a Apollo del documento.

¿Una estrategia de marketing para conseguir más asistentes? Es posible, pero sin duda que por esas fechas ya se tendrán más detalles sobre la nueva versión de Windows Phone y seguramente ese evento sea un lugar privilegiado para enterarnos de cómo adaptar las aplicaciones existentes a la nueva versión del sistema operativo.

Más tiempo para Cell·APP Awards

Las plegarias han sido oídas y  hemos ampliado el plazo para presentar juegos y aplicaciones a Cell·APP Awards:

Cell·App Awards

Desarrolla tu app usando CELL·SDK. Debes rellenar este formulario para participar y enviarnos el formulario de suscripción.

  • Fin de Inscripción: 31/05/2012
  • Último día para enviarnos tu app: 15/06/2012
  • Periodo de votaciones Online: Empezará una vez envíes tu app y nosotros la subamos. Este periodo acabará el 26 de Junio
  • El Jurado valorará las apps más votadas a partir del 28 de Junio.
  • La entrega de premios será el 29 de Junio.

Todavía no tienes Cell·SDK?! O_o

Pues descárgalo aquí.

CodeFluent Entities. Nunca el DDD fué tan fácil

Vamos a ver en este post es un producto que he encontrado y parece muy prometedor. CodeFluent Entities es una herramienta de modelado que nos permite generar y mantener actualizadas todas las layers y capas de nuestra aplicación. Asegurando el conjunto de buenas prácticas arquitecturales en nuestros sistemas desde su nacimiento. Esto es, han creado una herramienta para aplicar Domain Driven Development sin que apenas nos demos cuenta.

La he estado probando un tiempo y la verdad me ha dejado sorprendido, pensé en un momento que iba a ser un ORM más, pero luego descubrí el modelador de objetos de negocio, seguido de la generación de servicios RESTful, la sencillez de enlazar el modelo de negocio con las interfaces de usuario ASP.NET Web Forms, WPF y Windows Forms (están trabajando en los conectores para ASP.NET MVC, Silverlight). Sigue leyendo

Cell·SDK

Cell·SDK y el emulador de Android

Hace unas semanas se publicó una actualización del emulador de Android que muchos estábamos esperando.

Entre otras cosas, la característica fundamental, y una de las más esperadas, es que esta versión del emulador por fin soporta la aceleración de GPU, necesaria para ejecutar aplicaciones que necesitan OPEN GL 2.0. Sigue leyendo

¡¡¡Normalízate!!!

¿Porqué respiramos? Respirar es algo normal que hacemos sin pensar. Parpadeamos sin darnos cuenta. Pues lo mismo debería pasar cuando vas a crear una tabla en una base de datos. ¿Cual es el primer campo que se añade a toda tabla? ... Si NO has pensado  una Clave Primaria auto numérica y auto incrementable, mejor será que esfuerces en no dejar de respirar. Sigue leyendo

El antipatrón “desenrollando switchs”

Las técnicas de desenrollado de bulces las usan los compiladores para optimizar el pipeline de los procesadores para aprovechar los huecos de las unidades funcionales disponibles y evitar que éstas estén ociosas y aumentando así el paralelismo del código consiguiendo de esta forma reducir el CPI.

Sin embargo nos empeñamos en una y otra vez todo ese conocimiento con código como este:

enum Axis
{
    XAxis,
    YAxis,
    ZAxis,
};
// code earlier in the function ensure that
// "axis" is always a valid axis
int newPosition;
switch (axis)
{
case XAxis:
     newPosition = m_position[XAxis] + amount;
     if (newPosition < m_minPosition[XAxis])
         newPosition = m_minPosition[XAxis];
     if (newPosition > m_maxPosition[XAxis])
         newPosition = m_maxPosition[XAxis];
     m_position[XAxis] = amount;
break;
case YAxis:
     newPosition = m_position[YAxis] + amount;
     if (newPosition < m_minPosition[YAxis])
         newPosition = m_minPosition[YAxis];
     if (newPosition > m_maxPosition[YAxis])
         newPosition = m_maxPosition[YAxis];
     m_position[YAxis] = amount;
break;
case ZAxis:
     newPosition = m_position[ZAxis] + amount;
     if (newPosition < m_minPosition[ZAxis])
        newPosition = m_minPosition[ZAxis];
     if (newPosition > m_maxPosition[ZAxis])
        newPosition = m_maxPosition[ZAxis];
     m_position[ZAxis] = amount;
break;
}

(me pregunto cuantas veces he escrito código así)

Empujados por saber que el código específico es más rápido que el código de propósito general, algunas veces no nos damos cuenta de que este mismo trozo de código se podría haber escrito de esta manera:

newPosition = m_position[axis] + amount;
if (newPosition &lt; m_minPosition[axis])
   newPosition = m_minPosition[axis];
if (newPosition &gt; m_maxPosition[axis])
   newPosition = m_maxPosition[axis];
m_position[axis] = amount;

Lo malo del switch primero que vimos es que no es fácil distinguir rápidamente si es un "error" del típico "copy&paste que queda nada para salir y me tengo que ir a casa" o hay algo escondido y sutil que hace de este código un ejemplo de libro.

Espero que os sirva.

Juan María Laó Ramos

Push Notifications en Cell·SDK

La semana pasada publicamos Cell·SDK 1.2 con un montón de nuevas características y algunas correcciones que hacen del desarrollo multiplataforma en iOS, Android y Windows Phone aún más sencillo.

En el post de hoy vamos a ver cómo enlazar lo que tenemos en el tutorial de Push notifications para Windows Phone y lo que podemos encontrar en la web de Microsoft sobre cómo mandar notificaciones a nuestros dispositivos.

Con el mismo código fuente que tenemos disponible en Github para la aplicación de ejemplo en el  dispositivo nos va a valer para este ejemplo.

Tenemos que tener en cuenta que debemos programarnos una pequeña aplicación/servicio para poder enviar notificaciones al servicio de notificaciones de Microsoft. Tal y como vemos en el diagrama y documentación de Microsoft:

Arquitectura Push

Nosotros tenemos que implementarnos el “Cloud Service” así que vamos a ver un ejemplo de cómo hacerlo según se indica aquí. De este último enlace sólo nos interesa la parte de “Sending a Toast Notification

Vamos a crear un proyecto de ASP.NET vacío y vamos a incluir cuatro controles TextBox y un botón para enviar la notifiación:

Página de envío

Ahora vamos a darle código al evento clic del botón:

protected void SendToast_Click(object sender, EventArgs e)
 {
 try
 {
 // Get the URI that the Microsoft Push Notification Service returns to the push client when creating a notification channel.
 // Normally, a web service would listen for URIs coming from the web client and maintain a list of URIs to send
 // notifications out to.
 string subscriptionUri = TextBoxUri.Text.ToString();

HttpWebRequest sendNotificationRequest = (HttpWebRequest)WebRequest.Create(subscriptionUri);

// Create an HTTPWebRequest that posts the toast notification to the Microsoft Push Notification Service.
 // HTTP POST is the only method allowed to send the notification.
 sendNotificationRequest.Method = "POST";

// The optional custom header X-MessageID uniquely identifies a notification message.
 // If it is present, the same value is returned in the notification response. It must be a string that contains a UUID.
 // sendNotificationRequest.Headers.Add("X-MessageID", "");

// Create the toast message.
 string toastMessage = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 "" +
 "" +
 "" + TextBoxTitle.Text.ToString() + "" +
 "" + TextBoxSubTitle.Text.ToString() + "" +

" " +
 "";

// Set the notification payload to send.
 byte[] notificationMessage = Encoding.Default.GetBytes(toastMessage);

// Set the web request content length.
 sendNotificationRequest.ContentLength = notificationMessage.Length;
 sendNotificationRequest.ContentType = "text/xml";
 sendNotificationRequest.Headers.Add("X-WindowsPhone-Target", "toast");
 sendNotificationRequest.Headers.Add("X-NotificationClass", "2");

using (Stream requestStream = sendNotificationRequest.GetRequestStream())
 {
 requestStream.Write(notificationMessage, 0, notificationMessage.Length);
 }

// Send the notification and get the response.
 HttpWebResponse response = (HttpWebResponse)sendNotificationRequest.GetResponse();
 string notificationStatus = response.Headers["X-NotificationStatus"];
 string notificationChannelStatus = response.Headers["X-SubscriptionStatus"];
 string deviceConnectionStatus = response.Headers["X-DeviceConnectionStatus"];

// Display the response from the Microsoft Push Notification Service.
 // Normally, error handling code would be here. In the real world, because data connections are not always available,
 // notifications may need to be throttled back if the device cannot be reached.
 TextBoxResponse.Text = notificationStatus + " | " + deviceConnectionStatus + " | " + notificationChannelStatus;
 }
 catch (Exception ex)
 {
 TextBoxResponse.Text = "Exception caught sending update: " + ex.ToString();
 }

Este código puede estar tanto en una aplicación web, una aplicación de Windows forms, un servicio de Azure, etc…

Tan sólo tenéis que montarlo, desplegar la aplicación de ejemplo de github en el dispositivo ó en el emulador y copiar el Channel ID que saldrá en la ventana de Output de Visual Studio:

Channell ID en Visual Studio

Este código lo introducimos en la página web que hemos creado en el textbox primero y recibiremos en el dispositivo o emulador una notifiación Toast:

Toast Notification

Hay tres tipos de notificaciones para Windows Phone que podemos enviar:

  • Toast: Con documentación y ejemplos aquí
  • Tile: Con documentación y ejemplos aquí.
  • Raw: Con documentación y ejemplos aquí.

Os recomiendo que probéis a enviar otro tipo de notificaciones, en este ejemplo hemos usado el ejemplo de envío de notificaciones Toast.

Para ver el código fuente de la aplicación y cómo es la API Unificada para Android, iOS y Windows Phone de Cell·SDK no tenéis más que pasaros por aquí

Espero que os sirva.

Juan María Laó Ramos.

Lanzamos Cell·SDK1.1

Hace unos días publicamos la nueva versión de Cell·SDK. Podéis descargarlo totalmente gratis y probarlo aquí.

En esta versión hemos incluido un montón de nuevas características que nos facilitan aún más la vida y podéis verlas aquí. Entre otras características nuevas tenemos:

-          Status API: Esta API unifica la forma de acceder a la información de todos los dispositivos Android, iOS y Windows Phone, como por ejemplo al estado de la batería, el ID del dispositivo, la plataforma y un largo etcétera. Podéis descargar Cell·SDK ahora y aprender cómo usarlo en el tutorial de la Status API aquí.

-          Acceso a la cámara: Ahora podemos jugar de manera unificada en todas las plataformas con el nuevo sensor de cámara de una manera sencilla. Leed el tutorial, es muy sencillo.

-          Sistemas de análisis: Hemos incluido una API preparada para integrar diferentes sistemas de analítica para poder ver cómo los usuarios usan las aplicaciones. A día de hoy tenemos disponible la opción que ofrece Localytics pero pronto habrá más. Aquí podéis aprender a usarlo.

Aún hay más características nuevas pero en el post de hoy vamos a ver en detalle las nuevas funcionalidades añadidas con el ScreenManager.

Y es que a la hora de hacer un juego o aplicación es muy importante ofrecer una forma atractiva de crear los diferentes menús que vamos a mostrar. Con la experiencia y el feedback que nos habéis aportado hemos decidido incluir este ScreenManager que muchos os lo habréis implementado varias veces. Pues ahora ya no tenéis que implementarlo ya que lo ofrecemos de fábrica.

El uso es bien sencillo, para verlo en acción descargaos el ejemplo que tenemos en GitHub llamado ScreenManager aquí.

Vamos  a ver el código:

En la clase StaticContent tenemos una nueva variable estática llamada ScreenManager. Esta variable es la que nos va a permitir pasar de una pantalla (o Screen) a otra en nuestro juego o aplicación. Consiste en una colección de las diferentes pantallas que vamos a tener disponibles y que debemos ir añadiendo para poder ir de una pantalla a otra.

Cuando creamos un proyecto nuevo con la plantilla de Cell·SDK se crea la primera pantalla MainScreen.cs y se añade a esta colección por defecto en el archivo Application.cs

///
<summary> /// The main method for loading controls and resources.
/// </summary>
public override void Initialize()
{
    base.Initialize();

    StaticContent.Graphics.IsFullScreen = true;
    StaticContent.Graphics.ApplyChanges();

    StaticContent.ScreenManager.GoToScreen(new MainScreen());
}

Vamos a ver cómo se usa directamente en la clase MainScreen del ejemplo. En la clase MainScreen.cs hemos definido unas cuantas variables del tipo Image que nos permitirán cargar los diferentes recursos del ejemplo para usarlo luego  como fondo de pantalla y como imágenes de los botones que tendremos en nuestra aplicación.

Pantalla de Inicio

Pero lo que realmente nos interesa es el uso de la variables StaticContent.ScreenManager así que veamos los eventos de release de los diferentes botones. Empezemos por el botón de opciones:

///
<summary> /// Go to options screen.
/// </summary>
///
private void bOptions_Released(Component source)
{
    StaticContent.ScreenManager.PushScreen(new OptionsScreen(), StaticContent.TransitionFactory.FadeBlackTransition);
}

Estamos añadiendo al ScreenManager una nueva pantalla, en este caso la de opciones, y con una transición FadeBlackTransition.Hay un montón de transiciones y añadiremos más en un futuro.

Ahora, en la pantalla de opciones (OptionsScreen.cs):

Pantalla de Opciones

Para seguir el flujo de navegación que estamos haciendo hemos añadido un botón para volver al a pantalla de inicio y en el evento Pressed hemos hecho un PopScreen, para eliminar la pantalla de la colección:

public override void BackButtonPressed()
{
    StaticContent.ScreenManager.PopScreen(StaticContent.TransitionFactory.FadeBlackTransition);
}

¡También con una transición!

Resumen

Hemos visto cómo podemos añadir diferentes pantallas a nuestra aplicación de una manera muy sencilla. Con este ScreenManager ya no tenemos que implementarnos nosotros mismos este tipo de mecanismos. Además tenemos un conjunto de transiciones por defecto bastante interesante que cubre la mayoría de efectos que podemos añadir a la hora de pasar de una pantalla a otra.

Os animo a que os descarguéis el código y probéis las diferentes transiciones que vienen por defecto y si tenéis alguna sugerencia sobre alguna transición que creéis podría aportar valor a las que ya vienen por defecto no dudéis en abrir un hilo en el foro sobre ello y lo estudiaremos.

Espero que sirva.

Juan María Laó Ramos (sígueme en twitter @juanlao)

Resumen Open Space Sevilla

Open Space SevillaHa sido un placer compartir las poco más de 16 horas del fin de semana pasado con tantos Profesionales, con mayúsculas y en negrita, hablando sobre tecnologías webs, metodologías, testing, seguridad, arquitecturas, tablets, marketing, usuarios (flame: esos malditos bastardos), organizaciones, jefes, clientes. Y mejor paro aquí.

Lo mejor del evento ha sido, sin dudarlo en ningún momento, el haber podido asistir.

Si me lo permitís os pondré un pequeño resumen de cada una de las sesiones a las que asistí y las conclusiones que saqué:

  • Seguridad: Pues, al igual que la calidad no es negociable. Los sistemas que diseñamos o implementamos deben tener en cuenta la seguridad desde el comienzo hasta el fin. Para evitar el “ya os lo dije” y asegurarnos una posición con respecto a nuestros competidores. Como dije al principio, es igual que la calidad, no es negociable. Sobre todo a la hora de usar frameworks o herramientas de terceros, debemos auditarlas.
  • Adicto al verde: Si, adicto a que los test que hacemos se pasen, pero claro, para ello hay que hacerlos. Ya sean unitarios, de integración, etc … Yo defino el arte del testing  como un seguro para no acabar en alcohólicos anónimos después de dos intentos fallidos de puesta en producción, y la calidad en principio da igual, lo que quiero es vivir tranquilo y llegar a casa a una hora decente y con la sensación de un trabajo bien hecho.
  • Garajes en Andalucia: Jmbeas quería saber cómo estaba el tema de los emprendedores en Andalucía y se enteró ;) . Por lo que vimos no está extendida la cultura del pelotazo, sino la del “quiero lo suficiente como para poder sacar al perro por las mañanas”. Manuel Recena ha resumido muy bien y lo comparto. Espero que nadie lo entienda como una falta de ambición, es todo lo contrario, plantear un plan de negocio basado en un pelotazo es como correr con el coche a 120 por las calles de una urbanización, te la vas a pegar, te vas a hacer daño y lo peor de todo es que vas a hacer daño a mucha más gente.
  • Yo te la mido (La campaña):  Nos presentaron http://twittalicious.com/ una herramienta opensource para análisis de métricas sobre twitter y conocer el impacto de una persona, campaña, empresa  en esta red social. La verdad es que no está nada mal.
  • Rendimiento de aplicaciones PHP: Un debate/charla, en la que vimos una arquitectura bastante completa y buscamos entre todos cómo podríamos mejorarla con componentes y herramientas que nos ayudan según qué eslabón de la cadena queremos optimizar.  Me gustó particularmente ya que el enfoque de cómo mejorar se puede aplicar a cualquier otra tecnología como .NET, Java, Ruby, etc..
  • “Trucos” para rentabilizar un blog: En esta fuimos poquitos, y es que los frikis trabajamos por amor al arte ;) .  Sin embargo estaba bastante interesado y surgieron muchas ideas: desde buscar anunciantes en otros blogs de la misma temática que el tuyo, ponerte en contacto con el anunciante y ofrecerte, montar una tienda online de algo relacionado con tu blog y buscar tus proveedores, buscar empresas que mantengan redes de blogs y proponer, por ejemplo, que te hosteen el blog a cambio de generar contenidos y un porcentaje de la publicidad.
  • Inspección continua: Vimos cómo integrar Jenkins, Maven y Sonar para hacer que en cada commit del subversión/github se lancen procesos de análisis estático de código vigilando que se cumplen las métricas que estimemos necesarias. Un par de conclusiones que me gustaron mucho son:  1 esta información se puede usar en las sesiones de revisión de código para seleccionar  aquellas clases que incumplan más métricas como candidatas a analizar y 2 si introduces un sistema de este tipo en un proyecto que ya ha comenzado, más te vale relajar alguna regla e ir poco a poco corrigiendo y manteniendo las métricas tal y como están para por lo menos no empeorar.

De nuevo gracias a tod@s por compartir vuestras experiencias y a la organización por este evento tan espléndido.

Juan María Laó Ramos.

Aliasing en formas geométricas

Aquí tenéis la octava entrega de la serie sobre aliasing

En el post de Multisampling vimos que la GPU "era lenta", así que el procesado de triángulos también. Las formas curvas complejas se aproximaban por un pequeño número de triángulos, donde cada uno de ellos era lo suficientemente grande como para cubrir varios píxeles de la pantalla.

 Esto creó una situación extraña en los primeros artículos sobre multisampling que se centraban en cómo suavizar los dientes que le salían a los triángulos. Nos acostumbramos tanto a esa forma de ver gráficos que hasta nos parecía hermoso, sin siquiera pararnos a pensar "¡Hey, la cabeza de este tipo sólo tiene 5 triángulos!"

Pero el hardware mejoró. El número de triángulos subió. Un juego moderno usa entre 4000 y 6000 triángulos para un personaje.

Fijaos en la situación:

  • El personaje se pinta de manera que ocupa 1/8 del alto de la pantalla.
  • El juego se renderiza a 720p, así que la imagen resultante es de 90 píxeles de alto.
  • Es decir que se cubren unos 2000 píxeles de la pantalla.
  • Suponiendo que la mitad de los triángulos están detrás de la cara.
  • Tenemos 3000 triángulos en total, cubriendo tan sólo 2000 píxeles de la pantalla.

Con tanto detalle en nuestros modelos, la geometría facial es algo del pasado. En su lugar tenemos un nuevo problema: ¡Hemos sido Nyquistados!

Recordad: para evitar el aliasing debemos tomar al menos dos veces más muestras de salida según la frecuencia más alta de la señal de entrada. Pero resulta que tenemos menos píxeles de salida que triángulos de entrada. Es bastante obvio que esto va a causar aliasing. Con menos píxeles que triángulos, algunos triángulos no aparecerán en la imagen de salida:

Juanma Pixelado

A medida que el objeto se mueva, los triángulos que sean afortunados y tengan un pixel irán cambiando aleatoriamente, así que la imagen se irá distorsionando a medida que los triángulos vayan apareciendo y desapareciendo.

En realidad existe un truco para suavizar el número de triángulos que un modelo debe contener. Para la mejor calidad, querremos que cada triángulo cubra exactamente dos píxeles de pantalla. Si los triángulos son más pequeños que esto, cruzaremos el límite de Nyquist y aparecerá el aliasing. Si son mayores, tu silueta saldrá "poligonizada".

NO es totalmente intuitivo que el truco sean dos píxeles por triángulo en lugar de uno, pero es verdad. Imaginad un círculo que es aproximado por una serie de segmentos de líneas. A medida que incrementamos el número de segmentos, el círculo se vuelve más y más perfecto. El momento en el que cada segmento va alcanza la longitud de dos píxeles, el círculo se convierte en perfecto. Por lo que añadir más segmentos a partir de aquí no hará ninguna mejora sobre la curva del círculo.

No es práctico tampoco mantener todos los triángulos con el mismo tamaño en la pantalla, ya que nuestro modelo se tiene que pintar a diferentes tamaños a medida que el jugador se mueve por el mundo.

Así que ¿cómo podemos pintar una geometría con muchos detalles sin tener aliasing?

Multisampling (o supersampling si podemos permitírnoslo) nos ayuda a alejar de nosotros el límite de Nyquist, pero sólo con eso no es suficiente para evitar el aliasing en geometrías.

Normalmaps puede ser una técnica poderosa. Tenemos bastantes opciones para evitar el aliasing cuando reconstruimos texturas, de manera que cada vez que podamos tendremos qie eliminar los detalles de nuestra geometría y reemplazarla con un normalmap, que nos ayudará a controlar el aliasing. Solemos pensar que estas técnicas de normalmaps son tan sólo una optimización del rendimiento (reemplazando geometrías caras con una textura) pero también pueden mejorar la calidad visual.

Por último, es importante considerar que el nivel de detalle del modelo puede variar. Cuando el objeto está muy lejos, cambiar un modelo de 6000 triángulos por uno más simple de 1000 o 500 triángulos es una opción que no sólo aumentará el rendimiento, sino que reducirá el efecto de aliasing en geometrías.

Moraleja: cuando hablamos de números de triángulos, más no siempre es lo mejor. Ten cuidado de no pintar más triángulos de los píxeles que ves en pantalla. Ese camino lleva al mundo del aliasing.

Artículo original.

P/D: Síguieme en twitter: @juanlao

Nuevo aspecto

Hola a tod@s.

Después de unos días buscando inspiración y sacando al artista que llevo dentro os presentamos el nuevo aspecto de este amado blog.

Ahora más participativo, más bonito, más todo.

Pero aún no acaba la cosa, esto es sólo el principio. Estad atentos ya que incluiremos nuevas funcionalidades más 2.0.

Gracias a los chicos de Mecus por su inestimable ayuda y profesionalidad.

Mecus

ASP.NET Web API (Parte 1)

Hace poco anuncié la release de ASP.NET MVC 4 Beta. ASP.NET MVC4 es una actualización con un montón de nuevas características. Una de las características que más me gustan es el soporte para crear "Web APIs". En este post es el primero de unos cuantos en los que veremos cómo aprovecharnos de esta nueva funcionalidad. Sigue leyendo

Cell·APP Awards

No debe ser nuevo para vosotros Cell·SDK, un nuevo framework para crear aplicaciones multiplataforma en el que hemos trabajado durante mucho tiempo y que hace poco os presentamos.

Hoy lanzamos un concurso para animaros a todos a probarlo y conseguir fantásticos premios. Presentamos

Cell·APP Awards

Cell·APP Awards

Tan sólo tenéis que descargarlo  y empezar a programar la aplicación o juego que tengáis en mente, pero tened en cuenta una cosa, cuando lo hagáis, será totalmente multiplataforma, es decir, programaréis el juego no sólo para una de las plataformas más extendidas, sino que lo tendréis listo para desplegar en iOS, Android y Windows Phone. Algo que no muchos pueden decir.

Una vez que los descarguéis sólo tendréis que "aprender" a usarlo. Y lo pongo entre comillas porque es realmente fácil, gracias a la potencia que ofrece C# y a los fantásticos tutoriales y ejemplos que tenemos disponibles es realmente fácil.

El concurso comienza el 1 de Marzo y tenéis toda la información disponible aquí.

Si todavía te lo estás pensando, presta atención a los premios:

 1º Premio: Licencia CellSDK Starter + Ipad2 + Nokia Lumia 800 + $250 Publicidad Inmobi + Promoción en MarketPlace (Microsoft)

2º Premio: Licencia Starter CellSDK + Nokia Lumia 800 + $150 Publicidad Inmobi

3º Premio: Licencia Starter CellSDK+ Nokia Lumia 800 + $100 Publicidad Inmobi

4º Premio: Licencia CellSDK Basic + $75 Publicidad Inmobi

5º Premio: Licencia CellSDK Basic + $75 Publicidad Inmobi

¿De verdad que te lo estás pensando todavía?

Resumiendo, increíbles premios, tutoriales, ejemplos y un foro donde poder preguntar dudas sobre el desarrollo de Cell·SDK.

Espero veros por los foros y ... que gane el mejor ;-) .

P/D: Sígueme en twitter @juanlao.

 

ASP.NET MVC 4 Beta

Hace unos días publicamos ASP.NET MVC 4 Beta. Es una release importante ya que viene con un montón de nuevas características.

ASP.NET MVC 4 Beta funciona con VS 2010 y .NET 4.0, y es compatible con instalaciones de versiones anteriores de ASP.NET MVC (es decir, podéis instalarla sin tener que preocuparos por el posible impacto que pueda tener en las aplicaciones que ya tenéis desarrolladas con otras versiones). La publicamos bajo la licencia "go-live" que os permite crear y desplegar aplicaciones en producción con ella. Haced clic aquí para descargarla e instalarla desde ya. Sigue leyendo