martes, 28 de mayo de 2013

Learn Experiment: Usando los estilos de FirefoxOS

Este artículo comienza una serie basada en la migración de una aplicación real de Android (Hiragana Learn Experiment) a FirefoxOS. Pretendo con ello ver la programación necesaria para crear una aplicación real, paso a paso. Vamos a empezar en esta ocasión con la creación del menú principal, y junto con este introduciremos el uso de los estilos propios de FirefoxOS. A continuación dejo algunos enlaces útiles:
Respecto a la aplicación, es un conjunto de ejercicios para aprender Hiragana (el silabario japonés). En esta ocasión desarrollaremos tan solo el menú principal,  que no es más que una lista con los tres tipos de ejercicios: "Escoger el hiragana correcto", "Escribir en romaji" y "Escribir el hiragana". Por hoy nos limitaremos a mostrar estas opciones, pero además daremos a la app el estilo de FirefoxOS. Empecemos por ver el contenido del <body>, dado que el resto de la página es casi idéntico a lo que vimos en anteriores ocasiones:

<body role="application">
   <section  role="region" id="list-view">
      <header>
         <h1>Hiragana</h1>
      </header>
   
      <article id="appList" data-type="list">
         <ul>
            <li><a href="#"><p>Escoger el hiragana</p></a></li>
            <li><a href="#"><p>Escribir en romaji</p></a></li>
            <li><a href="#"><p>Escribir el hiragana</p></a></li>
         </ul>
      </article>
    </section>
</body>

Esta estructura es importante conservarla tal cual por que al usar estilos predefinidos, estos solo se aplicarán sobre una estructura con el siguiente formato:
  • El bloque <section> que divide el contenido en secciones, compuestas por un <header> y un <article>
  • El bloque <header>, en donde hemos situado el título <h1>, pero donde podría haber también botones y herramientas.
  • El <article> que contiene el contenido de la página/sección.
  • La lista <ul> que contiene tres elementos <li> los cuales consisten en un enlace <a> (que actualmente no enlazan a nada) y dentro de los cuales se incluye un párrafo <p> con el título de la opción.
Veamos ahora la hoja de estilos (css) necesaria para dar a este contenido el aspecto adecuado:

@import url(firefoxos/responsive.css);
@import url(firefoxos/headers.css);
@import url(firefoxos/lists.css);

html, body{
 margin:0;
 font-family:sans-serif;
 font-size:10px;
}

Como podéis ver los estilos son muy sencillos de nuevo, pero esto es por que estamos haciendo uso de otras hojas de estilo definidas por otros programadores. Por ello en la nuestra tan solo usamos:

  • La instrucción "@import url(....);", que nos permite cargar otras hojas de estilo. En este caso usamos las hojas de estilo ya definidas por FirefoxOS, ahorrándonos casi todo el trabajo
  • Una definición de estilos con el selector "html, body", en donde la coma simplemente indica que el estilo se aplica tanto al elemento <html> como al <body>
  • Lo primero que hacemos es aplicar un margen nulo, para que no quede un espacio en blanco con el borde de la página, que es lo que sucedería por defecto.
  • Por último indicamos un tamaño de fuente a toda la página de 10 píxeles, e indicamos que se use un tipo de letra "sans-serif", que son los tipos de letra que carecen de remates en los extremos y pueden ser más fáciles de leer en ciertas pantallas.
El resultado lo podemos ver a continuación. Como podréis entender, tanto la cabecera naranja, como el fondo azul que se "ilumina" al pulsar una opción son el resultado de usar las hojas de estilo de FirefoxOS con la estructura apropiada:


En conclusión

En este artículo hemos visto como aplicar los estilos por defecto de FirefoxOS. Con ello no solo nos ahorramos trabajo sino que logramos un diseño más consistente con las demás aplicaciones del teléfono. Poco a poco iremos viendo nuevos elementos del interfaz y como utilizarlos. En el próximo artículo empezaremos a desarrollar la navegación dentro de la aplicación, incluyendo la generación dinámica de contenidos de los menús.

jueves, 23 de mayo de 2013

Programando un foro para FirefoxOS (I)

Este artículo es el comienzo de una serie que mostrará el desarrollo de una plataforma de comunicación destinada a recibir feedback de los usuarios directamente desde las aplicaciones móviles. Es decir, en la propia aplicación un usuario podrá escribir un mensaje proponiendo mejoras o dando sugerencias, y otros podrán responder con su propia opinión.

Es un proyecto complejo, y de hecho se usará en varias aplicaciones reales comenzando por algunas que he programado para Android (ej: Hiragana Learn Experiment), pero en estos artículos nos centraremos sobre todo en su diseño e integración en FirefoxOS, aunque se hablará también de otras partes del desarrollo, incluyendo la programación del servidor y su implementación en Android u otras plataformas.

En este primer artículo nos centraremos en el diseño de la plataforma, que como se verá no es tan simple como pudiera parecer en un primer momento. Los datos concretos no tienen importancia, pero espero que el concepto general de diseño os sirva si vais a trabajar en vuestras propias aplicaciones.

Definiendo los requisitos

Empezando por lo básico, el programa permitirá varias acciones al usuario:
  • Ver lista de temas
  • Crear un tema nuevo
  • Ver tema
  • Responder a tema
  • Votar mensaje
  • Permitir a los usuarios escoger que nombre de usuario mostrar a los demás
  • Destacar los mensajes y temas del desarrollador
  • Indicar cuando un tema ha sido leído por el usuario y cuando tiene mensajes nuevos
Esta es la funcionalidad necesaria, y en un mundo ideal nuestros requisitos acabarían aquí. Pero la realidad es que aquí empiezan nuestros problemas. Para empezar ¿que ocurre cuando no tengamos conexión a internet? Podríamos dar una versión sin conexión, pero empecemos por algo más simple:
  • Si no hay Internet, tan solo mostraremos un mensaje indicándolo
¿Y que ocurre si se meten demasiados contenidos: temas, mensajes textos? Habrá que limitar la información que se muestra:
  • En el foro se mostrarán solo los últimos 30 temas actualizados
  • En cada tema los mensajes se mostrarán de 30 en 30, divididos en páginas
  • Los títulos de los temas tendrán un máximo de 100 caracteres
  • Los textos de los mensajes tendrán un máximo de 400 caracteres
¿Pero y si un usuario se pone a enviar demasiados mensajes? Necesitaremos nuevos límites para evitar que llene todo el foro tan solo con sus mensajes:
  • No se permitirá crear mas de un tema al día a cada usuario
  • No se permitirá mandar más de dos mensajes seguidos en un mismo tema a un mismo usuario, en menos de dos horas
Esto es solo una muestra de los requisitos, que probablemente se vaya ampliando con el tiempo, pero que nos permitirá comenzar a definir el resto de la "aplicación".

Diseñando la base de datos

La base de datos es donde se almacena la información que crean o modifican los usuarios. Se organiza en elementos de diferentes tipos (como usuarios, temas,...) cada uno con sus propios campos (nombre, título, fecha,...). En nuestro caso tendremos los siguientes tipos de elementos, en principio:


Cada "caja" es un tipo de elemento y las flechas entre ellas indican relaciones. El sentido de la flecha indica dependencias, así un foro tiene temas, y un tema tiene mensajes. Un usuario puede haber iniciado o leído varios temas, y haber escrito o votado varios mensajes. A continuación detallo los campos para cada tipo de elemento:
  • Usuario: Nombre, tipo (0=normal, 1=desarrollador), clave_producto
  • Aplicación: Nombre, usuario (propietario de la app), clave_producto
  • Foro: Aplicación, nombre, orden
  • Tema: Foro, título, usuario (quien lo creó), fecha (en que se insertó el último mensaje)
  • Mensaje: Tema, usuario (que lo escribió), fecha (en que se escribió), texto
  • Leído: Tema (leído), usuario (que lo leyó), fecha (de la última lectura)
  • Voto: Mensaje (que se vota), usuario (que lo vota)
Normalmente las bases de datos se representan como conjunto de tablas en las que cada tipo de elemento es una tabla, y sus campos son columnas de dicha tabla, mientras que por cada elemento se inserta una fila (usuario, tema, mensaje,...).

Realizar el diseño de la base de datos suele ser sencillo, pero a la vez es importante para tener clara la organización de la información y las operaciones a realizar en cada actividad.

Diseño de navegación

El diseño de navegación consiste en diseñar un esquema con las diferentes pantallas de la aplicación y unirlas con flechas indicando como se puede navegar entre ellas. En nuestro caso:



  • Temas: Muestra la lista de temas ordenados por fecha de último mensaje. Un botón permitirá crear nuevos temas
  • Nuevo tema: Formulario en el que se podrán escribir un título y un primer mensaje para el nuevo tema
  • Mensajes: Muestra la lista de mensajes de un tema, ordenados por fecha, con los últimos al final. Un botón permitirá escribir un nuevo mensaje.
  • Permitirá escribir un nuevo mensaje en el tema.
Se podría entrar en mas detalle con la descripción del interfaz, pero dado que probablemente lo acabemos cambiando de aquí al final, no es problema mantenerlo sencillo de momento.

Diseño del servicio web

Este es un paso que vosotros no tendréis que hacer habitualmente. Pero dado que en esta ocasión el foro lo usarán varios usuarios, los mensajes deben de encontrarse en un lugar común, en Internet, y por tanto hemos de definir un servicio web que permita acceder a dichas funciones.

Un servicio web no es mas que un conjunto de direcciones web que permiten modificar contenidos
  • Obtener temas: Devolverá la lista de temas de un foro ordenados por fecha descendente
    • Parámetros: Foro, usuario, clave de aplicación
  • Obtener mensajes: Devolverá la lista de mensajes de un tema ordenados por fecha ascendente
    • Parámetros: Tema, usuario, clave de la aplicación, mensaje inicial, mensajes a devolver
  • Crear tema: Creará un nuevo tema en un foro
    • Parámetros: Foro, clave de aplicación, usuario, nombre, título del tema, texto del primer mensaje
  • Escribir mensaje: Creará un nuevo mensaje en el tema
    • Parámetros: Tema, clave de aplicación, usuario, nombre, texto del mensaje
  • Votar mensaje: Incrementará el número de votos del mensaje
    • Parámetros: Mensaje, clave de aplicación, usuario, nombre

Conclusiones

A lo largo del artículo hemos dado los primeros pasos para desarrollar una aplicación, o en este caso, mas bien un complemento para las aplicaciones. Esta es una tarea que puede hacer cualquiera, sin necesidad de saber programar, aunque la experiencia en desarrollo suele ser siempre positiva. En próximos artículos nos meteremos manos a la obra con las siguientes actividades:
  • Creación de la base de datos con SQL y PHPMyAdmin
  • Creación de los servicios web con PHP
  • Desarrollo de la aplicación de foros para FirefoxOS, que funcione a partir de dichos servicios.

viernes, 17 de mayo de 2013

Javascript, jQuery y FirefoxOS: La programación orientada a eventos

En el artículo anterior vimos como crear un programa para FirefoxOS, pero ese programa no hacía nada más que mostrar un texto. En esta ocasión vamos a permitir al usuario interactuar con la aplicación, y para eso introduciremos el uso de javascript y jquery con un sencillo ejemplo de un programa que simula tiradas de dados.

Antes de empezar, algunos enlaces de interés:
En esta ocasión, además de los archivos ya vistos, tendremos un par de carpetas con los scripts (js) y los estilos (css). Pero de nuevo empezaremos viendo el HTML que contiene los elementos del interfaz:

<!DOCTYPE html>
<html>
<head>
    <title>Tirada de dados</title>
    <meta charset="UTF-8">
    <link rel="stylesheet" type="text/css" href="css/estilo.css" />
    <script type="text/javascript" src="js/jquery.js"></script>
    <script type="text/javascript" src="js/app.js"></script>
</head>
<body>
    Número de caras: <input type="number" id="numero_caras" value="6" />
    Número de dados: <input type="number" id="numero_dados" value="1" />
    <input type="button" value="Tirar dados" id="tirar_dados" />
    <div id="result" ></div>
</body>
</html>

Esta vez podemos ver las siguientes novedades respecto al código anterior:
  • En la cabecera tenemos los enlaces a la hoja de estilos <link>, y al javascript <script>
  • En el body tenemos varios elementos <input>, dos de tipo "number" (para introducir números) y el tercero, un botón.
  • Por último tenemos un elemento <div> que es una simple capa vacía en donde escribiremos el resultado de la tirada.


La idea es sencilla. Al pulsar el botón se calcula la tirada, que se mostrará en el campo resultado. Todo esto se hace en el script "app.js":

$(iniciar);

function iniciar() {
    $("#tirar_dados").click(tirar_dados);
}

function tirar_dados() {
    var suma=0;
    var tiradas=new Array();
    for(var i=0;i<$('#numero_dados').val();i++){
        tiradas.push(Math.ceil($('#numero_caras').val()*Math.random()));
        suma+=tiradas[tiradas.length-1];
    }
    $("#result").text("Resultado: "+suma+" = "+tiradas.join(" + "))
}

En realidad no suelo escribir código de esta manera, pero creo que será más fácil de explicar:
  • En la línea 1 se usa una función de jQuery que obliga a esperar a que se cargue la página antes de hacer nada más.
  • Cuando se ha cargado la página se llama a la función iniciar. Lo único que se hace aquí es seleccionar el botón con identificador "tirar_dados" y establecer un evento de manera que cuando alguien lo pulse se llame a la función "tirar_dados"
  • El cálculo se hace en la función "tirar_dados", y consiste simplemente en:
    • Cada tirada la "calculamos" generando un valor aleatorio entre 0 y 1, multiplicándolo por el valor indicado en el campo "número de caras" y redondeando el resultado hacia arriba (línea 11)
    • Repetimos estas tiradas tantas veces como número de dados se haya indicado (líneas 10 a 13)
    • Y vamos sumando los resultados en una variable para obtener el resultado final (línea 12)
  • Finalmente mostramos el resultado (en el bloque "result"), mostrando tanto la suma como la lista de tiradas parciales separadas por "+" (línea 14)
Hay varias cosas que quiero que os queden claras aquí por que luego se usarán en cada tutorial, así que pasaré sobre ellas sin comentarlas de nuevo:
  1. Siempre hay que inicializar la aplicación, esperando a que todo esté cargado
  2. En la inicialización se deben establecer los elementos con los que va a interactuar el usuario, y asociar a ellos los eventos correspondientes.
  3. Tanto para inicializar, como para asociar eventos, como para hacer cambios en los objetos del documento HTML, se utilizará jQuery. Así que acostumbraos a ver la instrucción $('selector').
Queda un detalle por resolver, y este es que el bloque <div> en el que se muestran los resultados tiene un estilo diferente, y naturalmente esto lo hemos establecido en el archivo "css/estilo.css":

#result{
 font-size:1.3em;
 font-weight:bolder;
}

Es un archivos sencillo, que simplemente establece el bloque identificado como "result" en negrita y con un tamaño de fuente de 1.3em. Para quienes no lo sepáis, la unidad "em" es una unidad de medida relativa al tamaño de fuente del bloque dentro del que está el actual, en este caso del <body>. En nuestro caso concreto 1.3em significa que el tamaño del texto en "result" será un 30% mayor que el tamaño del texto en el <body>.

Usaremos mucho esta medida relativa pues se ajusta mejor al dispositivo que usemos. De hecho en el próximo tutorial de esta serie vamos a tratar justamente el uso de hojas de estilo para dar una apariencia consistente a las aplicaciones de FirefoxOS, y en este contexto hablaremos más de tamaños y otras cuestiones de estilo.

miércoles, 15 de mayo de 2013

Diseñando aplicaciones I: Interfaces con HTML

Un interfaz es la parte de una aplicación que el usuario "ve", y con la que se comunica. En las aplicaciones de FirefoxOS (como en las aplicaciones web) este interfaz está definido mediante HTML, usándose generalmente un archivo HTML para cada pantalla de la aplicación.

Pero HTML fue originalmente un lenguaje para escribir documentos en la web, y creo necesario señalar las diferencias que implica el usarlo para desarrollar aplicaciones. Este artículo por tanto se ajustará a un nivel básico de conocimientos, así que disculpad si algunas de las cosas que comento ya las conocéis.

Si habéis aprendido HTML para hacer páginas web seguro que conoceréis muchas etiquetas (<p>, <ol>, <strong>, <em>, <h1>,...). La buena noticia para los que no las conozcan es que para programar aplicaciones casi nos basta con usar una sola: el bloque <div>. Mientras que las otras etiquetas tienen un aspecto y comportamiento predefinido, esta otra está pensada para adoptar cualquiera que necesitemos:


Como se muestra en la imagen anterior, todo interfaz lo podemos dividir en un conjunto de bloques identificables, los cuales adoptarán su aspecto y comportamiento final usando respectivamente CSS y javascript. Respecto al aspecto podemos usar distintas letras, márgenes, fondos, colores, bordes,... Respecto al comportamiento podemos cambiar el texto de un bloque, hacer que realice cálculos al pulsarlo, que muestre el progreso mediante una barra que se alarga o acorta,...

Pero para poder hacer todo eso necesitamos una manera de identificar dichos bloques y es aquí donde entran los atributos más importantes de HTML: "id" y "class". El primero identifica un bloque de manera única, mientras que el segundo admite una lista de palabras que puede compartir con otros bloques:

<div id="boton_continuar" class="boton destacado">
</div>

En el ejemplo anterior el bloque podría ser identificado por ser un bloque <div>, por su identificador "boton_actual" o por sus clases "boton" o "destacado". Por ejemplo, en CSS:

div{
   margin:1em;
}

.boton{
   border-radius:3em;
}

#boton_continuar{
   background:green;
}

Este código haría que el bloque anterior tuviese un margen por ser un div, tuviese las esquinas redondeadas por tener la clase "boton", y el fondo verde por ser el "boton_continuar". Fijaos que mientras la etiqueta se pone tal cual, la clase se identifica poniendo un punto delante, y el identificador usando una almuhadilla (#).

Javascript no tiene una manera equivalente de identificar los bloques, pero se han creado librerías que permiten hacerlo. En concreto nosotros usaremos una llamada jQuery:

$('.boton').click(
   // Aquí iria una función que se ejecuta al pulsar
   // cualquier bloque con la clase "boton"
)

// La siguiente instrucción pone el texto "Continuar"
// En el botón identificado como "boton_continuar"
$('#boton_continuar').text('Continuar')

Como podéis observar jQuery utiliza una el símbolo del dolar ($), seguido de unos paréntesis entre los que se introduce el selector al que le queremos aplicar el efecto, ya sea asociarle un evento o modificarlo de manera dinámica. Hay formas más complejas de definir selectores, como seleccionar solo los bloques que estén dentro de otros dados, o solo los bloques pares o impares,... Lo importante por ahora es saber que podemos usar estos selectores tanto para definir el aspecto de los bloques con CSS, como para definir su comportamiento con jQuery.

Otras etiquetas HTML

Aunque con los bloques <div> tenemos casi toda la funcionalidad que necesitamos, quería mencionar algunas de las otras etiquetas que se suelen utilizar en aplicaciones HTML y la razón para usarlas:
  • Los bloques <span>: Son genéricos como los <div> pero pensados para ser usados dentro de párrafos de texto, aunque en realidad pueden 
  • Las imágenes <img>: Siguen siendo necesarias para mostrar imágenes dentro de la aplicación.
  • Las listas <ul>, <li>: Se suelen utilizar para definir menús o listados de elementos
  • Los enlaces <a>: Aunque se podrían programar con javascript, siguen siendo una manera rápida de enlazar con otros contenidos.
  • Los elementos de formulario <input> y <textarea>: Interesantes sobre todo a la hora de meter campos de edición de texto.

sábado, 11 de mayo de 2013

Nuestro primer programa en FirefoxOS

En este artículo vamos a configurar el entorno de trabajo que usaremos en los próximos tutoriales. Para ponerlo en práctica haremos también nuestro primer programa, lo más sencillo posible. Como es típico en estos casos este programa lo único que hará será mostrar un "Hola mundo" en pantalla.

Antes de comenzar os dejo una lista de enlaces que usaremos en este artículo:


Solo necesitaremos tres archivos para esta primera tarea: Un icono, un archivo HTML que mostrará el "Hola mundo" y un archivo llamado "manifest.webapp" que es lo que usa FirefoxOS para saber que se trata de una aplicación y obtener la información que necesita:


Como ya sabréis FirefoxOS se programa con tecnologías web, así que quienes conozcáis el campo tendréis ventaja. Empezaremos viendo el código de la aplicación que es simplemente la estrucura del contenido que se muestra en pantalla, en lenguaje HTML:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>Hola mundo</title>
</head>
<body>
    <h1>¡Hola mundo!</h1>
</body>
</html>

Una breve explicación para los que no seáis programadores web:
  • El doctype indica el tipo de documento, en este caso HTML5, mientras que las etiquetas <html> marcan el contenido del documento.
  • Dentro tenemos las etiquedas <head> y <body>. El <body> es lo que muestra la página, mientras que <head> son cosas accesorias
  • En este caso tiene <title>, que es el título que se muestra en la pestaña del navegador, y <meta>, que indica la codificación internacional UTF-8 (premite usar desde la "ñ" hasta símbolos chinos)
  • Por último, en el body tenemos lo único que se mostrará, un título de primer nivel <h1> que tiene escrito "¡Hola mundo!"

En cierto sentido ya tenemos el "programa" de ejemplo. Mas adelante le añadiremos interactividad y diseño, pero hoy vamos a ir en otra dirección, pues con esto solo no es una aplicación FirefoxOS.  Para que lo sea, nos falta escribir el archivo "manifest.webapp" con la información relativa a nuestra aplicación. Este archivo está en formato JSON, que es un lenguaje de descripción de datos con la sintaxis de javascript. Pero se explica mejor viéndolo:

{
    "name": "Hola mundo",
    "description": "Ejemplo básico de web app",
    "launch_path": "/index.html",
    "icons": {
        "64": "/icon.png"
    }
}

Como podéis comprobar es tremendamente sencillo: Tenemos el nombre de la aplicación (name), una descripción (description), el acceso a la primera pantalla (launch_pad) y una referencia al icono (icons). No me molestaré en describir más en este tutorial, solo tenéis que cambiar el texto entre comillas para adaptar vuestra aplicación. En lugar de ello vamos a ver que hace falta para probar esto en una firefoxOS, o mejor dicho, en su simulador.

Para hacerlo, lo primero que necesitáis es el navegador Firefox instalado, para después instalar el simulador de FirefoxOS que funciona como un plugin del navegador. Una vez tengáis ambos, aparecerá la opción en el menú del navegador en Firefox > Desarrollador web > Firefox OS Simulator:


Al pulsar ahí se nos abrirá la página de control del simulador. Lo primero que haremos será añadir la aplicación que hemos creado pulsando el botón "Add Directory":


Entonces buscaremos en nuestro ordenador el programa que hemos desarrollado y escogeremos su archivo "manifest.webapp". Si no lo habéis hecho paso a paso podéis descargar aquí el código fuente del programa. Una vez seleccionado aparecerá la siguiente pantalla, indicando que hemos instalado el programa, y podremos entonces arrancar el emulador, pulsando en el interruptor en el que ahora mismo pone "Stopped":


Entonces veremos ver el simulador, que representa la pantalla de un teléfono. Si arrastramos lateralmente hacia la izquierda podremos recorrer las diferentes pantallas de aplicaciones hasta encontrar la nuestra:


Y pulsando en ella podremos verla su sencillo código en ejecución:


Con esto ya hemos visto como crear una aplicación sencilla y ejecutarla en el simulador. En próximos artículos ya podremos comenzar a hacer cosas más complejas e interesantes. Si tenéis alguna sugerencia sobre lo que os gustaría ver o hacer, serán bien recibidas.

jueves, 9 de mayo de 2013

FirefoxOS: Una nueva manera de programar para móviles


Supongo que todos conocéis el navegador Firefox, el tercero en discordia junto a Internet Explorer y Chrome. FirefoxOS no es más que un nuevo sistema operativo para móviles que entrará a competir con Android e iOS, y que usa como base el navegador web para la ejecución de las apps


 Uno podría preguntarse si un nuevo sistema operativo para móviles tiene sentido en un mundo dominado por Google y Apple. El caso es que lo que si tiene sentido es el enfoque que le van a dar, y lo demostraremos paso a paso en este blog. Por que lo interesante de FirefoxOS no es el sistema, sino las apps. Apps basadas en tecnologías web, y por lo tanto mucho más fáciles de programar, y mucho más versátiles y accesibles. 


 Si alguna vez te has planteado crear apps para móviles, o aplicaciones web, y eres aficionado a la informática o te gustaría saber algo de programación, este es tu lugar. La web tiene una curva de aprendizaje muy suave, y desde el primer artículo comenzaremos a crear aplicaciones que funcionarán en móviles FirefoxOS y en cualquier navegador web. Y poco a poco iremos viendo tecnologías y técnicas más avanzadas para poder desarrollar cada vez cosas más interesantes.


 Vamos a hablar aquí también de otras cuestiones interesantes para este campo, desde la publicidad para apps hasta el SEO, desde la programación en el servidor hasta la obtención de beneficios. Y espero que vosotros también os animéis a participar. Por que este campo permite desarrollar gran cantidad de ideas, y hace falta gente con iniciativa dispuesta a aprender y colaborar para ponerlas en marcha.