Jesus M. Gonzalez-Barahona

The talk will explain how to analyze software development with GrimoireLab. It will show with simple code how easy it is to retrieve data from git, Bugzilla, GitHub, mailing lists, StackOverflow, Gerrit, IRC, Slack, and many other repositories. Then, with the same toolkit, the data will be organized in ElasticSearch indexes, visualized in actionable dashboards, and summarized in reports. Some advanced analysis will also be presented on how to exploit the data using Python/Pandas and IPython/Jupyter Notebooks. The talk will be complemented with interesting insights on real FOSS projects.

Many free / open source software (FOSS) projects feature an open development model, with public software development repositories which anyone can browse. These repositories are normally used to find specific information, such a certain commit or a particular bug report. But they can also be mined to extract all relevant data, so that it can be analyzed to learn about any aspect of the project. This talk will explain the GrimoireLab method for doing that, which is based on organizing all that information in a database, which can be later analyzed. This approach allows for minimal impact on the project infrastructure, since data is retrieved only once, even if it later analyzed many times. It allows as well for efficiency and comfort when mining data for an analysis, since the results are readily available, databases can be shared and replicated at will, and queried them with any kind of tools is easy.

The tools that retrieve information from the repositories are grouped in the GrimoireLab toolset. It includes mature, widely tested programs capable of extracting information from most repositories used by FOSS projects of any scale. Many of them are agnostic with respect to the database used, although currently ElasticSearch is the best supported.

The produced databases can be exploited in several ways, of which two will be explained during the talk: using Python/Pandas to produce IPython/Jupyter Notebooks which analyze some aspect of the project; and using Python to feed a ElasticSearch cluster, with a Kibana front-end for visualizing in a flexible, powerful dashboard.

All these approaches can be used to understand general aspects of the project, such as how efficient are the code review or bug fixing processes, how diverse are contributions to the git repository, or how conversations in mailing lists or StackOverflow are shaped. But they can be used as well to drill down, and analyze the contributions by a certain developer, or the longer code review processes, or the contents of the most lively email and QA threads.

The talk will explain the whole process from data retrieval to visualization, and will show some specific cases of real world use, such as the dashboards produced for Eclipse, OPNFV, MediaWiki and many others. Some of the contents of the talk are described in detail in the online book GrimoireLab Training.

GrimoireLab is on of the systems produced by the CHAOSS Collaborative Project.

• GrimoireLab

• GrimoireLab Training

• OpenDayLight GrimoireLab Dashboard

• OPNFV GrimoireLab Dashboard

• Wikimedia GrimoireLab Dashboard

• CHAOSS Collaborative Project

The talk will explain how to analyze software development repositories of common use in the free software community with [GrimoireLab tools][http://grimoirelab.github.io], a toolset for software development analytics writting in Python. It will start by explaining how to retrieve data from git, Bugzilla, GitHub, mailing lists, StackOverflow, Gerrit, and many other repositories by, and organizing it in a database. The talk will later explain how this database can be exploited with several components of the toolset, for different purposes. In this context, special attention will be given to how to extract useful information from it using Python/Pandas and iPython/Jupyter Notebooks; and how to use ElasticSearch/Kibana to deploy actionable dashboards that show data in all its glory.

Many free / open source software (FOSS) projects feature an open development model, with public software development repositories which anyone can browse. These repositories are normally used to find specific information, such a certain commit or a particular bug report. But they can also be mined to extract all relevant data, so that it can be analyzed later to learn about any specific or general aspect of the project. This talk will explain the GrimoireLab method for doing that, which is based on organizing all that information in a database, which can be later analyzed. This approach allows for minimal impact on the project infrastructure, since data is retrieved only once, even if it later analyzed many times. It allows as well for efficiency and comfort when mining data for an analysis, since the results are readily available, databases can be shared and replicated at will, and queried them with any kind of tools is easy.

The tools that retrieve information from the repositories are grouped in the GrimoireLab toolset. It includes mature, widely tested programs capable of extracting information from most repositories used by FOSS projects of any scale. Many of them are agnostic with respect to the database used, although currently ElasticSearch is the best supported.

The produced databases can be exploited in several ways, of which two will be explained during the talk: using Python/Pandas to produce iPython/Jupyter Notebooks which analyze some aspect of the project; and using Python to feed a ElasticSearch cluster, with a Kibana front-end for visualizing in a flexible, powerful dashboard.

All these approaches can be used to understand general aspects of the project, such as how efficient are the code review or bug fixing processes, how diverse are contributions to the git repository, or how conversations in mailing lists or StackOverflow are shaped. But they can be used as well to drill down, and analyze the contributions by a certain developer, or the longer code review processes, or the contents of the most lively email and QA threads.

The talk will explain the whole process from data retrieval to visualization, and will show some specific cases of real world use, such as the dashboards produced for Eclipse, OPNFV, MediaWiki and many others. Some of the contents of the talk are described in detail in the online book GrimoireLab Training.

The Document Foundation Development Dashboard shows detailed data about how LibreOffice is being developed. It also allows for drilling down, filtering, and understanding it. The talk will explore some of these possibilities, by showing how to look for specific data, for customizing the results, and for sharing the results with others.

The Document Foundation Development Dashboard visualizes data obtained from some systems used to support LibreOffice development: git, Gerrit, Bugzilla... The data is retrieved from them, stored, organized an massaged in a database, and later visualized in the dashboard. The dashboard allows not only to browse the data, but also to drill down and play with it. The dashboard permits to track activity (in commits, issues, pull requests, questions and answers, etc.), actors (who is creating the code, who is fixing bugs, who is answering questions), and processes (hot long does it take to close issues, or to accept pull requests).

The Document Foundation Development Dashboard has been deployed using GriomoireLab, an complete FOSS system for retrieving data from software development repositories, storing it, and producing different kinds of analytics, dashboards and reports.

The talk will explain how to interact with the data provided by the dashboard for finding any detail of interest. The talk will also provide hints on how to exploit the data behind the dashboard to obtain specific information.

The LibreOffice project has become a large software development project. To better understand how it is being developed, a software development analytics dashboard has been deployed for it. This dashboard tracks most of the public data about LibreOffice development, and it allows to visualize, drill down and understand that data. The talk will present this dashboard, and will explain how to interpret the data it provides.

The Document Foundation Development Dashboard visualizes data obtained from some systems used to support LibreOffice development: git, Gerrit, Bugzilla... The data is retrieved from them, stored, organized an massaged in a database, and later visualized in the dashboard. The dashboard permits to track activity (in commits, issues, pull requests, questions and answers, etc.), actors (who is creating the code, who is fixing bugs, who is answering questions), and processes (hot long does it take to close issues, or to accept pull requests).

The Document Foundation Development Dashboard has been deployed using GriomoireLab, an complete FOSS system for retrieving data from software development repositories, storing it, and producing different kinds of analytics, dashboards and reports.

The Rust project has become a large software development project. To better understand how it is being developed, a software development analytics dashboard has been deployed for it. This dashboard tracks most of the public data about Rust development, and allows to visualize, drill down and understand that data. The talk will present this dashboard, and how to use it to learn about the details of Rust development processes and community. It will also present some interesting data obtained from it.

The Rust software development dashboard visualizes data obtained from some systems used to support Rust development: git, GitHub, StackOverflow... The data related to Rust is retrieved from them, stored, organized an massaged in a database, and later visualized in the dashboard. The dashboard allows not only to browse the data, but also to drill down and play with it. This way, any person interested in how Rust is being developed can have both an general overview, or very detailed views of the community and processes involved. The dashboard permits to track activity (in commits, issues, pull requests, questions and answers, etc.), actors (who is creating the code, who is fixing bugs, who is answering questions), and processes (hot long does it take to close issues, or to accept pull requests).

The Rust Development Dashbard has been deployed using GriomoireLab, an complete FOSS system for retrieving data from software development repositories, storing it, and producing different kinds of analytics, dashboards and reports.

The talk will present the different kind of information that can be obtained from the dashboard, and how to interact with it for finding any detail of interest. Several specific aspects of Rust development will be presented as well, so that people attending may expect to finish the talk with a better understanding of how Rust is being developed. The talk will also provide hints on how to exploit the data behind the dashboard to obtain specific information.

If you have 15 minutes, in this talk you can learn how to explore data from git or Gerrit repositories, using a Kibana-based dashboard. The talk will explain how to retrieve the data from the repositories, how to visualize different aspects of it, and how to produce a dashboard with those visualization. The dashboard, once composed, allows for selective filtering, drilling-down, and in general, knowing about the internals of a free, open source software project at any level of detail. Is there a better way of spending 15 minutes?

Free, open source software (FOSS) projects with an open development model offer a great deal of data in their public development repositories. Among them, git and Gerrit are some of the most common. That data can be retrieved and analyzed to learn about how the project is working. Who is contributing, who is reviewing code, how much time they spend in code review, etc.

Once an arcane art, analyzing these repositories is today becoming more and more easy for anyone. In this talk, I will show how the data can be extracted from the repositories, and how once it is stored in a database, it can be easily analyzed. As an example, ElasticSearch will be used as database, and Kibana as the tool to produce analytics dashboards. Both are FOSS products, easy to install, which allows anyone, even with basic skills, to reproduce the procedure presented in the talk.

But even when the procedure is simple, and the tools used in it are FOSS and readily available, the dashboards produced are rich, and allow for detailed drill down. Some examples of the dashboards that can be produced are:

• http://s.bitergia.com/db-openstack-git
• http://s.bitergia.com/db-openstack-gerrit

Some more information about how to use and produce these dashboards can be found in the Bitergia blog, http://blog.bitergia.com.

Many FOSS projects have a carefully designed governance. But to which extent that governance fits the real inner life of the project? In this talk I will present some ways of measuring to which extent governance may be subverted (or not) by real practices, how that can be detected, and tracked. From this base, I will show how a continuous tracking of those behaviors can contribute to a more fair development community, and to increase the trust in the project. The discussion will be framed by the concept of "open development analytics".

Many FOSS projects have developed governance rules. Specially when companies are involved, those rules model the ethos of the project. They may try to avoid, for example, that a single company controls the main aspects of the development process. Or that independent developers are treated equal than those employed by companies. Or that the "old generation" doesn't have an overwhelming weight in decisions. Usually, those rules define governing bodies, how they are elected, and which binding rules those bodies may produce. Therefore, governance is enforced as a kind of "law" for the project.

But you have law, and you have reality. In the case of FOSS projects, you have bylaws, governing bodies, approved codes... and then you have tools, development practices, and developers. The fact that most of the development actions are mediated by tools allows for the examination of what is happening in the project. From there, you can learn to which extent that conforms with the governance envisioned. In other words, tools can be examined, to see to which extent the reality of the project fits what the project wanted them to be.

The talk will show how using simple software development analytics some specific areas can be analyzed from this point of view. For example, a good proxy for who soft-controls a project is who is contributing to it (authoring code, reviewing code, closing tickets, participating in discussions). A good proxy to how fair it is to developers is how they are treated in the code review process when they propose changes. And that way, several metrics can be defined to help understand what is really going on.

All of this will be framed using the concept of "open development analytics". Open development analytics can be understood as a step forward in project transparency and community openness. They can be used to provide useful about how the project is really behaving, so that anyone can detect problems and deviations from the intended behavior. I will explain how this makes the project more resilient, its supporting community more self-aware, and helps increase trust by third parties.

Free / open source software projects are producing, as a byproduct of their usual activity, a great deal of data about how they develop software, and about how their community coordinates. Development and community metrics can be derived from this information, which can be later visualized in project development dashboards. The talk will show how tools in the *Grimoire toolset can be easily used to build those dashboards, from data retrieval up to analysis and visualization. As examples, dashboards for real projects, such as OpenStack, Puppet and MediaWiki, will be used to show how to interpret the data, and get insight about their development processes and their community. Examples of specific areas in which metrics are useful to track important parameters of the project will also be explored in detail, such as code review performance, time to close tickets, or the structure of the community.

FLOSS (free, libre, open source software) projects are usually developed in the open. A lot of information about their inner life is available in their development repositories: source code management (aka version control), issue tracking (aka bug reporting) systems, mailing lists, IRC channel logs, etc. This information can be organized and analyzed, and be used to gain understanding about how the project is performing, about the processes their developers are using, and in general about how it is evolving.

The kind of quantitative analytics that can be obtained from these repositories allow also for a direct tracking of several parameters that can characterize specific aspects of software development. The impact of changes in project policies or uses can therefore be evaluated quantitatively, and be observed and tracked.

Fortunately, having these analysis done for a given FLOSS project is becoming an easy task. Some web-based services, such as Ohloh, are already producing some of them, and some platforms, such as GitHub and Jira, also allow for tracking some parameters. In this talk we will present Grimoire, a FLOSS platform allowing anyone to do their own metrics dashboard, from data retrieval from repositories to analysis and visualization of the parameters of interest. Grimoire is composed of two main components: MetricsGrimoire, a set of Python tools supporting most common development and community repositories, and vizGrimoire, which provides an R package and a JavaScript library for analyzing and visualizing the data.

As a part of the talk, the whole process of how to analyze repositories using *Grimoire will be briefly described. As case examples, some well known projects, such as OpenStack, Puppet or MediaWiki, will be explored based on the information from their dashboards, which are already being used by their communities. In addition, specific areas in which metrics are useful to track important parameters of the project will also be explored.

More information about MetricsGrimoire

More information about vizGrimoire

Some of the dashboards that will be presented in the talk are:

• OpenStack Development Dashboard

• MediaWiki Community Dashboard

An introduction to MetricsGrimoire and vizGrimoire

The talk provides a technical view of how to use, extend and contribute to the Metrics-Grimoire project, which produces a set of tools that can be used to analyze many kinds of software development repositories, from git or Subversion to Bugzilla, Jira or the SourceForge, GitHub and Launchpad issue trackers. Some related tools (from the vizGrimoire toolset) allow for different kinds of analysis and visualization of the retrieved data. When combined, quantitative data and charts about many different aspects of any free software project can be obtained, gaining knowledge about its evolution, performance, community, source code structure, etc. Being all the tools free software, the limit for the kind of analysis and visualizations is only the imagination.

FLOSS (free, libre, open source software) projects are usually developed in the open. A lot of information about their inner life is available in their development repositories: source code management (aka version control), issue tracking (aka bug reporting) systems, mailing lists, etc. This information can be organized and analyzed, and be used to gain understanding about how the project is performing, about the processes their developers are using, and in general about how it is evolving.

The kind of quantitative analytics that can be obtained from these repositories allow also for a direct tracking of several parameters that can characterize specific aspects of software development. The impact of changes in project policies or uses can therefore be evaluated quantitatively, and be observed in retrospective.

There are some websites that allow for some of these analysis, and some tools for supporting software development are also starting to offer some functionality along this line. But a more complete, holistic, flexible and customizable option is available: a set of free software tools that can extract information and metainformation from the most widely used kinds of software development repositories, store it in a database, and produce data and visualizations out of it. This talk will present it: the MetricsGrimoire toolset and its friends.

The Metrics-Grimoire project provides a set of tools that can be used to analyze many kinds of software development repositories, from git or Subversion to Bugzilla, Jira or the SourceForge, GitHub and Launchpad issue trackers. Some related tools allow for different kinds of analysis and visualization of the retrieved data. Being all the tools free software, the limit for the kind of analysis and visualizations is only the imagination.

The talk will provide a technical view of the tools (written mainly in Python), how they can be used and extended, and how we're using them to produce detailed analysis about several free software projects.

The main tools that will be introduced are:

<ul> <li>CVSAnalY, which currently supports CVS, SVN and Git, while Bazaar and Mercurial are in the roadmap. </li> <li>Bicho, currently supporting Bugzilla and the Google Code, GitHub, Jira, Launchpad, and Allura trackers. </li> <li>MailingListStats, currently supporting files in mbox format and Mailman web-accesible archives. </li> <li>VizGrimoire, a set of R scripts and JavaSript code to analyze and visualize the databases produced by the former tools. </li> </ul>

With all these tools working together, automatic and semi-automatic analysis of software development projects is possible, at least to a certain extent. Developers can tailor and adapt them to suit their specific needs, track the parameters they are interested in, and analyze the specific aspects of their pet projects that they may want.

Some questions that could be answered by this combined use of the tools are:

<ul> <li>How has evolved the time-to-fix for bug reports over the whole history of a project? </li> <li>How technical decisions affect attraction of new developers, time-to-attend for bug reports, or time to review changes to code? </li> <li>How can it be done a dynamic visualization of the evolution of a project?. </li> </ul>

The talk will show how in fact it is easy to have answers to this questions, with some practical examples of the analysis of real projects.