All posts by juan

¿Qué es Firebase?

Si trabajas haciendo apps para móviles, sabes lo complicado que resulta a veces realizar algunas operaciones, sobre todo la gestión multidispositivo con la base de datos. Por ejemplo a la hora de realizar aplicaciones muy grandes como CLMs, hay una enorme inversión de horas de trabajo para crear un backend poderoso que nos permita sincronizar de forma bidireccional la comunicación entre dispositivo y servidor aunque estemos desconectados de la red.

Firebase se podría decir que es un framework de trabajo de Google que nos ayuda con esto y con muchas cosas más. Aunque tiene soporte para web, está más orientada al desarrollo móvil iOS y android, para que los desarrolladores no tengan que preocuparse de desarrollar y mantener un servidor con su backend, además de ofrecer herramientas para la interconexión entre la app y el backend.

 

Firebase dispone de diferentes funcionalidades, entre las que se encuentran:

  • Base de datos en tiempo real: una base de datos gestionada por Google basada en JSON que nos permite, mediante eventos, tener funcionalidades en tiempo real. También nos permite llevar una gestión automática de los datos en el caso de que la aplicación se encuentre sin conexión, sincronizando todos los cambios una vez haya recuperado dicha conectividad.
  • Sistema de autentificación de usuarios tanto por email/contraseña como por otros sistemas como facebook, twitter, google, github, etc.
  • Cloud Messaging para el envío de notificaciones push a los dispositivos de una forma sencilla.
  • Un sistema de almacenamiento y sincronización de ficheros con el dispositivo.
  • Un sistema de hosting estático, ideal para realizar páginas estáticas o utilizarlo a modo de CDN de la app.
  • Sistema de reporting de errores.
  • Laboratorio de pruebas, para realizar pruebas en los dispositivos.
  • Funciones lambda basadas en NodeJS para realizar mediante eventos ciertas operaciones.
  • Conexión con AdMob para la monetización de la aplicación.
  • Configuración remota de la aplicación, pudiendo cambiar dinámicamente funcionalidades de la misma.

Lo más llamativo de Firebase es el Free Tier que ofrece, puesto que un proyecto para arrancar es gratuito, pudiendo dar el salto al pago cuando la aplicación haya crecido lo suficiente. Como opciones de pago disponemos de una tarifa plana de 25$ al mes que nos ofrece lo necesario para funcionar en proyectos de mediana envergadura. También disponemos de un "pago por uso" que nos permite pagar por aquellos recursos que utilicemos y que nos permitirá, de una forma escalonada, ir aumentando los costes poco a poco, según va creciendo nuestra aplicación.

¿Se puede rentabilizar un blog?

Tengo varios amigos que me preguntan si se puede ganar dinero con un blog, que están pensando escribir un blog para así dejar de trabajar. Lamentablemente siempre les tengo que dar la misma respuesta "si y no".

Por un lado, claro que si se puede pero tiene mucho trabajo. Lo primero me voy a saltar el término "viral", puesto que este es muy relativo y es muy difícil que se de. Cuando empezamos a escribir un blog tenemos que hacerlo porque nos gusta y no porque vamos a ser ricos con el. Solo cuando este punto está claro podemos trabajar en nuestro blog, porque no esperamos nada a cambio, lo hacemos por gusto.

Pero, ¿cómo gano dinero mi blog? Tienes 3 formulas principales: publicidad, artículos de pago o donaciones.

  • Publicidad: es la más clásica. Pones publicidad en tu blog y a escribir. Si tenemos la suerte que alguna empresa nos patrocine para poner su publicidad, podemos cobrar un fijo mensual, pero si no tenemos esa suerte, dependeremos de alguna plataforma tipo AdSense de Google para hacerlo. El problema, necesitamos muchas visitas, clicks y suerte para ganar dinero.
  • Artículos de pago: esta fórmula es difícil de conseguir pero es interesante. Cuando te contactan para este formato, solo tienes que escribir un artículo sobre una temática en concreto y te pagaran por ello. Hay empresas que ya te dan el artículo escrito y otras que permiten que lo escribas tu mismo. El precio varia en función del tamaño de tu blog, visitas, temática, etc. Es más rentable que la publicidad tal cual, pero tiene el problema que estás "vendido" por decirlo de alguna manera.
  • Donaciones: este es otro formato, menos explotado, puesto que o eres de mucha calidad y todo el mundo te conoce o no vas a ver ni un céntimo. Esta es la opción menos atractiva, ya que mucha gente no está dispuesta a pagar para leer algo en internet.

Sea cual sea la fórmula que elijamos para intentar ganar dinero con nuestro blog, debemos tener claro que necesitamos visitas. Sin visitas, da igual cuanta y de que calidad sea nuestra publicidad, no nos rentabilizará. En otro artículo explicaré como conseguir visitas para nuestro blog.

Por otro lado, no se puede ganar dinero con nuestro blog. Cuando la gente habla de ganar dinero con su blog, no se refiere unos centimos o euros al mes, se refiere a conseguir un sueldo con nuestro blog. Tengo un amigo que me dice:

Estoy leyendo un libro de uno que vive de escribir su blog, si el puede yo también

¡Claro que si! Poder se puede y esa es la actitud, si nunca lo intentas nunca lo lograrás, pero como decía al comienzo de la entrada, "tienes que hacerlo porque te gusta, no porque te harás rico". Por hacer un poco números en el aire, si partimos de Adsense y con este venimos ganando entorno 1€ cada mil visitas (estoy tirando por lo alto), deberíamos tener dos millones de visitas (2.000.000) al mes para conseguir un sueldo de 2.000€. Evidentemente esta regla no se aplica porque cuando tienes muchas visitas complementas con publireportajes, publicidad más cara, etc. pero desde luego, vemos lo difícil que es arrancar cuando las visitas iniciales son cero.

Hacer una consulta MongoDB comprobando que un atributo array no esté vacío

En el ejemplo de obtener resultados aleatorios en una consulta de MongoDB y mongoose utilizaba un where un tanto especial. Este where es para comprobar que un atributo de tipo array que está contenido en el modelo tiene datos.

Primero definamos un ejemplo de modelo simple con el que vamos a trabajar. Lo detallo en formato JSON para no anclarnos a un entorno:

{
  name: "Nombre",
  code: "Código",
  screenshots: [],
  description: "Descripción"
}

Ahora con el modelo definido veamos como utilizarlo. Para ello debemos fijarnos en la sentencia where que vamos a utilizar.

{ screenshots: {$exists: true, $not: {$size: 0}} }

En este where, sobre screenshots realizamos 2 comprobaciones. La primera comprobación es utilizar "$exists: true" donde indicamos que la propiedad necesariamente debe existir. Recordemos en las bases de datos de documentos como MongoDB no necesariamente deben coincidir todos los modelos en una colección (tabla) de la base de datos.

Lo segundo que comprobamos es "$not" negamos que el tamaño del array sea 0 o lo que es lo mismo "$size: 0", de esta forma, le pedimos a MongoDB que nos de solo modelos que tengan la propiedad screenshots y que el tamaño de screenshots sea mayor de 0.

Ahora volvamos a ver el ejemplo que usamos con mongoose.

var where = { screenshots: {$exists: true, $not: {$size: 0}} };

mongooseGameModel.count().where(where).exec(function(err, gameCount) {
  var rand = Math.floor(Math.random() * gameCount);

  mongooseGameModel.findOne().where(where).skip(rand).populate('developer').exec(function(err, game) {
    res.locals.randomGame = game;
    next();
  });
});

En este ejemplo utilizando mongoose contra MongoDB obtenemos un juego aleatorio de un listado que cumpla la condición de que screenshots no esté vacío.

Obtener registros aleatorios con MongoDB

En una base de datos NoSQL como es MongoDB nos asaltan dudas constantemente. En este caso, ¿Cómo obtener un único registro aleatorio? A continuación os detallo como obtener este dato.

Para obtener un registro aleatorio debemos de realizar una consulta de un único elemento pero saltando los x primeros registros. De esta forma obtendremos el resultado. Nada mas fácil que verlo con un ejemplo. Para ello pondré 2 ejemplos uno directamente haciendo la consulta sobre MongoDB y otro utilizando ODM de Mongoose.

En MongoDB se haría de la siguiente forma.

db.games.find().limit(-1).skip( _rand() * db.games.count() )

Si tenemos una tabla games con un listado de juegos y queremos seleccionar un juego aleatorio, lo podríamos hacer así. Seleccionamos todos los juegos, establecemos el limit a -1 y saltamos un aleatorio.

Otro método sería utilizando mongoose, este ya solo como programación.

mongooseModel.count().exec(function(err, resultCount) {
  var rand = Math.floor(Math.random() *resultCount);
  mongooseModel.findOne().skip(rand).exec(function(err, result) {
    console.log(result);
  });
});

Como podemos ver, es un lo mismo que hacerlo directamente sobre MongoDB pero añadiendo algo de complejidad en el proceso por las llamadas asíncronas. En primer lugar deberemos obtener el número de resultados, una vez los tengamos, podemos calcular el aleatorio y obtener con findOne el resultado que queremos.

Ya para terminar un buen ejemplo de como utilizar este código, es utilizando where para filtrar los resultados, que deberemos aplicar tanto a la hora de obtener el contador como cuando buscamos el resultado, ya que si no lo aplicamos en conjunto, puede fallarnos todo el código.

var where = { screenshots: {$exists: true, $not: {$size: 0}} };

mongooseGameModel.count().where(where).exec(function(err, gameCount) {
  var rand = Math.floor(Math.random() * gameCount);

  mongooseGameModel.findOne().where(where).skip(rand).populate('developer').exec(function(err, game) {
    res.locals.randomGame = game;
    next();
  });
});

Montar un servidor para node.js usando nodeserver

Llevo tiempo trabajando con node.js y la verdad es que es el entorno donde mas cómodo me siento. El problema que tiene node.js es que cuando buscas como montar un servidor, no tienes ejemplos reales, solo como escuchar el puerto 80.

Para mis webs uso un servidor de desarrollo propio llamado nodeserver que podemos encontrar tanto en github como en npm. Este servidor tiene varias ventajas fundamentales:

  • Al ser un desarrollo propio, me permite fácilmente ir añadiendo nuevas funcionalidades según las necesito.
  • Tiene soporte para proxy reverso, por ejemplo tener las webs en un servidor interno sin acceso público y traer las conexiones.
  • Soporte de gestión de procesos para node.js, por lo que los .js de node.js que vamos a arrancar como servidores, podemos arrancarlos automáticamente desde el servidor, así como pararlos o reiniciarlos.
  • Tiene soporte para páginas estáticas en html, con un listado de mime types en desarrollo. Esto nos permite por ejemplo, crear un sistema cookieless para un CDN sin un backend, solo configurando el servidor.
  • Soporte para páginas en PHP. Aunque aún no soporta elementos como mod_rewrite, en un futuro lo tendrá, por lo que en el típico VPS para gestionar pequeños proyectos, podemos prescindir de un NGINX o Apache y utilizar nodeserver para gestionar nuestras webs.

Vamos a ver como se instala y configura este servidor. Para esto, primero debemos tener instalado en nuestro sistema node.js, cualquier versión o io.js. Este servidor funciona desde la versión 0.10 de node.js, aunque lo mas recomendable es utilizar las últimas versiones, 4.0 o superiores.

Con nodejs ya instaldo, debemos instalar por npm nodeserver

$ sudo npm install nodeserver -g

De momento nodeserver solo cuenta con script de instalación para centos pero se irá ampliando a otros sistemas, esto no quiere decir que no se pueda utilizar, no se instalará como demonio del sistema.

$ sudo nodeserver install centos

Una vez instalado el script, que no es obligatorio, deberemos configurar el servidor. Para ello crearemos un json de configuración en /etc/nodeserver/nodeserver.config.

{
 "nodeserver": {
  "admin": {
   "active": [true|false],
   "port": admin-port-number,
   "user": "user-for-admin",
   "password": "hash-password"
  }
 },
 "sites": [{
  "name": "website name",
  "type": "node|cgi",
  "bindings": [
   "example.com:80",
   "www.example.com:80",
   "otherbindings:8080",
  ],
  "port": "internal port number for the project, do not repeat it. Only for node"
  "script": "absolute script for server.js for node or doc_root for php (cgi)",
  "security": {
   "certs": {
    "key": "/absolutepath/keycert.key",
    "cert": "/absolutepath/cert.cert",
    "ca": ["/absolutepath/ca.cert"]
   },
   "bindings": [
    "securehostforhttps.com:443",
    "www.securehostforhttps.com:443"
   ]
  },
 }, {
  "name": "php website",
  "type": "cgi",
  "bindings": [
   "myphpsite.com:80"
  ],
  "script": "/var/www/phpsite"
 }, {
  "name": "standar nodejs site",
  "type": "node",
  "bindings": [
   "standarnodejs.com:80"
  ],
  "port": "10001",
  "script": "/var/www/nodejs1/server.js"
 }, {
  "name": "secure nodejs site",
  "type": "node",
  "bindings": [
   "securenodejs.com:80"
  ],
  "port": "10002",
  "security": {
   "certs": {
    "key": "/absolutepath/keycert.key",
    "cert": "/absolutepath/cert.cert",
    "ca": ["/absolutepath/ca.cert"]
   },
   "bindings": [
    "securenodejs.com:443"
   ]
  },
  "script": "/var/www/nodejs2/server.js"
 }]
}

El json de configuración se divide en 2 keys: una de administración y otra de sitios web. La parte de administración indicamos si queremos activarlo o no, el puerto de escucha via web, usuario y contraseña. La contraseña viene en formato hash y podemos generar una utilizando el comando:

$ nodeserver password micontraseña

El resultado deberemos utilizarlo en la configuración de password.

Por otro lado tenemos los sites. Los sites tienen como configuración un nombre, un tipo cgi para estáticosphp o node para webs en node.js. Un array de bindings indicará dominio y puerto que vamos a utilizar de escucha. En los bindings podemos incluir patrones regulares, por ejemplo, para cuando tenemos subdominios que queremos gestionar desde un mismo backend. Un ejemplo sería ".+\.midominio.com:80" para capturar todos los subdominios de midominio.com en el puerto 80. El atributo port solo se utilizar en node.js y es un puerto interno de escucha para servidores node.js. El atributo script utiliza para node.js la ruta del script de arranque del proyecto o el document_root para webs en php o estáticas.

Una vez todo configurado, ya podemos arrancar y probar nuestro servidor.

$ sudo nodeserver start

Os animo a probarlo y a comentar vuestras experiencias, mejoras, etc. Esto es un ejemplo, de como prepararlo en un entorno real, pero se puede configurar nodeserver como servidor de desarrollo, tener una escucha con el parametro start-loop en lugar de start.

¿Qué es un protocolo de ObjetiveC y para que se usan los protocolos en ObjetiveC?

Cuando programamos en ObjetiveC para iphone o ipad, utilizando funciones mas avanzadas de la interfaz gráfica nos encontramos con delegados, llamados también delegates. En estos casos, por ejemplo cuando tenemos un UIScrollView que captura el evento - (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView que utilizamos para controlar cuando ese UIScrollView se ha parado. Para controlar esto lo hacemos mediante el uso de los delegados. Pero mejor verlo con un ejemplo que se vea mas claro.

@implementation IndalcasaViewController

- (void)viewDidLoad {
[super viewDidLoad];
self.indalScroll.delegate = self;
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
int page = scrollView.contentOffset.x / scrollView.frame.size.width;

NSLog(@"Hemos cambiado a la pagina %i", page);
}

@end

Tras este ejemplo vemos como funciona un delegado en una clase normal de ObjetiveC. Pero aún no entendemos lo que significa ser un delegado. Un delegado no es mas que un nombre de convención, que podemos llamar como queramos y que utilizaremos como disparador, donde el objeto que está almacenado implementa una serie de funcionalidades definidas en un protocolo.

Se que ahora ha quedado claro del todo :P, pero mejor verlo en un ejemplo.

@interface IndalcasaViewController : UIViewController
@end

Como vemos en el ejemplo anterior, a la hora de extender la clase UIViewController decimos que implementa el protocolo UIScrollViewDelegate. Para los mas veteranos desarrolladores, un protocolo no es mas que una interfaz. Para los mas novatos, una interfaz es como una clase donde se definen llamadas pero no se implementa código.

Para verlo todo mas sencillo, vamos a poner un último ejemplo. Lo que vamos a hacer es definir otro UIViewController al que instanciaremos en el viewDidLoad y que implementará un metodo vacío llamado "cambioPagina" que recibirá la página por parámetro.

IndalcasaViewController.h
@interface IndalcasaViewController : UIViewController

@property UIViewController delegate;
@property (weak, nonatomic) IBOutlet UIScrollView *indalScroll;

@end

IndalcasaViewController.m
@implementation IndalcasaViewController

- (void)viewDidLoad {
[super viewDidLoad];
self.indalScroll.delegate = self;
}

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
int page = scrollView.contentOffset.x / scrollView.frame.size.width;

NSLog(@"Hemos cambiado a la pagina %i", page);

[self.delegate cambioPagina:page];
}

@end

DelegadoViewController.h
@interface DelegadoViewController : UIViewController
@end

@protocol IndalcasaDelegate

-(void)cambioPagina:(int)pagina;

@end

DelegadoViewController.m
@implementation DelegadoViewController

- (void)cambioPagina:(int)pagina {
NSLog(@"Hemos cambiado a la pagina %i con un delegado", pagina);
}

@end

Como vemos en el ejemplo, lo que hacemos es que cuando capturamos el evento scrollViewDidEndDecelerating, que nos indica que se ha parado el scroll, llamamos a un delegado, previamente seteado que implementa el protocolo (intefaz) IndalcasaDelegate. Como sabemos que el delegado, al implementar el protocolo IndalcasaDelegate tiene un método cambioPagina que recibe un entero con la página, podemos llamar al método desde el delegado.

Comentar también que en muchos casos, nos encontraremos delegados de tipo id y no de un tipo concreto. Los tipos id vendrían a ser tipos de objetos genéricos, algo parecido al object de cualquier lenguaje.