Agregador de noticias

Ever feel the need to use the apps already on on your mobile device instead of the work approved ones from your IT department? LogMeIn has developed a tool called AppGuru to help those IT teams organize the mobile apps people can’t seem to resist bringing to work.

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

Además de la Xbox One, Microsoft ha presentado los servicios asociados a la consola. Además de los contenidos multimedia, que por desgracia no disfrutaremos en España debido a la exclusividad de los acuerdos y la localización de los contenidos, los de Redmond han presentado el nuevo Xbox Live.

En las anteriores plataformas, fue el centro de toda la experiencia de juego online y esta vez tendrá un papel más importante todavía. Estos ocho años de Xbox 360 han servido para tomar nota e introducir unas cuantas mejoras bastante sustanciales.

Una de las principales mejoras de esta nueva Xbox gira entorno a la nube. Cada usuario tendrá su espacio en la nube donde podrán subir partidas, contenidos multimedia y otras funciones bastante atractivas como vídeos que grabamos de nuestras partidas. De momento, eso sí, no han hablado sobre la conexión de esta última función con las redes sociales.

Lo que tampoco se ha especificado de momento es la capacidad de almacenamiento con la que contará cada usuario. Lo único que sabemos es que Xbox Live funcionará bajo 300.000 servidores dedicados. Una cifra bastante alta que pone de manifiesta que para Microsoft la experiencia online también es importante.

Otro punto a favor es la posibilidad de guardar partidas en la nube. Ahorramos almacenamiento en el disco duro, aunque normalmente son archivos que ocupan poco tamaño, y podemos sincronizar nuestras partidas en diferentes consolas. En principio además todo apunta a que se mantendrá el modelo gratuito con restricciones y la suscripción mensual o anual.

También se han introducido mejoras en una de las señas de identidad de Xbox: los logros. Esta vez, los desarrolladores podrán introducir logros sin necesidad de hacerlo a través de los DLC. En principio, parece que se irán adaptando a nuestra forma de jugar por lo que el desarrollador podrá enviarnos nuevos retos.

Los logros además, parece que irán más allá de la consola y podremos conseguirlo utilizando otras plataformas como dispositivos móviles o el navegador. De momento, Microsoft no ha dado más detalles al respecto por lo que tendremos que esperar al E3 para tener más información y cómo lo van a utilizar los desarrolladores.

El match making también ha mejorado y se han introducido pequeños detalles muy útiles como darnos un tiempo de espera estimado cuando estamos esperando para meternos en una partida. Además, podremos esperar en segundo plano mientras vemos otra cosa en Xbox como la televisión.

Otra novedad bastante importante es el sistema de descargas. Al igual que en PlayStation 4, podremos jugar antes de que se acabe de bajar todo el contenido. Se irá bajando en paquetes respetando el orden en el que se juega, bien pensado para cuando bajamos un juego completo.

Google acaba de lanzar la versión estable de Chrome 27 para Windows, Mac y Linux. Se trata de una actualización dirigida especialmente al rendimiento y optimización del navegador, mejorando la velocidad de carga de páginas hasta un 5 % como principal novedad.

Además de dicha mejora en la optimización de páginas Web que permite la reducción del tiempo de espera, se ha añadido la nueva API “Sync FileSystem“ para desarrollares, así como 14 correciones en la seguridad del navegador.

El lanzamiento de Chrome Beta el pasado mes contenía optimizaciones para que las páginas web se cargaran un 5% más rápido de media. Hoy hemos incluido estas optimizaciones en la versión estable de Chrome para que todos los usuarios puedan disfrutar de una experiencia de navegación más rápida.

Si es cierto que la mejora del 5 % en la velocidad de carga de sitios puede parecer poco pero, si sumamos esos pocos segundos y lo multiplicamos por todas las páginas que visitamos al día, puede suponer unos minutos ahorrados de espera al día.

Como es normal y habitual cada vez que se lanza una nueva versión de Chrome, se puede aplicar directamente desde el menú Ayuda del navegador o realizando una nueva instalación desde el sitio oficial de descarga. Así mismo, la versión beta de Chrome 28 ya está disponible.

ACTUALIZACIÓN. Con Chrome 27 se activa automáticamente la búsqueda por voz en Google, presentado en el pasado evento I/O 2013.

Fuente | Google Blog – TheNextWeb
Descarga | Chrome 27

Balancing the demands of digital marketing isn’t easy, especially if you’re the chief marketing officer. What makes you most successful? No one can deny that leveraging big data to build solid relationships customers is key, but according to a new report by Forrester, most CMOs believe it’s actually an enterprise-wide commitment to brand building that is critical to success. 

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

The customer experience is still a work in progress. We know that as social and mobile technologies become more advanced, the challenge isn’t necessarily about deploying them, it’s about getting them to seamlessly align alongside human capabilities. The mobile coupon fails to get scanned at checkout. The opportunity to enroll customers in a rewards programs is missed. Consumers receive irrelevant promotions that don’t meet their interests or activities. What if there was a better way to improve the customer experience without having to upgrade the human experience?

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

The current definition of the Customer Journey seems to consist of some version of Consider/Awareness leading to Research/Evaluate, and then to Purchase. Some models include the Out Of the Box Experience (OOBE) followed by Usage after Purchase. I particularly appreciate models that include those two pieces, as they take into account that the customer’s experience needs to be favorable for some time after the purchase. Most customers are not in the market for the next new thing as soon as they purchase one (if so, there’s something wrong with the product!)

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

No es la primera vez que hablamos sobre motores gráficos, ni tampoco es la primera vez que mencionamos a Unity, uno de los mejores conjuntos de herramientas para desarrollo de juegos en 3D del mercado.

Pues bien, buenas noticias para nosotros, los usuarios, pues Unity Technologies acaba de anunciar que pondrá a disposición de los desarrolladores independientes sus herramientas de desarrollo bajo Unity de manera gratuita, y además para todas las principales plataformas móviles: iOS, Android, Windows Phone 8 y Blackberry 10.

Por si esto fuera poco, la licencia para publicar juegos basados en Unity pasará a ser gratuita también, desde los 800 dólares que costaba anteriormente.

Unity Technologies ha comunicado oficialmente la noticia, confirmando que además los desarrolladores que habían adquirido la licencia anteriormente recibirán una compensación.

La propia Unity lo resume asegurando que siempre han querido ayudar a los desarrolladores haciendo accesibles las mejores herramientas a más gente, para que puedan hacer realidad sus ideas creativas y construir sus propios negocios. Así, nosotros no tenemos más que aplaudir el movimiento y esperar que muchos desarrolladores que antes no tenían recursos lleguen ahora a Android para traernos lo mejor de su trabajo.

En Xataka Android | El motor gráfico Frostbite de EA Games llegará a dispositivos móviles
Más información | Unity

Microsoft acaba de presentar su nueva consola de videojuegos, la Xbox One, que quiere convertirse en un sistema con el que controlar tanto los juegos como el ocio de nuestro hogar.

Muchas son las novedades de una consola que quiere mantener a Microsoft como referencia del mercado. Pasemos a descubrir todos los detalles de una ambiciosa consola que quiere convertirse en el centro de nuestra experiencia de ocio y entretenimiento.

La Xbox One con nombre en clave Durango llega once años y medio después de la llegada de la Xbox original y siete años y medio después de la llegada de la Xbox 360. El ciclo de renovación de su último modelo ha sido especialmente largo, pero eso ha demostrado la validez de una propuesta que ahora se renueva con novedades importantes en todos los ámbitos.

El hardware interno a examen

El potencial técnico de la Xbox 360 se ha demostrado durante años: la elección de los componentes fue un acierto y eso ha permitido sacarle todo el juego a la consola con títulos que no han perdido su espectacularidad técnica en todos estos años. Así pues, el reto a nivel hardware era importante: ¿qué componentes elegir para garantizar un ciclo de vida tan largo como el de su predecesora?

En Redmond se han decidido por centrar ese hardware en una APU octo-core de AMD (una versión de su procesador con la recién presentada arquitectura “Jaguar”), un procesador con arquitectura de 64 bits, fabricado con escala de integración de 40 nm, y que funciona a 1,6 GHz, además de tener una caché de nivel 2 de 4 MB. A esa CPU le acompaña una GPU a 800 MHz y con soporte DirectX 11, además de otros bloques hardware que gestionan ciertos tipos de tareas y que alivian así la carga del procesador principal.

Según los responsables de Microsoft, la potencia gráfica de la Xbox One es 8 veces superior a la de la Xbox 360, algo que se ve afectado, entre otras cosas, por esa GPU que integra 10 veces más transistores que la GPU de la Xbox 360: 5.000 millones de transistores frente a los 500 de la anterior generación de GPUs usadas en las consolas de los de Redmond.

Los 8 Gbytes de memoria DDR3 son otro de los elementos importantes de una concepción que como sucedía en el caso de la Xbox 360 y de la Xbox original se asienta sobre el conocido esquema del PC, un esquema que sigue manteniendo su validez y en el que también entran en juego el Northbridge (para conectar CPU, GPU y memoria principalmente) y el Southbridge (que interconecta la red GbE, la conectividad Wi-Fi Direct, los mandos, los puertos USB 3.0, o el disco duro, entre otros).

Precisamente en cuestión de puertos y conectividad contaremos con una selección que en esencia es muy similar a las actuales Xbox 360, que ya cumplían de forma sobresaliente en este aspecto. Así, además de la conectividad Wi-Fi Direct 802.11 a/b/g/n tendremos un puerto Gigabit Ethernet, puertos USB 3.0, entrada (más sobre esto más adelante) y salida HDMI 1.4a, y salida S/PDIF.

Pero sobre todo la novedad destacada será la inclusión de una unidad Blu-ray con soporte para discos de 50 GB y que tras el fracaso de la apuesta por HD-DVD en la Xbox 360 ayudará a la nueva consola de Microsoft a cumplir con garantías también en otro terreno muy importante para Microsoft: el del entretenimiento con contenidos de vídeo.

El reconocimiento de voz, protagonista

Si algo nos dejaron claro nada más comenzar la presentación es que el reconocimiento de voz será importante en la nueva Xbox One, ya que de hecho con una orden de voz se puede encender la consola.

A partir de ese encendido, existen todo tipo de comandos para ir activando distintas funciones de la consola, como el salto de un tipo de tarea a otra con órdenes claras y sencillas que son fáciles de recordar y que permitirán evitar el mando de juegos o el control remoto en muchas ocasiones.

Durante la demostración se comprobó como el cambio entre una tarea y otra era instantáneo incluso con órdenes de voz, rápidamente reconocidas y con una eficiencia total. A ese “instant switching“ del que hablaban de Microsoft se añadía otra novedad: el llamado Snap Mode, que nos recuerda al presente en los Microsoft Surface con su versión de Windows 8.

Con Snap Mode es posible poder mostrar dos aplicaciones al mismo tiempo, por ejemplo una emisión televisiva o película, y, en la parte derecha y ocupando algo menos de espacio, una instancia de Internet Explorer en la Xbox One. Una forma interesante de aprovechar aún mejor esa nueva capacidad de multitarea que ofrece el nuevo sistema operativo de la Xbox One.

En este apartado también es importante englobar a Skype, una aplicación nativa en las nuevas Xbox One que se puede lanzar en cualquier momento y que en todo momento ofrece la posibilidad de realizar llamadas de grupo, con notificaciones que se muestran en nuestro Dashboard.

Juegos, juegos, juegos

Por supuesto, poco sentido tiene un lanzamiento como este sin estar acompañado de juegos que logren demostrar el potencial de la plataforma. Como ha revelado el director de la división de entretenimiento interactivo de Microsoft Aaron Greenberg en el podcast del Major Nelson hace unas horas, las noticias al respecto se desvelarán esencialmente en la feria E3. Greenberg lo indicó claramente en dicho podcast:

Tenemos tanto bueno que contar que no hay forma de reunirlo todo en un solo evento. La mejor forma de explicarlo es indicando que habrá dos eventos. Comenzaremos el 21 de mayo y en esa parte realmente nos dedicaremos a descubrir la próxima plataforma Xbox y nuestra visión para el futuro de los juegos y el futuro del entretenimiento. Tenemos un montón de sorpresas planificadas.

En el evento de presentación de la Xbox One pudimos ver demostraciones de varios juegos, con protagonismo especial para una alianza con Electronic Arts que dio algunos avances sobre cuatro de sus lanzamientos para Xbox One: FIFA 14, Madden NFL 25, NBA Live 14 y UFC.

También estuvieron presentes otros juegos que inaugurarán el catálogo de la nueva consola de Microsoft, como Forza Motorsport 5, Quantum Break (de Remedy, creadores de Max Payne y Alan Wake), y con un cierre especialmente esperado que mostró en primicia mundial un trailer de Call of Duty: Ghost, la nueva entrega de la franquicia CoD.

Los responsables de Microsoft quisieron destacar este apartado indicando que Microsoft Studios lanzará más de 15 juegos en exclusiva, ocho de ellos originales, para la Xbox One durante el primer año de vida de esta nueva consola.

Las grandes dudas sobre los juegos de la Xbox One

Dato importante el que afecta al requisito obligado: todos los juegos deberán ser instalados en disco duro antes de poder ser jugados, tal y como indicaban en Wired, confirmándose así los rumores que apuntaban a este requisito como una de las novedades de la nueva consola.

En dicho reportaje también se habla de los juegos de segunda mano: cada juego estará asignado a una cuenta de Xbox, y si queremos usar un juego con una segunda cuenta, tendremos que pagar una comisión y instalar el juego desde el disco en esa nueva consola y para esa nueva cuenta.

Otro detalle importante y esperado: los juegos de la Xbox 360 no serán compatibles con la Xbox One. Los responsables de Microsoft han indicado que “el sistema está basado en una arquitectura distinta, así que la compatibilidad hacia atrás no es posible en ningún sentido“.

En este apartado no parece que Microsoft vaya a proporcionar una especie de servicio de emulación que permite aprovechar esos viejos juegos, entre los que también estarán incluidos los de Xbox Live Arcade. El salto a la nueva generación de consolas será muy duro, pero en cierto modo un cambio de esta escala hace lógicas este tipo de decisiones.

Kinect también se renueva

Una de las claves de la Xbox One será la inclusión obligatoria de Kinect en todas las nuevas consolas de Microsoft. Este periférico ha sido definido como “esencial y parte integral de la plataforma“, algo que permitirá a los desarrolladores decidir si quieren ofrecer ese soporte sabiendo que todos los usuarios de Xbox One podrán aprovecharlo.

La nueva cámara integrada en el nuevo sensor Kinect —que también cambia de diseño— ofrece grabación de vídeo 1080p y que gana en ángulo visual en un 60%. La cámara es capaz de capturar vídeo a 60 FPS, pero lo realmente impresionante es su precisión, con capacidad para diferenciar seis jugadores simultáneos en lugar de los dos del periférico actual.

Mientras que el sensor original localizaba a las personas a través de la llamada “luz estructurada“, que a través del uso de luz infrarroja creaba un mapa con profundidad 3D, pero ese mapa era de baja resolución y varios detalles eran muy poco precisos e incluso imperceptibles.

En el nuevo modelo se usa un rayo de luz infrarroja modulada, y se mide el tiempo que los fotones tardan en volver a través de la tecnología “time-of-flight“, que permite reconocer formas de forma mucho más potente.

Temas como el reconocimiento de voz también se han mejorado como se demostraba en las demos en las que toda la interfaz se controla a través de órdenes directas tanto en la interfaz como en los juegos.

En el tintero quedan algunos proyectos de los que se hablaba en una filtración en junio del año pasado, como por ejemplo Kinect Glasses (Project Fortaleza), un dispositivo similar en cierta medida a Google Glass y que ofrecería gafas de realidad aumentada conectadas a la consola y que teóricamente podrían llegar en 2014. Tampoco parece que tendremos de momento noticias de IllumiRoom, que nos mete aún más en los juegos al proyectar sobre la habitación en la que jugamos todo tipo de formas y luces.

La multitarea llega a la Xbox

Aunque el soporte de la multitarea en sistemas operativos convencionales e incluso en sistemas operativos móviles no es una novedad, dicha función no había llegado aún a las consolas, pero en Microsoft han preparado una característica que aportará cierto nivel de multitarea a las nuevas Xbox.

Así, será por ejemplo posible ejecutar varios juegos y aplicaciones al mismo tiempo, estando tan solo una activa en pantalla pero con la diferencia de que el resto seguirá ejecutándose. Por ejemplo, podremos jugar a un juego y tener una sesión de Twitter abierta en segundo plano a la que podremos volver en cualquier momento.

Más que nunca, a por nuestro salón

La consola de Microsoft lleva tiempo apostando no solo por el segmento de los juegos, sino también por el del entretenimiento, con un catálogo de contenidos de audio y vídeo cada vez más interesante para los usuarios incluso en nuestro país, a pesar de que la oferta en Estados Unidos es mucho más versátil.

Esa oferta crecerá ahora con la inclusión de un puerto de entrada HDMI que permitirá convertir a la consola en un set-top-box completo al que conectar otros dispositivos —por ejemplo, sintonizadores de TDT o de televisión por cable— para que la nueva Xbox ofrezca también funciones de PVR.

Uno de los apartados destacados en esta función es la inclusión de una guía de programas (Xbox Guide) que permite conocer la parrilla televisiva y que también da acceso a los contenidos favoritos, como por ejemplo canales o series que nos gustan especialmente.

Ese puerto de entrada convierte a la Xbox en una pasarela, como los antiguos vídeos VHS por ejemplo, en los que la señal de antena llegaba al vídeo, que a su vez estaba conectado a la televisión. La función de la Xbox será esencialmente la misma, pero a partir de ahí aparecerán funciones muy interesantes, como esas funciones de grabación y por supuesto la posibilidad de ver la televisión en segundo plano mientras usamos la Xbox en primer plano para jugar, navegar por Internet o conectar con conocidos vía Skype.

La conexión a Internet será opcional, no obligatoria

Uno de los apartados que más rumores ha generado en torno a la nueva consola de Microsoft era el de si sería necesario tener la consola permanentemente conectada a Internet para poder utilizarla. Fuentes cercanas a la empresa indicaron que esa conexión a Internet sería obligatoria en todo momento, algo que otras fuentes negaron semanas más tarde.

Microsoft ha confirmado que la conexión a Internet no será necesaria todo el tiempo, algo a lo que ya la empresa ya había apuntado en comentarios previos, lo que significa que podremos seguir utilizando la consola para jugar sin estar conectados. En comentarios oficiales en la web oficial de este desarrollo lo dejan claro:

No tendrá que estar siempre conectada […]. Estamos diseñando la Xbox One para ser tu sistema de entretenimiento completo que esté conectado a la nube y siempre disponible. También la estamos diseñando para que puedas jugar a juegos, ver películas de Blu-ray y ver la TV en vivo si pierdes tu conexión.

Curiosamente, la decisión sobre si un juego necesitará conexión a Internet (incluso en modo de un solo jugador, no multijugador) la tomará la empresa desarrolladora del juego, ya que Microsoft ofrecerá ambas posibilidades.

Precio y disponibilidad

La Xbox One estará disponible a nivel global “en los próximos meses“ (sin más datos), y es más que probable que ese lanzamiento se produzca a finales de año, coincidiendo con la etapa previa a las vacaciones navideñas que es en el que se producen los mayores picos de ventas de consolas.

Microsoft no ha ofrecido datos sobre el precio al que se venderá este dispositivo, un dato que revelará más adelante.

Galería de fotos (Haz click en una imagen para ampliarla)

Oracle may have outlined how the inability to break-down information silos was negating many of the positive benefits of the cloud yesterday, but today Forbes highlights yet again the business value of the cloud, particularly in facilitation with effective enterprise collaboration.

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

 Digital marketers have a strong interest in tuning and optimizing the search experience, which is why Sitecore has given search a front row seat in Sitecore 7.

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

Cuando Twitter compró Tweetie en 2010, no sólo se hicieron con uno de los clientes para Mac e iOS más prometedores hasta la fecha, sino que además en el pack venía una tecnología interesante: el push-to-refresh o “deslizar para actualizar”, que en su día desarrolló Loren Brichter, fundador de Tweetie, y que en la actualidad se puede ver en muchas aplicaciones para dispositivos móviles.

Hoy, tres años después, la patente de este gesto se ha otorgado finalmente a Twitter, que ha aprovechado para estrenar su nuevo Innovator’s Patent Agreement. ¿Qué significa esto? Que Twitter se compromete a utilizar esta patente sólo de forma defensiva y que cualquier acción que se pueda llevar a cabo en el futuro tendrá que tener la aprobación del creador original de la tecnología en cuestión, en este caso Loren Brichter.

¿Quiere decir esto que de momento, y a pesar de la patente, los desarrolladores pueden estar tranquilos? Parece que sí, desde Twitter aseguran que esto es sólo un “escudo” de cara a posibles demandas, y no como un “arma” para utilizar en futuras guerras de patentes. Si queréis consultar exactamente lo que dice la patente en cuestión, podéis revisar el documento oficial en la Oficina de Patentes de Estados Unidos.

IPA, cambio en la filosofía de patentes

Según lo establecido en este acuerdo IPA que mencionábamos, que Twitter estrena hoy pero que ya anunció hace meses, todas estas patentes de tecnologías desarrolladas por sus ingenieros que se acojan a este programa sólo podrán utilizarse con este uso defensivo del que hablamos. Es decir, Twitter no podrá usarlas para demandar a otras compañías que las utilicen. Además, si se venden o si desean hacer algo, tendrán que ser con autorización expresa del creador original.

Lo normal, según cuentan la popular compañía de microblogging, es que las compañías patenten todos los desarrollos de sus empleados y los usen a voluntad, lo que incluye posibles demandas a terceros por utilizarlo o incluso venderla a otras empresas, que a su vez puedan hacer con ellas lo que les plazca. Si bien IPA suena muy bien sobre papel, habrá que esperar a ver si en la práctica se aplica tal y como Twitter pretende.

Enlace | Patente
Más información | Blog oficial de Twitter
En Genbeta | Twitter se compromete a usar las patentes de sus desarrolladores sólo de forma defensiva

Después de mucha espera llegó el 21 de mayo. Es la feccha elegida por Microsoft para presentar su nueva Xbox. En Xataka te lo vamos a contar todo en directo a partir de las 19.00 horas (Península) en nuestra página de directos y nuestro canal en Twitter.

Desde allí te descubriremos las novedades de la nueva Xbox con nuestro toque. Y justo en el momento en que se desvele el secreto, tendrás todos los datos en la portada de Xataka. No te vayas muy lejos.

En Xataka | Nueva Xbox.
En Twitter | #NuevaXbox

A Pandora for relationship management. That’s how Nimble describes version 3.0 of its social relationship manager platform, because of a Rules Engine that curates engagement opportunities, birthdays, job changes and “people of importance.” Sort of like setting up a station on Pandora, but built around people you want to stay in contact with.

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

South Korean mega-vendor Samsung keeps churning out the devices to cover every conceivable base and user need, with the new Mega 6.3" screen phablet joining a waterproof S4 model, with an S4 mini confirmed on the way. 

Read full story...
Follow us on Twitter Join free newsletter View upcoming events Find a new job

Los ordenadores portátiles con pantallas táctiles han llegado para quedarse, aunque a muchos, entre los que se encuentra Apple, no les parezca una solución ideal, la realidad es que en el mercado están funcionando. Las ventas en el primer trimestre de año han sido de 4,57 millones de unidades, según Displaybank (IHS).

El crecimiento con respecto al trimestre anterior es de un 51,8%, y prácticamente representan el 10% de las ventas de todo tipo de portátiles, que se estima en unas 46 millones de unidades.

Hay que tener en cuenta que el mercado de portátiles táctiles se ha visto potenciado por Windows 8 y los principales fabricantes, pero realmente estamos en un estado inicial (siete meses desde la aparición del nuevo Windows), por lo que la tendencia es que vaya creciendo hasta que se igualen con los ordenadores sin pantalla táctil. Va a depender mucho de la oferta que hagan los fabricantes, lo que nos quieran vender.

El mercado de los ordenadores en general ha caído, según IDC un 13,9% en este trimestre que hemos dejado atrás. Dentro de lo negativo, este tipo de portátiles traen poco de luz a la situación. De hecho nombres como ASUS o Lenovo tienen la intención de duplicar la penetración de portátiles táctiles a medio plazo.

Paul Otellini, hasta hace días CEO de Intel, ya desveló los planes de su compañía con respecto a dispositivos táctiles con Windows 8: los quería cercanos a los 200 dólares, y no muy lejos de finales de 2013.

Vía | Digitimes | TOM’s Hardware

Great design is a product of care and attention applied to areas that matter, resulting in a useful, understandable, and hopefully beautiful user interface. But don’t be fooled into thinking that design is left only for designers.

There is a lot of design in code, and I don’t mean code that builds the user interface—I mean the design of code.

Well-designed code is much easier to maintain, optimize, and extend, making for more efficient developers. That means more focus and energy can be spent on building great things, which makes everyone happy—users, developers, and stakeholders.

There are three high-level, language-agnostic aspects to code design that are particularly important.

1. System architecture—The basic layout of the codebase. Rules that govern how various components, such as models, views, and controllers, interact with each other.
2. Maintainability—How well can the code be improved and extended?
3. Reusability—How reusable are the application’s components? How easily can each implementation of a component be customized?

In looser languages, specifically JavaScript, it takes a bit of discipline to write well-designed code. The JavaScript environment is so forgiving that it’s easy to throw bits and pieces everywhere and still have things work. Establishing system architecture early (and sticking to it!) provides constraints to your codebase, ensuring consistency throughout.

One approach I’m fond of consists of a tried-and-true software design pattern, the module pattern, whose extensible structure lends itself to a solid system architecture and a maintainable codebase. I like building modules within a jQuery plugin, which makes for beautiful reusability, provides robust options, and exposes a well-crafted API.

Below, I’ll walk through how to craft your code into well-organized components that can be reused in projects to come.

The module pattern

There are a lot of design patterns out there, and equally as many resources on them. Addy Osmani wrote an amazing (free!) book on design patterns in JavaScript, which I highly recommend to developers of all levels.

The module pattern is a simple structural foundation that can help keep your code clean and organized. A “module” is just a standard object literal containing methods and properties, and that simplicity is the best thing about this pattern: even someone unfamiliar with traditional software design patterns would be able to look at the code and instantly understand how it works.

In applications that use this pattern, each component gets its own distinct module. For example, to build autocomplete functionality, you’d create a module for the textfield and a module for the results list. These two modules would work together, but the textfield code wouldn’t touch the results list code, and vice versa.

That decoupling of components is why the module pattern is great for building solid system architecture. Relationships within the application are well-defined; anything related to the textfield is managed by the textfield module, not strewn throughout the codebase—resulting in clear code.

Another benefit of module-based organization is that it is inherently maintainable. Modules can be improved and optimized independently without affecting any other part of the application.

I used the module pattern for the basic structure of jPanelMenu, the jQuery plugin I built for off-canvas menu systems. I’ll use that as an example to illustrate the process of building a module.

Building a module

To begin, I define three methods and a property that are used to manage the interactions of the menu system.

var jpm = { animated: true, openMenu: function( ) { … this.setMenuStyle( ); }, closeMenu: function( ) { … this.setMenuStyle( ); }, setMenuStyle: function( ) { … } };

The idea is to break down code into the smallest, most reusable bits possible. I could have written just one toggleMenu( ) method, but creating distinct openMenu( ) and closeMenu( ) methods provides more control and reusability within the module.

Notice that calls to module methods and properties from within the module itself (such as the calls to setMenuStyle( )) are prefixed with the this keyword—that’s how modules access their own members.

That’s the basic structure of a module. You can continue to add methods and properties as needed, but it doesn’t get any more complex than that. After the structural foundations are in place, the reusability layer—options and an exposed API—can be built on top.

jQuery plugins

The third aspect of well-designed code is probably the most crucial: reusability. This section comes with a caveat. While there are obviously ways to build and implement reusable components in raw JavaScript (we’re about 90 percent of the way there with our module above), I prefer to build jQuery plugins for more complex things, for a few reasons.

Most importantly, it’s a form of unobtrusive communication. If you used jQuery to build a component, you should make that obvious to those implementing it. Building the component as a jQuery plugin is a great way to say that jQuery is required.

In addition, the implementation code will be consistent with the rest of the jQuery-based project code. That’s good for aesthetic reasons, but it also means (to an extent) that developers can predict how to interact with the plugin without too much research. Just one more way to build a better developer interface.

Before you begin building a jQuery plugin, ensure that the plugin does not conflict with other JavaScript libraries using the $ notation. That’s a lot simpler than it sounds—just wrap your plugin code like so:

(function($) { // jQuery plugin code here })(jQuery);

Next, we set up our plugin and drop our previously built module code inside. A plugin is just a method defined on the jQuery ($) object.

(function($) { $.jPanelMenu = function( ) { var jpm = { animated: true, openMenu: function( ) { … this.setMenuStyle( ); }, closeMenu: function( ) { … this.setMenuStyle( ); }, setMenuStyle: function( ) { … } }; }; })(jQuery);

All it takes to use the plugin is a call to the function you just created.

var jpm = $.jPanelMenu( ); Options

Options are essential to any truly reusable plugin because they allow for customizations to each implementation. Every project brings with it a slew of design styles, interaction types, and content structures. Customizable options help ensure that you can adapt the plugin to fit within those project constraints.

It’s best practice to provide good default values for your options. The easiest way to do that is to use jQuery’s $.extend( ) method, which accepts (at least) two arguments.

As the first argument of $.extend( ), define an object with all available options and their default values. As the second argument, pass through the passed-in options. This will merge the two objects, overriding the defaults with any passed-in options.

(function($) { $.jPanelMenu = function(options) { var jpm = { options: $.extend({ 'animated': true, 'duration': 500, 'direction': 'left' }, options), openMenu: function( ) { … this.setMenuStyle( ); }, closeMenu: function( ) { … this.setMenuStyle( ); }, setMenuStyle: function( ) { … } }; }; })(jQuery);

Beyond providing good defaults, options become almost self-documenting—someone can look at the code and see all of the available options immediately.

Expose as many options as is feasible. The customization will help in future implementations, and flexibility never hurts.

API

Options are terrific ways to customize how a plugin works. An API, on the other hand, enables extensions to the plugin’s functionality by exposing methods and properties for the implementation code to take advantage of.

While it’s great to expose as much as possible through an API, the outside world shouldn’t have access to all internal methods and properties. Ideally, you should expose only the elements that will be used.

In our example, the exposed API should include calls to open and close the menu, but nothing else. The internal setMenuStyle( ) method runs when the menu opens and closes, but the public doesn’t need access to it.

To expose an API, return an object with any desired methods and properties at the end of the plugin code. You can even map returned methods and properties to those within the module code—this is where the beautiful organization of the module pattern really shines.

(function($) { $.jPanelMenu = function(options) { var jpm = { options: $.extend({ 'animated': true, 'duration': 500, 'direction': 'left' }, options), openMenu: function( ) { … this.setMenuStyle( ); }, closeMenu: function( ) { … this.setMenuStyle( ); }, setMenuStyle: function( ) { … } }; return { open: jpm.openMenu, close: jpm.closeMenu, someComplexMethod: function( ) { … } }; }; })(jQuery);

API methods and properties will be available through the object returned from the plugin initialization.

var jpm = $.jPanelMenu({ duration: 1000, … }); jpm.open( ); Polishing developer interfaces

With just a few simple constructs and guidelines, we’ve built ourselves a reusable, extensible plugin that will help make our lives easier. Like any part of what we do, experiment with this structure to see if it works for you, your team, and your workflow.

Whenever I find myself building something with a potential for reuse, I break it out into a module-based jQuery plugin. The best part about this approach is that it forces you to use—and test—the code you write. By using something as you build it, you’ll quickly identify strengths, discover shortcomings, and plan changes.

This process leads to battle-tested code ready for open-source contributions, or to be sold and distributed. I’ve released my (mostly) polished plugins as open-source projects on GitHub.

Even if you aren’t building something to be released in the wild, it’s still important to think about the design of your code. Your future self will thank you.

We’ve all been there: that bit of JavaScript functionality that started out as just a handful of lines grows to a dozen, then two dozen, then more. Along the way, a function picks up a few more arguments; a conditional picks up a few more conditions. And then one day, the bug report comes in: something’s broken, and it’s up to us to untangle the mess.

As we ask our client-side code to take on more and more responsibilities—indeed, whole applications are living largely in the browser these days—two things are becoming clear. One, we can’t just point and click our way through testing that things are working as we expect; automated tests are key to having confidence in our code. Two, we’re probably going to have to change how we write our code in order to make it possible to write tests.

Really, we need to change how we code? Yes—because even if we know that automated tests are a good thing, most of us are probably only able to write integration tests right now. Integration tests are valuable because they focus on how the pieces of an application work together, but what they don’t do is tell us whether individual units of functionality are behaving as expected.

That’s where unit testing comes in. And we’ll have a very hard time writing unit tests until we start writing testable JavaScript.

Unit vs. integration: what’s the difference?

Writing integration tests is usually fairly straightforward: we simply write code that describes how a user interacts with our app, and what the user should expect to see as she does. Selenium is a popular tool for automating browsers. Capybara for Ruby makes it easy to talk to Selenium, and there are plenty of tools for other languages, too.

Here’s an integration test for a portion of a search app:

def test_search fill_in('q', :with => 'cat') find('.btn').click assert( find('#results li').has_content?('cat'), 'Search results are shown' ) assert( page.has_no_selector?('#results li.no-results'), 'No results is not shown' ) end

Whereas an integration test is interested in a user’s interaction with an app, a unit test is narrowly focused on a small piece of code:

When I call a function with a certain input, do I receive the expected output?

Apps that are written in a traditional procedural style can be very difficult to unit test—and difficult to maintain, debug, and extend, too. But if we write our code with our future unit testing needs in mind, we will not only find that writing the tests becomes more straightforward than we might have expected, but also that we’ll simply write better code, too.

To see what I’m talking about, let’s take a look at a simple search app:

When a user enters a search term, the app sends an XHR to the server for the corresponding data. When the server responds with the data, formatted as JSON, the app takes that data and displays it on the page, using client-side templating. A user can click on a search result to indicate that he “likes” it; when this happens, the name of the person he liked is added to the “Liked” list on the right-hand side.

A “traditional” JavaScript implementation of this app might look like this:

var tmplCache = {}; function loadTemplate (name) { if (!tmplCache[name]) { tmplCache[name] = $.get('/templates/' + name); } return tmplCache[name]; } $(function () { var resultsList = $('#results'); var liked = $('#liked'); var pending = false; $('#searchForm').on('submit', function (e) { e.preventDefault(); if (pending) { return; } var form = $(this); var query = $.trim( form.find('input[name="q"]').val() ); if (!query) { return; } pending = true; $.ajax('/data/search.json', { data : { q: query }, dataType : 'json', success : function (data) { loadTemplate('people-detailed.tmpl').then(function (t) { var tmpl = _.template(t); resultsList.html( tmpl({ people : data.results }) ); pending = false; }); } }); $('<li>', { 'class' : 'pending', html : 'Searching &hellip;' }).appendTo( resultsList.empty() ); }); resultsList.on('click', '.like', function (e) { e.preventDefault(); var name = $(this).closest('li').find('h2').text(); liked.find('.no-results').remove(); $('<li>', { text: name }).appendTo(liked); }); });

My friend Adam Sontag calls this Choose Your Own Adventure code—on any given line, we might be dealing with presentation, or data, or user interaction, or application state. Who knows! It’s easy enough to write integration tests for this kind of code, but it’s hard to test individual units of functionality.

What makes it hard? Four things:

• A general lack of structure; almost everything happens in a $(document).ready() callback, and then in anonymous functions that can’t be tested because they aren’t exposed.
• Complex functions; if a function is more than 10 lines, like the submit handler, it’s highly likely that it’s doing too much.
• Hidden or shared state; for example, since pending is in a closure, there’s no way to test whether the pending state is set correctly.
• Tight coupling; for example, a $.ajax success handler shouldn’t need direct access to the DOM.

Organizing our code

The first step toward solving this is to take a less tangled approach to our code, breaking it up into a few different areas of responsibility:

• Presentation and interaction
• Data management and persistence
• Overall application state
• Setup and glue code to make the pieces work together

In the “traditional” implementation shown above, these four categories are intermingled—on one line we’re dealing with presentation, and two lines later we might be communicating with the server.

While we can absolutely write integration tests for this code—and we should!—writing unit tests for it is pretty difficult. In our functional tests, we can make assertions such as “when a user searches for something, she should see the appropriate results,” but we can’t get much more specific. If something goes wrong, we’ll have to track down exactly where it went wrong, and our functional tests won’t help much with that.

If we rethink how we write our code, though, we can write unit tests that will give us better insight into where things went wrong, and also help us end up with code that’s easier to reuse, maintain, and extend.

Our new code will follow a few guiding principles:

• Represent each distinct piece of behavior as a separate object that falls into one of the four areas of responsibility and doesn’t need to know about other objects. This will help us avoid creating tangled code.
• Support configurability, rather than hard-coding things. This will prevent us from replicating our entire HTML environment in order to write our tests.
• Keep our objects’ methods simple and brief. This will help us keep our tests simple and our code easy to read.
• Use constructor functions to create instances of objects. This will make it possible to create “clean” copies of each piece of code for the sake of testing.

To start with, we need to figure out how we’ll break our application into different pieces. We’ll have three pieces dedicated to presentation and interaction: the Search Form, the Search Results, and the Likes Box.

We’ll also have a piece dedicated to fetching data from the server and a piece dedicated to gluing everything together.

Let’s start by looking at one of the simplest pieces of our application: the Likes Box. In the original version of the app, this code was responsible for updating the Likes Box:

var liked = $('#liked');
 var resultsList = $('#results');
 
 // ... 

 resultsList.on('click', '.like', function (e) { e.preventDefault();
 var name = $(this).closest('li').find('h2').text();
 liked.find( '.no-results' ).remove();
 $('<li>', { text: name }).appendTo(liked);
 });

The Search Results piece is completely intertwined with the Likes Box piece and needs to know a lot about its markup. A much better and more testable approach would be to create a Likes Box object that’s responsible for manipulating the DOM related to the Likes Box:

var Likes = function (el) { this.el = $(el); return this; }; Likes.prototype.add = function (name) { this.el.find('.no-results').remove(); $('<li>', { text: name }).appendTo(this.el); };

This code provides a constructor function that creates a new instance of a Likes Box. The instance that’s created has an .add() method, which we can use to add new results. We can write a couple of tests to prove that it works:

var ul; setup(function(){ ul = $('<ul><li class="no-results"></li></ul>'); }); test('constructor', function () { var l = new Likes(ul); assert(l); }); test('adding a name', function () { var l = new Likes(ul); l.add('Brendan Eich'); assert.equal(ul.find('li').length, 1); assert.equal(ul.find('li').first().html(), 'Brendan Eich'); assert.equal(ul.find('li.no-results').length, 0); });

Not so hard, is it? Here we’re using Mocha as the test framework, and Chai as the assertion library. Mocha provides the test and setup functions; Chai provides assert. There are plenty of other test frameworks and assertion libraries to choose from, but for the sake of an introduction, I find these two work well. You should find the one that works best for you and your project—aside from Mocha, QUnit is popular, and Intern is a new framework that shows a lot of promise.

Our test code starts out by creating an element that we’ll use as the container for our Likes Box. Then, it runs two tests: one is a sanity check to make sure we can make a Likes Box; the other is a test to ensure that our .add() method has the desired effect. With these tests in place, we can safely refactor the code for our Likes Box, and be confident that we’ll know if we break anything.

Our new application code can now look like this:

var liked = new Likes('#liked'); var resultsList = $('#results');
 
 // ... 

 resultsList.on('click', '.like', function (e) { e.preventDefault();
 var name = $(this).closest('li').find('h2').text();
 liked.add(name); });

The Search Results piece is more complex than the Likes Box, but let’s take a stab at refactoring that, too. Just as we created an .add() method on the Likes Box, we also want to create methods for interacting with the Search Results. We’ll want a way to add new results, as well as a way to “broadcast” to the rest of the app when things happen within the Search Results—for example, when someone likes a result.

var SearchResults = function (el) { this.el = $(el); this.el.on( 'click', '.btn.like', _.bind(this._handleClick, this) ); }; SearchResults.prototype.setResults = function (results) { var templateRequest = $.get('people-detailed.tmpl'); templateRequest.then( _.bind(this._populate, this, results) ); }; SearchResults.prototype._handleClick = function (evt) { var name = $(evt.target).closest('li.result').attr('data-name'); $(document).trigger('like', [ name ]); }; SearchResults.prototype._populate = function (results, tmpl) { var html = _.template(tmpl, { people: results }); this.el.html(html); };

Now, our old app code for managing the interaction between Search Results and the Likes Box could look like this:

var liked = new Likes('#liked'); var resultsList = new SearchResults('#results');
 
 // ... 

 $(document).on('like', function (evt, name) { liked.add(name); })

It’s much simpler and less entangled, because we’re using the document as a global message bus, and passing messages through it so individual components don’t need to know about each other. (Note that in a real app, we’d use something like Backbone or the RSVP library to manage events. We’re just triggering on document to keep things simple here.) We’re also hiding all the dirty work—such as finding the name of the person who was liked—inside the Search Results object, rather than having it muddy up our application code. The best part: we can now write tests to prove that our Search Results object works as we expect:

var ul; var data = [ /* fake data here */ ]; setup(function () { ul = $('<ul><li class="no-results"></li></ul>'); }); test('constructor', function () { var sr = new SearchResults(ul); assert(sr); }); test('display received results', function () { var sr = new SearchResults(ul); sr.setResults(data); assert.equal(ul.find('.no-results').length, 0); assert.equal(ul.find('li.result').length, data.length); assert.equal( ul.find('li.result').first().attr('data-name'), data[0].name ); }); test('announce likes', function() { var sr = new SearchResults(ul); var flag; var spy = function () { flag = [].slice.call(arguments); }; sr.setResults(data); $(document).on('like', spy); ul.find('li').first().find('.like.btn').click(); assert(flag, 'event handler called'); assert.equal(flag[1], data[0].name, 'event handler receives data' ); });

The interaction with the server is another interesting piece to consider. The original code included a direct $.ajax() request, and the callback interacted directly with the DOM:

$.ajax('/data/search.json', { data : { q: query }, dataType : 'json', success : function( data ) { loadTemplate('people-detailed.tmpl').then(function(t) { var tmpl = _.template( t ); resultsList.html( tmpl({ people : data.results }) ); pending = false; }); } });

Again, this is difficult to write a unit test for, because so many different things are happening in just a few lines of code. We can restructure the data portion of our application as an object of its own:

var SearchData = function () { }; SearchData.prototype.fetch = function (query) { var dfd; if (!query) { dfd = $.Deferred(); dfd.resolve([]); return dfd.promise(); } return $.ajax( '/data/search.json', { data : { q: query }, dataType : 'json' }).pipe(function( resp ) { return resp.results; }); };

Now, we can change our code for getting the results onto the page:

var resultsList = new SearchResults('#results');
 var searchData = new SearchData(); // ... searchData.fetch(query).then(resultsList.setResults);

Again, we’ve dramatically simplified our application code, and isolated the complexity within the Search Data object, rather than having it live in our main application code. We’ve also made our search interface testable, though there are a couple caveats to bear in mind when testing code that interacts with the server.

The first is that we don’t want to actually interact with the server—to do so would be to reenter the world of integration tests, and because we’re responsible developers, we already have tests that ensure the server does the right thing, right? Instead, we want to “mock” the interaction with the server, which we can do using the Sinon library. The second caveat is that we should also test non-ideal paths, such as an empty query.

test('constructor', function () { var sd = new SearchData(); assert(sd); }); suite('fetch', function () { var xhr, requests; setup(function () { requests = []; xhr = sinon.useFakeXMLHttpRequest(); xhr.onCreate = function (req) { requests.push(req); }; }); teardown(function () { xhr.restore(); }); test('fetches from correct URL', function () { var sd = new SearchData(); sd.fetch('cat'); assert.equal(requests[0].url, '/data/search.json?q=cat'); }); test('returns a promise', function () { var sd = new SearchData(); var req = sd.fetch('cat'); assert.isFunction(req.then); }); test('no request if no query', function () { var sd = new SearchData(); var req = sd.fetch(); assert.equal(requests.length, 0); }); test('return a promise even if no query', function () { var sd = new SearchData(); var req = sd.fetch(); assert.isFunction( req.then ); }); test('no query promise resolves with empty array', function () { var sd = new SearchData(); var req = sd.fetch(); var spy = sinon.spy(); req.then(spy); assert.deepEqual(spy.args[0][0], []); }); test('returns contents of results property of the response', function () { var sd = new SearchData(); var req = sd.fetch('cat'); var spy = sinon.spy(); requests[0].respond( 200, { 'Content-type': 'text/json' }, JSON.stringify({ results: [ 1, 2, 3 ] }) ); req.then(spy); assert.deepEqual(spy.args[0][0], [ 1, 2, 3 ]); }); });

For the sake of brevity, I’ve left out the refactoring of the Search Form, and also simplified some of the other refactorings and tests, but you can see a finished version of the app here if you’re interested.

When we’re done rewriting our application using testable JavaScript patterns, we end up with something much cleaner than what we started with:

$(function() { var pending = false; var searchForm = new SearchForm('#searchForm'); var searchResults = new SearchResults('#results'); var likes = new Likes('#liked'); var searchData = new SearchData(); $(document).on('search', function (event, query) { if (pending) { return; } pending = true; searchData.fetch(query).then(function (results) { searchResults.setResults(results); pending = false; }); searchResults.pending(); }); $(document).on('like', function (evt, name) { likes.add(name); }); });

Even more important than our much cleaner application code, though, is the fact that we end up with a codebase that is thoroughly tested. That means we can safely refactor it and add to it without the fear of breaking things. We can even write new tests as we find new issues, and then write the code that makes those tests pass.

Testing makes life easier in the long run

It’s easy to look at all of this and say, “Wait, you want me to write more code to do the same job?”

The thing is, there are a few inescapable facts of life about Making Things On The Internet. You will spend time designing an approach to a problem. You will test your solution, whether by clicking around in a browser, writing automated tests, or—shudder—letting your users do your testing for you in production. You will make changes to your code, and other people will use your code. Finally: there will be bugs, no matter how many tests you write.

The thing about testing is that while it might require a bit more time at the outset, it really does save time in the long run. You’ll be patting yourself on the back the first time a test you wrote catches a bug before it finds its way into production. You’ll be grateful, too, when you have a system in place that can prove that your bug fix really does fix a bug that slips through.

Additional resources

This article just scratches the surface of JavaScript testing, but if you’d like to learn more, check out:

• My presentation from the 2012 Full Frontal conference in Brighton, UK.
• Grunt, a tool that helps automate the testing process and lots of other things.
• Test-Driven JavaScript Development by Christian Johansen, the creator of the Sinon library. It is a dense but informative examination of the practice of testing JavaScript.

Si fue en el Mobile World Congress cuando LG presentó al mundo su línea Optimus F, con la que pretendía extender la mano del LTE a aquellos terminales de especificaciones menos punteras, no se desveló al completo. O así lo indican las últimas imágenes filtradas para un nuevo dispositivo que encaja en ella.

Se trata de un Optimus F3 que vendría a ser el más pequeño de la familia, conformada también por el Optimus F5 y F7, que probamos en dicha feria.

Este dispositivo acompañaría con sus 4.0 pulgadas a sus hermanos mayores de 4.3 y 4.7 respectivamente, con algunas especificaciones que se han escurrido a la vez que el render que veis arriba, entre las que se encuentran una pantalla en resolución 800×480 (WVGA), Android 4.1.2 (Jelly Bean), un procesador Dual Core no espeficado y una batería bastante nutrida de 2.460 mAh. Además de, por supuesto, LTE integrado.

De momento, y según apuntan desde PhoneArena viene a competir por la operadora estadounidense Sprint y con unos precios muy agresivos no referenciados, al menos bajo contrato. De cualquier forma, se trata de una línea de terminales que todavía tardaremos en ver por España, debido a la todavía nula adopción de este tipo de conectividad.

En Xataka Android | LG Optimus F5 y F7, los probamos

Tras su vida como una aplicación para el tablet de Apple, NextGuide da el salto a la web y se posiciona como una de las propuestas más interesantes para unir a las diferentes plataformas de contenidos. Pero cuidado, estamos hablando por ahora solamente de una guía avanzada de programación adaptada a los tiempos.

En NextGuide se citan tanto contenido de televisiones que emiten al aire y por cable, como soluciones de streaming y bajo demanda del estilo de Netflix o Hulu, además de iTunes. El propósito de NextGuide es que el usuario pase por su servicio como punto de inicio para una experiencia televisiva más completa.

Nextguide proporciona un potente buscador y mucho toque social gracias a la integración con Facebook. El sistema nos da recomendaciones sobre películas y series, nos permite compartir nuestros gustos y aprende de los de nuestra red social cercana para que siempre tengamos algo que ver.

Para cada programa podemos configurar recordatorios y añadirlo a listas de reproducción. También disponemos de mucha información relacionada, guía de capítulos con la sinopsis, hora y cadena/plataforma de emisión, y hasta trailers en el caso de cine. Por ahora, en EEUU es donde, por invitación, más se puede aprovechar uno de este servicio para teleadictos.

Vía | GigaOm.
Más información | Nextguide.

Hi,

After the checkout and payment paypal giving the following error.

"We are sorry, we are experiencing temporary difficulties. Please try again later. If this error occurred while making a payment, avoid duplicate payments by checking your Account Overview before resending a payment.

For some browsers, this problem can be resolved by clearing or deleting cookies.

Message 3514"

I have deleted the browser cookies and checked in chrome,Firefox, IE. Still problem is there.

read more