Autor

Cristina Heredia

Outlier y graduada en Ing. Informática en la ugr. Computer science.

Más artículos de Cristina Heredia

En este post vamos a explorar nuestra comunidad de Github, considerando nuestros amigos (nuestros seguidores) en esta red social. En primer lugar daremos algunas indicaciones para crear una aplicación y empezar a usar la API de github. Después extraeremos la información que necesitamos para realizar nuestro análisis, y así obtener que lenguajes de programación son más usados por nuestros amigos, y cuales los menos usados. ¡Exploremos la popularidad de los lenguajes en nuestra comunidad!

1. Crear la app, instalar paquetes, autenticarse

1.1 Registrar la app

Antes de nada, ya que queremos acceder a datos públicos de github, ncesitaremos registrar una app con autenticación para ello. Esto nos permitirá no tener límite de llamadas a la API. Así que dirígete a github developer program page y clica en Register now. Luego, selecciona una cuenta (debe aparecer un listado de tus cuentas de github) y en la pestaña de Personal settings selecciona Authorized applications.

Si ya tienes una aplicación autorizada para acceder a la API de github, deberás visualizarla aquí. Sino tienes ninguna app registrada aún, vete a OAuth applications (bajo Personal settings) y selecciona Register a new application.

Ahora tienes que registrar tu nueva app, darle un nombre, una descripción… completa los campos y en Callback URL introduce: localhost:1410, que es la url a la que github devolverá cuando se autentique la app.

Ahora que tienes registrada tu app, se generarán su Client ID y Client Secret. Puedes verlos en OAuth applications -> Your App. Recuerda mantenerlos siempre en secreto y a salvo.

¡Bien! pues ya eres miembro del programa de developers. Lo siguiente que haremos es instalar los paquetes de R que vamos a usar para trabajar.


Ayúdanos a seguir escribiendo


1.2 Instalación de paquetes

Usaremos la versión 3 de la API de GitHub para obtener los datos github v3 API. Ya que la API devuelve los datos en formato JSON, vamos a usar la función fromJSON, que nos permitirá usar la url de la API directamente y nos parsea los datos JSON devueltos en formato dataframe. Ésta función se encuentra en el paquete jsonlite, así que tenemos que instalar ese paquete si no lo tenemos ya instalado:

install.packages('jsonlite')

Si no tienes instalado el paquete stringr, instálalo tal como acabamos de hacer con jsonlite. Lo usaremos para hacer operaciones comunes con strings. Instala también ggplot2 si no lo tienes instalado. Lo usaremos para las gráficas y httpuv, un paquete para poder trabajar con HTTP.

Para conectarse a la app the github, necesitaremos instalar el paquete rgithub. Puedes hacerlo directamente desde el código fuente en github. Date cuenta que depende del paquete devtools:

require(devtools)
install_github("cscheid/rgithub")

Tras la instalación, carga las librerías:

# load libraries
library(github)
library(jsonlite)
library(stringr)
library(ggplot2)

1.3 Autentica el acceso

Necesitaremos autenticar el acceso, y lo haremos a través de la función interactive.login del paquete rgithub, pasándole nuestro ID y secreto. Mi recomendación es que pongas estas líneas en un fichero separado y no las compartas con nadie. Sólo haz un source del fichero cuando necesites autenticarte o ejecuta las líneas de nuevo.

# github app autentication
clientID<-"your_client_id_goes_here"
clientSecret<-"your_secret_goes_here"
context<-interactive.login(clientID,clientSecret)

2. Obtener la información de tus amigos

Ya estás autenticado. Lo que sigue es obtener tus seguidores de GitHub. Para obtener los usuarios que nos siguen e información sobre ellos, usaremos la función get.my.followers:

# get your followers
myFollowers<-get.my.followers(context)

Podemos comprobar fácilmente cuantos seguidores tenemos usando la función length:

# get number of my followers
numFollowing<-length(myFollowers$content)

Ahora que tenemos nuestros seguidores, vamos a crear un dataframe para guardar toda la información obtenida. Primero, extraemos cada línea de contenido de la lista de myFollowers, y la vamos añadiendo a una variable dataset usando la función rbind:

# create a dataset with your followers
dataset<-unlist(myFollowers$content[[1]])

for(i in 2:length(myFollowers$content)){
  dataset<-rbind(dataset,unlist(myFollowers$content[[i]]))
}

Ahora que tenemos el dataframe, nombra a las columnas como se llamaban originalmente en myFollowers$content y guárdalo en un csv para poder reutilizarlo:

# create a data frame and save it for later use
dataset<-unname(dataset)
dataset<-as.data.frame(dataset)
colnames(dataset)<-c(names(myFollowers$content[[1]]))
write.csv(dataset,file="CrisFollowers.csv")

Obviamente lo puedes guardar con el nombre que quieras. Pero no olvides la extensión.

3. Obtener la información de los repositorios de tus amigos y crear un nuevo conjunto de datos

Como ya te habrás percatado, en los últimos datos que extraímos había información acerca del nombre de nuestros seguidores, su id, avatar, tipo… y algunas url de interés. Sin embargo, en esa información no aparecía la información de los repositorios que necesitamos para nuestro análisis, como nombres de los repositorios, lenguaje de los repositorios, número de líneas de código…

Debemos obtener esa información. Si has explorado un poco el dataset, te habrás dado cuenta de que existe una columna, llamada repos_url que nos dice que la url para obtener los repositorios dado un usuario cualquiera, es: https://api.github.com/users/user/repos. Por ejemplo, para obtener la información de cuales son mis repositorios, etc, deberemos llamar a la API https://api.github.com/users/CritinaHG/repos , y obtendremos los datos que queremos en formato JSON.

Así que obtendremos esos datos para cada usuario leyendo el dataset que creamos anteriormente, obteniendo de él los nombres de nuestros seguidores, componiendo la correspondiente url de sus repos y parseando los datos obtenidos de la API usando la función fromJSON:

# read latest created csv
myFriends<-read.csv("CrisFollowers.csv")

# extract the names
unname<-as.character(myFriends$login)

# extract data from friends' public repositories
compdata<- NULL

for(i in 1:nrow(myFriends)){
  data<-fromJSON(paste0("https://api.github.com/users/",str_trim(unname[i],side = "both"),"/repos?clientID&clientSecret"))
  if(length(data)!=0){
    data<-data[,-4]
    compdata<-rbind(compdata,data)
  }
}

# write data for reuse
write.csv(compdata,"UsersWithRepoInfo.csv")

Debes sustituir clientID y clientSecret por el id y secreto de tu app, generados al principio del post. No es necesario especificarle estos parámetros, pero hacerlo nos permite evitar limitaciones en las peticiones. Se elimina la 4º columna porque contiene información redundante, y se usa rbind para ir agregando los datos que se van obteniendo al nuevo dataset.

4. Haciendo un poco de procesamiento

Lee (si no tienes leído) el dataset activeFriends<-read.csv("UsersWithRepoInfo.csv"). Vamos a hacerle algunas transformaciones a los datos para hacerlos más manejables con R.

En primer lugar, como la zona horaria es UTC+2 (o la de Madrid), necesitamos establecer el parámetro timezone. Construimos una función para realizar el formateo y lo aplicamos a cada columna con fechas del dataset:

# make date format supported by R
date.format<-function(datestring){
  date<-as.POSIXct(datestring,format="%Y-%m-%d %H:%M:%S",tz="Europe/Madrid", usetz=TRUE)
}

# update dates with new format
activeFriends$created_at<-date.format(activeFriends$created_at)
activeFriends$updated_at<-date.format(activeFriends$updated_at)
activeFriends$pushed_at<-date.format(activeFriends$pushed_at)

Siéntete libre de explorar el conjunto de datos. Seguro que estás pensando que en él hay columnas que nos interesan para nuestro análisis, y otras que no tanto. Lo siguiente que haremos será seleccionar las que más nos interesan para nuestro análisis:

# selecting just the interesting cols
activeFriends<-activeFriends[,c("id","name","full_name","private","description","fork","created_at","updated_at","pushed_at","homepage","size","stargazers_count","watchers_count","language",                             "has_issues","has_downloads","forks_count","open_issues_count","forks","open_issues","watchers")]

Podemos binarizar las columnas que tienen solo valores True o False:

activeFriends$private<-as.integer(activeFriends$private)
activeFriends$has_issues<-as.integer(activeFriends$has_issues)
activeFriends$fork<-as.integer(activeFriends$fork)
activeFriends$has_downloads<-as.integer(activeFriends$has_downloads)

Por último, la columna full_name contiene el nombre de usuario junto con el nombre del repositorio. Extraemos de aquí sólo el nombre de usuario, pues el nombre del repositorio ya se incluye en la columna name. Lo hacemos separando cada item por la barra que separa los nombres, y tomando el primer elemento:

# Getting the username
activeFriends$full_name<-unlist(lapply(strsplit(as.character(activeFriends$full_name),split = '/',fixed = TRUE),function(x) (x[1])))

Guárdalo si quieres, para reutilizarlo más tarde.

5. Analizando la popularidad de los lenguages de programación

Podemos hacernos una primera idea de cómo están distribuidos los datos, cual es la media, mediana, máximo, mínimo… para cada columna, usando la función summary en el dataset. Éste es sólo un ejemplo parte de la salida de esta función que se obtiene para mi comunidad de amigos, mostrando las métricas mencionadas para las primeras columnas:

summary(activeFriends)
       id                 name      full_name            private                                                                      description
Min.   : 2054512   IV      :  4   Length:524         Min.   :0   Asignatura de infraestructuras virtuales para el Grado de Informática     :  4
1st Qu.:32878832   blog    :  3   Class :character   1st Qu.:0   Repositorio para la asignatura Infraestructura Virtual de 2016-2017       :  3
Median :51252063   DAI     :  3   Mode  :character   Median :0   An example repo in Ruby for continuous integration with Travis CI         :  2
Mean   :51191269   IV16-17 :  3                      Mean   :0   Curso de LaTeX organizado por AMAT para alumnos de Trabajo de Fin de Grado:  2
3rd Qu.:70082791   swap1415:  3                      3rd Qu.:0   Diferentes scripts para representación de carreras en cifras              :  2
Max.   :88848228   TFG     :  3                      Max.   :0   (Other)                                                                   :404
                   (Other) :505                                  NA's                                                                      :107

Ahora vamos al tema que nos concierne: ver que lenguajes de programación se están usando en nuestra comunidad de amigos, y cuánto se usan. Para este cometido, podemos comenzar por crear una tabla de contingencia, para dar un primer vistazo a nuestra respuesta:

languagesAndUse<-table(activeFriends$language)
languagesAndUse

         Arduino                C               C#              C++            CLIPS              CSS             Dart
               1               13                7               55                5               19                2
      Emacs Lisp              GAP         GDScript               Go           Groovy          Haskell             HTML
               2                1                1                3                1                2               48
            Java       JavaScript Jupyter Notebook              Lex              Lua         Makefile      Mathematica
              60               67                3                1                1                6                2
             PHP       PostScript           Prolog           Python                R             Ruby            Scala
               8                2                1               56               12               24                1
           Shell              TeX       TypeScript
               7               38                1

Con nrow(languagesAndUse) podemos ver el número de lenguages diferentes que se están usando en nuestra comunidad de amigos. En la mía son 31. También podemos apreciar que hay muchos repos con código JavaScript entre mis 30 amigos, sin embargo, parece que Scala, Lua, Arduino, TypeScript, Groovy, Lex, Prolog, GDScript… sólo son usados por una persona.

Finalmente, usamos qplot del paquete ggplot2 para crear un hibstograma que represente el uso de los lenguajes de programación en nuestra comunidad de github:

languages<-na.omit(activeFriends$language)
langUssage<-qplot(languages,geom = "bar",xlab = "Language", ylab="Usage",fill=I("cornflowerblue"))
langUssage+theme(axis.text.x = element_text(angle = 90,hjust = 1)) +ggtitle("Programming languages used by my friends")+theme(plot.title = element_text(hjust = 0.5))

Donde usamos na.omit para omitir de la representación de los datos los valores NA (lenguajes que no se hayan podido extraer). El hibstograma resultante es el siguiente:

Lenguajes usados en mi comunidad de github

Así que, como podemos ver en la representación, JavaScript es el lenguage más usado, habiendo 67 repos en total en mi comunidad de amigos que contienen código JavaScript. También Java, C++ y Python son muy populares en mi comunidad.

Encontramos código Tex en 38 repositorios, por lo que LaTeX está bastante presente en mi comunidad de amigos. También hay muchos repos con código HTML, y muchos menos con código CSS, Ruby, R and C. Tras ellos, lenguages conocidos pero no amados por muchos, como PHP, C# o CLIPS, que están presentes en menos de 10 repositorios.

Por último, se puede aprecidar que hay menos de 5 repositorios en total con código Dart, Go,Haskell, Jupyter, PostScript y Mathematica, y que sólo hay un usuario de mi comunidad usando Scala, Groovy, Lua o TypeScript. Ésto responde a mi pregunta, ya que, como mi lengugaje favorito es Scala, quería saber cuántos de mis seguidores lo usaban.

Y bueno, ¿Qué sucede en tu comunidad de amigos? ¿Se usan los mismos lenguajes que en la mía? ¿Sigue Siendo JavaScript el más usado?

Referencias:

Categorías:Etiquetas:

Quizá también te interese leer...