@conference {Izquierdo-Cortazar:2017:UMT:3084226.3084247,
	title = {Using Metrics to Track Code Review Performance},
	booktitle = {Proceedings of the 21st International Conference on Evaluation and Assessment in Software Engineering},
	series = {EASE{\textquoteright}17},
	year = {2017},
	pages = {214{\textendash}223},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {During 2015, some members of the Xen Project Advisory Board became worried about the performance of their code review process. The Xen Project is a free, open source software project developing one of the most popular virtualization platforms in the industry. They use a pre-commit peer review process similar to that in the Linux kernel, based on email messages. They had observed a large increase over time in the number of messages related to code review, and were worried about how this could be a signal of problems with their code review process.

To address these concerns, we designed and conducted, with their continuous feedback, a detailed analysis focused on finding these problems, if any. During the study, we dealt with the methodological problems of Linux-like code review, and with the deeper issue of finding metrics that could uncover the problems they were worried about. For having a benchmark, we run the same analysis on a similar project, which uses very similar code review practices: the Linux Netdev (Netdev) project. As a result, we learned how in fact the Xen Project had some problems, but at the moment of the analysis those were already under control. We found as well how different the Xen and Netdev projects were behaving with respect to code review performance, despite being so similar from many points of view.

In this paper we show the results of both analyses, and propose a comprehensive methodology, fully automated, to study Linux-style code review. We discuss also the problems of getting significant metrics to track improvements or detect problems in this kind of code review.},
	keywords = {code review, data mining, Software development analytics},
	isbn = {978-1-4503-4804-1},
	doi = {10.1145/3084226.3084247},
	url = {http://doi.acm.org/10.1145/3084226.3084247},
	author = {Izquierdo-Cortazar, Daniel and Sekitoleko, Nelson and Jesus M. Gonzalez-Barahona and Kurth, Lars}
}
@article {1324,
	title = {Are Developers Fixing Their Own Bugs?},
	journal = {International Journal of Open Source Software and Processes},
	volume = {3},
	year = {2011},
	note = {"The analysis is focused at the level of lines of code and it uses the information stored in the source code management system"},
	pages = {23 - 42},
	abstract = {The process of fixing software bugs plays a key role in the maintenance activities of a software project. Ideally, code ownership and responsibility should be enforced among developers working on the same artifacts, so that those introducing buggy code could also contribute to its fix. However, especially in FLOSS projects, this mechanism is not clearly understood: in particular, it is not known whether those contributors fixing a bug are the same introducing and seeding it in the first place. This paper analyzes the comm-central FLOSS project, which hosts part of the Thunderbird, SeaMonkey, Lightning extensions and Sunbird projects from the Mozilla community. The analysis is focused at the level of lines of code and it uses the information stored in the source code management system. The results of this study show that in 80\% of the cases, the bug-fixing activity involves source code modified by at most two developers. It also emerges that the developers fixing the bug are only responsible for 3.5\% of the previous modifications to the lines affected; this implies that the other developers making changes to those lines could have made that fix. In most of the cases the bug fixing process in comm-central is not carried out by the same developers than those who seeded the buggy code.},
	keywords = {bug fixing, developers, loc, scm},
	issn = {1942-3934},
	doi = {10.4018/jossp.2011040102},
	author = {Izquierdo-Cortazar, Daniel and Capiluppi, Andrea and Jesus M. Gonzalez-Barahona}
}
@article {1236,
	title = {Tools for the Study of the Usual Data Sources found in Libre Software Projects},
	journal = {International Journal of Open Source Software and Processes},
	volume = {1},
	year = {2009},
	month = {31/2009},
	pages = {24 - 45},
	abstract = {Due to the open nature of Free/Libre/Open Source software projects, researchers have gained access to a rich set of development-related information. Although this information is publicly available on the Internet, obtaining and analyzing it in a convenient way is not an easy task and many considerations have to be taken into account. In this paper we present the most important data sources that can be found in libre software projects and that are studied by the research community: source code, source code management systems, mailing lists and bug tracking systems. We will give advice for the problems that can be found when retrieving and preparing the data sources for a posterior analysis, as well as provide information about the tools that support these tasks.},
	keywords = {bug tracking systems, data sources, mailing lists, scm, tools},
	issn = {1942-3934},
	doi = {10.4018/jossp.2009010102},
	attachments = {https://flosshub.org/sites/flosshub.org/files/robles.pdf},
	author = {Gregorio Robles and Gonz{\'a}lez-Barahona, Jes{\'u}s M. and Izquierdo-Cortazar, Daniel and Herraiz, Israel}
}
@article {10.1109/HICSS.2009.1014,
	title = {Using Software Archaeology to Measure Knowledge Loss in Software Projects Due to Developer Turnover},
	journal = {2009 42nd Hawaii International Conference on System Sciences (HICSS 2009)},
	year = {2009},
	pages = {1-10},
	publisher = {IEEE Computer Society},
	address = {Los Alamitos, CA, USA},
	abstract = {Developer turnover can result in a major problem when developing software. When senior developers abandon a software project, they leave a knowledge gap that has to be managed. In addition, new (junior) developers require some time in order to achieve the desired level of productivity. In this paper, we present a methodology to measure the effect of knowledge loss due to developer turnover in software projects. For a given software project, we measure the quantity of code that has been authored by developers that do not belong to the current development team, which we define as orphaned code. Besides, we study how orphaned code is managed by the project. Our methodology is based on the concept of software archaeology, a derivation of software evolution. As case studies we have selected four FLOSS (free, libre, open source software) projects, from purely driven by volunteers to company-supported. The application of our methodology to these case studies will give insight into the turnover that these projects suffer and how they have managed it and shows that this methodology is worth being augmented in future research.},
	keywords = {attrition, case study, developers, evince, evolution, gimp, growth, knowledge collaboration, lines of code, nautilus, quality, sloc, turnover},
	isbn = {978-0-7695-3450-3},
	doi = {http://doi.ieeecomputersociety.org/10.1109/HICSS.2009.1014},
	attachments = {https://flosshub.org/sites/flosshub.org/files/07-07-08.pdf},
	author = {Izquierdo-Cortazar, Daniel and Gregorio Robles and Ortega, Felipe and Jesus M. Gonzalez-Barahona}
}
