Contenido


Cree una herramienta para analizar perfiles de Twitter utilizando Node.js, Mongo y D3

Construya una herramienta de nube de palabras sobre una plataforma de nube IBM Cloud

Comments

En mi rol como diseñador de experiencia de usuario, debo comprender la motivación de las personas que utilizan los productos que ayudo a diseñar. Una experiencia de usuario bien diseñada mejora la capacidad de un producto para competir en el campo.

Pensé que podía aprender acerca de los aspectos de una base de usuario determinada a través de las redes sociales. Decidí tomar muestras de los tweets y las biografías de perfil de los usuarios de la cuenta de Twitter de un producto para descubrir cómo los seguidores se describen a sí mismos y para ver si eso puede ayudarme a comprender sus motivaciones para seguir un producto.

Piense acerca de lo que la gente está haciendo hoy en [las redes sociales] … están construyendo una imagen e identidad para ellos mismos, que en cierto sentido es su marca. Se están conectando con la audiencia con la que desean conectarse.

Mark Zuckerberg

Después de revisar algunos perfiles, me alentaron los detalles de las biografías que tomé como muestra. Sin embargo, si realizaba la tarea en forma manual, solo podía tomar una muestra de un lote pequeño de seguidores y formar una imagen mental general. Parecía una idea prometedora — las biografías están abiertas y pueden revelar una forma interesante y profunda del análisis competitivo o del usuario. Aún así, parecen haber pocas herramientas que nos ayudan a contemplarnos en el espejo de las redes sociales — para comprender cómo nos ven los demás.

Deseaba ver una nube de palabras de alrededor de mil biografías de seguidores que destacara las palabras más frecuentes en estas biografías, pero no pude encontrar una herramienta gratuita y disponible para realizar nubes de palabras desde las biografías.

Profile words concept
Profile words concept

Encontré una herramienta comercial para enumerar las cinco palabras principales de las biografías de mis seguidores, pero debía pagar para usarla y no era exactamente lo que quería. Sospeché que también había valor en las palabras periféricas y que los patrones podían surgir desde una mayor propagación de datos.

Por eso creé una aplicación en la plataforma de nube IBM Cloud para ayudar a ilustrar estos datos.Este es un ejemplo del resultado de la aplicación.Es una nube de palabras de las palabras más prominentes de las biografías de los perfiles de mis seguidores. Puede utilizar la misma idea para tomar muestras de las biografías de los perfiles de los seguidores de un producto y los tweets de la cuenta de Twitter de un producto.

A word cloud view of the                 most common words from my Twitter follower's biographies
A word cloud view of the most common words from my Twitter follower's biographies

Puede utilizar una herramienta de nube de palabras para:

  • Verificar y adaptar su propia identidad
  • Comparar los seguidores de productos o personas de la competencia
  • Evaluar a nuevos seguidores o personas potenciales que le gustaría seguir

En el excelente artículo de Scott Rich mencionado anteriormente, se muestra cómo crear una base de Node, express y Twitter en IBM Cloud. La base de mi aplicación es similar a la de Scott, excepto que extiendo una aplicación de Twitter básica en Node.js utilizando la autenticación de Twitter, integrando una base de datos de Mongo y transformando los datos sin procesar en una infografía más sofisticada.

Incluyo pasos generales para integrar Mongo y Node, y brindo enlaces a proyectos simples dedicados a configurar esa integración, pero los vinculo a mi aplicación en nube de palabras donde puede ver a Mongo y Node integrados en un ejemplo del mundo real.

Ejecutar la aplicaciónObtener el código

Lo que necesitará para construir una aplicación similar

Esta es una aplicación compleja. Los pasos de este tutorial pueden ayudar a que un desarrollador intermedio aprenda cómo construir aplicaciones de Twitter autenticadas en Node e implementarlas en unaPaaS, pero algunos componentes y pasos son necesarios.

Mi enfoque es crear un entorno local con Mongo y Node y luego utilizar la función de autoimplementación en DevOps Services para implementar en IBM Cloud al insertar cambios en git.

Para el desarrollo local, instalé módulos de Node.js del lado del servidor y bibliotecas de JavaScript del lado del cliente.

  • Los módulos de Node.js del lado del servidor:
    • Mongodb: para conectarse a una base de datos mongo
    • express: ayuda a organizar y analizar solicitudes de HTTP desde rutas de URL específicas
    • twit: una biblioteca muy útil para llamar a las API de Twitter .
    • OAuth: para autenticar en Twitter
  • Bibliotecas JavaScript del lado del cliente:
    • Programa de arranque: para programar ciertos componentes de IU HTML confiables
    • D3: los documentos impulsados por datos que se utilizan en la visualización en nube de palabras

Al hacer clic en el botónObtener el código anterior, podrá descargar un archivo package.json.

{
  "name": "ProfileWords",
  "version": "v0.0.1",
  "description": "A tool for analyzing Twitter accounts, using follower's bios",
  "dependencies": {
    "mongodb": "*",
    "express": "*",
    "twit": "~1.1.11",
    "cookie-parser": "*",
    "express-session": "~1.0.3",
    "errorhandler": "*",
    "morgan": "*",
    "request":"*",
    "multiparty":"*",
    "oauth": "*"
  },
  "engines": {
    "node": ">=0.10.0"
  },
  "repository": {}
}

El archivo de paquete también contiene algunos paquetes sobre los que dependen Mongo y OAauth.

Todo el código se desarrolló con la tecnología de pila MEAN simple y se diseñó para ejecutarse en IBM Cloud. Incluyo los pasos para configurar un servicio MongoLabs en IBM Cloud.

Para aprender cómo construir mis mezclas visuales de Twitter, seguí los siguientes pasos:

  1. Seguí las instrucciones del artículo de Scott
  2. Instalé Mongo localmente
  3. Creé una aplicación de Twitter desde el sitio de desarrollador de Twitter
  4. Establecí mi configuración para la autenticación de Twitter
  5. Creé una aplicación básica de Mongo para ejecutar en ella
  6. Añadí la autenticación básica de Twitter, que termina la base
  7. Comencé a escribir el código para llamar a la API de Twitter y escribir a la base de datos
  8. Realicé capas en una biblioteca de visualización (D3, en mi caso)

Paso 1. Almacene la configuración en el entorno

Uno de los 12 factores para el desarrollo del software moderno es almacenar la configuración en el entorno. Esta técnica ayuda a mantener las claves de API (y otros datos) en privado.

Dado que este proyecto utiliza la API de Twitter , necesita crear una nueva aplicación de Twitter para ejecutar el código.Al hacerlo, se le brindan algunas claves de Twitter que el archivo app.js necesita conocer; de otro modo, Twitter rechaza las llamadas a la API que utiliza la aplicación. Para obtener más detalles, consulte el archivo README.MD para mi aplicación.

En mi archivo app.js, puede ver las siguientes líneas de código que configuran un objeto de clave del consumidor para autenticación.

var consumer = new oauth.OAuth(
        "https://twitter.com/oauth/request_token", "https://twitter.com/oauth/access_token",
        process.env.TWITTER_CONSUMER_KEY, 
        process.env.TWITTER_CONSUMER_SECRET, 
        "1.0A", _callBackPage, "HMAC-SHA1");

        app.use(errorHandler({ dumpExceptions: true, showStack: true }));
        app.use(logger());
        app.use(cookieParser());
        app.use(session({ secret: "very secret" })
);

La lista incluye los valores de serie process.env.TWITTER_CONSUMER_KEY y process.env.TWITTER_CONSUMER_SECRET que Twitter proporciona para mi aplicación. Cree una nueva aplicación de Twitter y vaya a la pestaña Claves de API de las páginas de la aplicación, que se muestran en la siguiente imagen. Defina las claves para el entorno. Mi aplicación se denomina ProfileWords. Su aplicación tendrá su nombre.

Usuarios de Mac : para definir las claves del entorno:

  1. Abra una ventana del terminal.
  2. Emita el siguiente comando:
    sudo vi /etc/launchd.conf
  3. Edite el archivo launchd.conf y añada las siguientes líneas:
    	setenv TWITTER_CONSUMER_KEY YOUR-STRING
    	setenv TWITTER_CONSUMER_SECRET YOUR-STRING
    	setenv TWITTER_ENDPOINT YOUR-ENDPOINT

Haga clic en la pestaña Configuración de las páginas de la aplicación. Especifique un nombre, una descripción, un URL de Web site y un URL de devolución de llamada. Marque la casilla de verificación Permitir que se utilice esta aplicación para Iniciar sesión con Twitter .

Settings page of Twitter app showing callback URL
Settings page of Twitter app showing callback URL

Reinicie el sistema. Ahora, cuando se ejecute la aplicación Node, tendrá acceso a las series del consumidor.

Usuarios de Windows : emitan el siguiente comando desde una shell:

SET TWITTER_CONSUMER_KEY=YOUR-STRING

Paso 2. Bifurque el proyecto desde DevOps Services

  1. Inicie sesión en IBM Cloud y añada una instancia del servicio MongoLab. Deje la instancia sin enlazar, configure un nombre (como MongoLab_profilesExample) y tome nota del mismo. IBM Cloud MongoLabs service
    IBM Cloud MongoLabs service
  2. Haga clic en el proyecto de los perfiles, seleccione Editar código y luegoBifurcar para darle un nombre al proyecto bifurcado. DevOps Services copia la estructura del proyecto por usted.
  3. Cambie el archivo manifest.yml para que se vincule con la base de datos y tenga un nombre único para la aplicación, como se muestra en la siguiente lista de códigos.
    	applications:
    	- services:
    	  - MongoLab-profilesExample
    	  disk_quota: 1024M
    	  host: myprofilesapp
    	  name: myprofilesapp
    	  command: node app.js
    	  path: .
    	  domain: mybluemix.net
    	  instances: 1
    	  memory: 512M
  4. Antes de implementar en IBM Cloud y ejecutar la aplicación, debe establecer algunas variables de entorno.
  5. Vaya a la sección Tiempo de ejecución para la nueva aplicación. IBM Cloud brinda una IU conveniente para establecer las series de entorno en esta sección, un método que protege la privacidad de las claves y le permite confirmar su código de manera segura, sin escribir las claves para que el público las vea.

    Como se muestra en la siguiente imagen, vaya a la sección Variables de entorno y añada las claves debajo de la pestaña Definido por el usuario .

    Runtime tab of IBM Cloud app
    Runtime tab of IBM Cloud app
  6. Reinicie la aplicación desde IBM Cloud. Debería estar listo.

Paso 3. Configure la autenticación y especifique el uso de los límites de calificación del usuario

Twitter tiene un límite de calificación para las API.El límite establece la cantidad de solicitudes que un usuario puede realizar en un cierto período de tiempo para evitar una demanda no administrable en sus servidores. Twitter le aconseja programar las aplicaciones personalizadas para que usen la asignación de calificación propia del usuario de la aplicación, en lugar de ejecutar una aplicación de una cuenta simple, como la cuenta del desarrollador de la aplicación.

Por ejemplo, la aplicación mi ProfileWords realiza una solicitud para una lista de seguidores cuando el usuario ingresa el nombre de un seguidor. Esa solicitud puede devolver hasta 1000 nombres de cuentas en mi aplicación.El límite de clasificación de Twitter permite 15 de tales solicitudes dentro de una ventana de 15 minutos. (Cuando se encuentra en una buena etapa de exploración de perfiles, este límite parece pequeño, pero c'est la vie.)

El primer paso consiste en autenticar un usuario, para poder llamar a la API y trabajar dentro del límite de clasificación personal del usuario.

Me tomó algunas horas de investigación descubrir cómo autenticar en Twitter con Node. Si bien esta es una tarea común (muchos servicios usan la autenticación abierta), la tecnología de Node está cambiando tan rápidamente que los ejemplos que encontré no funcionan con el último módulo de Node OAuth.

Por lo tanto, desarrollé un proyecto aislado para compartircómo utilizar OAuth para conectarse a Twitter. El archivo LÉAME de ese proyecto desglosa los pasos para clonar esta aplicación con su propia información de desarrollador de Twitter.

Este es el proceso general que se utiliza en la siguiente lista de códigos:

  • Cuando un usuario escribe el URL de la aplicación, se le solicita iniciar sesión a través de Twitter.
  • Cuando el usuario hace clic en Iniciar sesión , se lo redirecciona a una página de autenticación de Twitter.
  • Cuando el usuario inicia sesión en Twitter, se lo envía nuevamente a una página de devolución de llamada preprogramada (en este caso, la página de nube de palabras).El URL de devolución de llamada se programa en el archivo server.js para el subproyecto.
var express = require('express');
var util = require('util');
var oauth = require('oauth');
var http = require('http');
var cookieParser = require('cookie-parser');
var session = require('express-session');
var errorHandler = require('errorhandler');
var logger = require('morgan');


var app = express();
var server = http.createServer(app);

// Get your credentials here: https://dev.twitter.com/apps

var _twitterConsumerKey = "YOUR TWITTER CONSUMER KEY";
var _twitterConsumerSecret = " YOUR TWITTER CONSUMER SECRET";

var consumer = new oauth.OAuth(
    "https://twitter.com/oauth/request_token", 
    "https://twitter.com/oauth/access_token",
    _twitterConsumerKey, _twitterConsumerSecret, "1.0A", "http://127.0.0.1:8080/sessions/callback", "HMAC-SHA1");

app.use(errorHandler({ dumpExceptions: true, showStack: true }));
app.use(logger());
app.use(cookieParser());
app.use(session({ secret: "very secret" }));

app.use(function(req, res, next){
  var err = req.session.error,
      msg = req.session.success;
      delete req.session.error;
      delete req.session.success;
  res.locals.message = '';
  if (err) res.locals.message = '<p class="msg error">' + err + '</p>';
  if (msg) res.locals.message = '<p class="msg success">' + msg + '</p>';
  next();
});

app.get('/sessions/connect', function(req, res){
  consumer.getOAuthRequestToken(
      function(error, oauthToken, oauthTokenSecret, results){
        if (error) {
            res.send("Error getting OAuth request token : " + 
                     util.inspect(error), 500);
    } else {
      req.session.oauthRequestToken = oauthToken;
      req.session.oauthRequestTokenSecret = oauthTokenSecret;
      res.redirect("https://twitter.com/oauth/authorize?oauth_token="+req.session.oauthRequestToken);
      console.log( 'get sessions connect' );
    }
  });
});

app.get('/sessions/callback', function(req, res){
  util.puts(">>"+req.session.oauthRequestToken);
  util.puts(">>"+req.session.oauthRequestTokenSecret);
  util.puts(">>"+req.query.oauth_verifier);
  consumer.getOAuthAccessToken( req.session.oauthRequestToken, req.session.oauthRequestTokenSecret, req.query.oauth_verifier, 
    function(error, oauthAccessToken, oauthAccessTokenSecret, results) {
    if (error) {
    res.send("Error getting OAuth access token : " + util.inspect(error) 
            + "["+oauthAccessToken+"]"+ "[" +oauthAccessTokenSecret 
            + "]" + "[" + util.inspect(results)+"]", 500);
    } else {
      req.session.oauthAccessToken = oauthAccessToken;
      req.session.oauthAccessTokenSecret = oauthAccessTokenSecret;

      console.log( 'get sessions callback' );
      res.redirect('/home');
    }
  });
});

var tAPI = "https://api.twitter.com/1.1/account/verify_credentials.json";

app.get('/home', function(req, res){
    consumer.get( tAPI, req.session.oauthAccessToken, 
                 req.session.oauthAccessTokenSecret, 
                 function (error, data, response) {
      if (error) {
          console.log( 'error\n' );
          console.log( error );
          res.redirect('/sessions/connect');
      } else {
          var parsedData = JSON.parse(data);
          console.log( parsedData );
          res.send('You are signed in: ' + parsedData.screen_name);
      }
    });
});

app.get('*', function(req, res){
    res.redirect('/home');
});

app.listen(8080);

El archivoLÉAME de este proyecto detalla los pasos para utilizar este código de esqueleto para su propia autenticación de Twitter. La ruta /sessions/connect conduce al usuario al recuadro de diálogo de inicio de sesión de Twitter en el Web site seguro del usuario y lo devuelve a la ruta /sessions/callback. Es fundamental que utilice sus propias credenciales de Twitter como se indica.

Dentro del proyecto ProfileWords, he tomado este mismo enfoque de autenticación y lo reflejé en el archivo app.js.

Cuando un usuario ha autenticado, puede derivar más información desde Twitter acerca de esa persona.Hay mucha información disponible, incluido el nombre de usuario, la geolocalización y la elección de colores en el diseño de la página de Twitter del usuario.

La información vital es la clave secreta del usuario, ya que debe usarse en las consultas subsiguientes a Twitter. Puede ver esa clave en la siguiente lista de códigos. Almaceno esos datos en una base de datos de Mongo para usarlos en nombre del usuario más adelante.

 app.get('/profilewords.html', function(req, res){

        var twitterVerification = "https://api.twitter.com/1.1/account/verify_credentials.json";
        var token = req.session.oauthAccessToken;
        var secret = req.session.oauthAccessTokenSecret;

        consumer.get( twitterVerification, token, secret, function (error, data, response) {
            if( error ){
                console.log( 'Twitter verification error\n' );
                console.log( error );
                res.redirect('/sessions/connect');

            } else {

                var parsedData = JSON.parse(data);
                            
                var person = ( {'name':parsedData.screen_name,
                                'oauth_access_token': req.session.oauthAccessToken,
                                'oauth_access_token_secret': req.session.oauthAccessTokenSecret } );

                var collection = followersDatabase.collection( 'tokens' );

                collection.remove( { 'name':parsedData.screen_name }, errorHandler );

                collection.insert( person, {safe:true}, errorHandler );

                res.sendfile('profilewords.html');
            }
        });
    });

Paso 4. Conéctese a Mongo

El código del servidor Node debe poder incluir la clave secreta de Twitter para un usuario al realizar solicitudes de API de Twitter. Se requiere tanto la clave pública como la clave secreta en la solicitud de Twitter.

Utilizo la clave pública como el código de la base de datos para encontrar la clave privada. Deseo que mi aplicación ProfileWords pueda admitir a muchas personas a la vez; por lo tanto, debe poder aceptar y formular solicitudes en nombre de varios usuarios, cada uno con sus propias credenciales de Twitter.

Cuando un usuario se autentica, Twitter proporciona una clave secreta para ese usuario.La clave se almacena en la base de datos. Luego, cuando el usuario emite una solicitud, la aplicación busca la clave privada almacenada y la compara con la mitad pública de la clave, que se guarda en el navegador Web y se envía con las solicitudes.

Esta es la secuencia.

Sequence chart for Twitter authentication with Node
Sequence chart for Twitter authentication with Node

Mongo funciona con una agrupación de conexión. Mi aplicación Node crea una conexión cuando se inicia:

mongo = {   "hostname":"127.0.0.1",
                "port":27017,
   	            "username":"",
                "password":"",
                "name":"",
                "db":"db",
                "url":"mongodb://127.0.0.1:27017/db" };
                
path = mongo.url;

MongoClient.connect( path, function(err, followersDatabase) {

Tenga en cuenta que toda mi aplicación Node se ejecuta dentro de esta conexión y puede hacer referencia a la base de datos simplemente utilizando la expresión followersDatabase desde ese punto en adelante.

En muchos ejemplos de Mongo, se crea una conexión actualizada cada vez que se realiza una solicitud. Aprendí que este método se desglosa rápidamente cuando se implementa en un tiempo de ejecución de PaaS. La documentación de Mongo (donde aprendí acerca de MongoClient.connect) aconseja que se ejecute con una sesión conectada, tal como yo lo hice.

He creadoun proyecto de conexión de base de datos simple y dedicado como referencia para ayudar a mostrar algunos aspectos básicos de Mongo, pero puede estudiar cómo usarlos dentro de app.js también.

Por ejemplo, el siguiente código busca el token secreto para que ese código pueda enviar una solicitud en Twitter.

app.param('id', function(req, res, next, id){    

        res.setHeader( 'Content-Type', 'application/json' );

        if( req.headers['oauth_token'] ){

            var token = req.headers['oauth_token'];
            var cloudType = req.headers['cloudtype'];
            
            var collection = followersDatabase.collection( 'tokens' );

            collection.findOne( { 'oauth_access_token': token }, function( err, item ) {                 

                var config = {
                    consumer_key:         'YOUR CONSUMER KEY',
                    consumer_secret:      'YOUR CONSUMER SECRET',
                    access_token_secret: item.oauth_access_token_secret,
                    access_token: item.oauth_access_token
                }

                console.log( 'account: ' + item.name );

                retrieveProfiles( config, res, id, cloudType );   

                var requests = followersDatabase.collection( 'requests' );

                var date = new Date();

                var request = ( { 'twitterId':id, 'timeStamp': date, 'account': item.name } );

                requests.insert( request, {safe:true}, errorHandler );

            });
        }

        next();
    });

    app.get( "/words/:id", function(req, res ){ } );

Tiene muchas oportunidades para guardar algunos datos de estudios analíticos en la base de datos. Por ejemplo, puede contar cada solicitud por usuario o registrar elecciones de temas de colores para la nube de palabras. La iteración actual de la aplicación utiliza la base de datos para gestionar el acceso al token para varios usuarios.

En este punto, he cubierto los siguientes pasos con Node y express, como utilizar Mongo y trabajar con la autenticación. Se pueden utilizar los mismos ingredientes dentro de las otras mezclas de las redes sociales. Puede avanzar mucho con estos bloques de construcción.

Me tomó un poco de tiempo desarrollar este conocimiento, pero el proceso de — solucionar problemas y aprender — se tornó adictivo. Los paquetes útiles de nodos ofrecen una buena base.

Paso 5. Visualice el resultado con D3

Me tomó algunas horas alcanzar el punto en el que tuve una aplicación predefinida en el código con mis propios datos de captación de autenticación de Twitter predefinidos en el código. Enseguida encontré una nube de palabras de JavaScript y pude ver cómo los aspectos básicos de mi idea funcionaron rápidamente.

Luego, algo ocurrió. No podía dejar de tener ideas acerca de cómo deseaba evolucionar mi aplicación, pero necesitaba una biblioteca de visualización versátil, un método para visualizar los datos de otro modo como gráficos o gráficos circulares. Después de buscar, encontré D3.

Jason Davies creó una extensión de nube de palabras en la biblioteca D3 JavaScript. Él brinda un ejemplo y una descripción excelentes. Después de muchos intentos, descubrí cómo sustituir los diferentes colores para las palabras de la nube. (Busqué hermosas combinaciones de colores de nubes de palabras, pero encontré ejemplos difíciles de hallar, por lo que me motivé a experimentar y probar algunas combinaciones atractivas).

Hice una matriz de temas y programé una pequeña rutina para elegir un color del tema al azar cada vez que se escribe una palabra. Al experimentar, decidí que me gustaba un máximo de cinco colores complementarios en un tema e incluí un pequeño componente de IU para elegir un tema. Deseaba poder ofrecer un tema de tipo papel periódico simple por ejemplo, dado que una persona puede descargar una nube para incluirla en un documento. Esto ayuda a tener un tema monótono, pero puede utilizar otros colores. Me gusta el anaranjado que se mostró anteriormente.

Para los datos, programé el código Node.js en el servidor para recopilar las biografías y analizar las palabras más frecuentes. Después de experimentar, 70 palabras se sintieron visualmente atractivas para una distribución equilibrada de datos, aún así no son demasiadas palabras como para abrumar. El servidor devuelve los datos y se dibuja la nube de palabras.

function draw(data, bounds) {
  statusText.style("display", "none");
  scale = bounds ? Math.min(
      w / Math.abs(bounds[1].x - w / 2),
      w / Math.abs(bounds[0].x - w / 2),
      h / Math.abs(bounds[1].y - h / 2),
      h / Math.abs(bounds[0].y - h / 2)) / 2 : 1;
  words = data;
  var text = visualisation.selectAll("text")
      .data(words, function(d) { return d.text.toLowerCase(); });
  text.transition()
      .duration(1000)
      .attr("transform", function(d) { return "translate(" + [d.x, d.y] + ")rotate(" + d.rotate + ")"; })
      .style("font-size", function(d) { return d.size + "px"; });
  text.enter().append("text")
      .attr("text-anchor", "middle")
      .attr("transform", function(d) { return "translate(" + [d.x, d.y] + ")rotate(" + d.rotate + ")"; })
      .style("font-size", function(d) { return d.size + "px"; })
      .on("click", function(d) {
        load(d.text);
      })
      .style("opacity", 1e-6)
    .transition()
      .duration(1000)
      .style("opacity", 1);
  text.style("font-family", function(d) { return d.font; })
      .style("fill", customFill)
      .text(function(d) { return d.text; });
  var exitGroup = background.append("g")
      .attr("transform", visualisation.attr("transform"));
  var exitGroupNode = exitGroup.node();
  text.exit().each(function() {
    exitGroupNode.appendChild(this);
  });
  exitGroup.transition()
      .duration(1000)
      .style("opacity", 1e-6)
      .remove();
  visualisation.transition()
      .delay(1000)
      .duration(750)
      .attr("transform", "translate(" + [w >> 1, h >> 1] + ")scale(" + scale + ")");
}

Conclusión

Mi código incluye muchas complejidades. Apunta a ser una aplicación genuina que todos pueden utilizar. Por lo tanto, manejo casos de error; gestiono tokens de autenticación; habilito cambios para ver la lista de usuarios que una persona sigue así como a sus seguidores, tweets y favoritos; respondo si la página se carga en un teléfono; y proporciono muchas otras funciones.

En este tutorial, me concentro en algunos bloques de construcción importantes (indicadores de la base de datos, autenticación y visualización) que le brindan la base para construir aplicaciones similares. El resto de los detalles están en el código, por si tiene curiosidad.

En mi artículo relacionado, Lo que me dicen los seguidores de twitter acerca de mis candidatos de elección, uso mi herramienta para ver mis perfiles de candidatos de elección en la elección reciente de Ontario.

El asunto de la identidad de las redes sociales es fascinante. Planeo construir muchas cosas más en este experimento de software y seguir agregando con el tiempo.


Recursos para Descargar


Temas relacionados


Comentarios

Inicie Sesión o Regístrese para agregar comentarios.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=Cloud computing
ArticleID=1013005
ArticleTitle=Cree una herramienta para analizar perfiles de Twitter utilizando Node.js, Mongo y D3
publish-date=08112015