Development History Granularity Transformations (N)

Development histories can simplify some software engineering tasks, butdifferent tasks require different history granularities. For example, a history that includes every edit that resulted in compiling code is needed when searching for the cause of a regression, whereas a history that contains only changes relevant to a feature is needed for understanding the evolution of the feature. Unfortunately, today, both manual and automated history generation result in a single-granularity history. This paper introduces the concept of multi-grained development history views and the architecture of Codebase Manipulation, a tool that automatically records a fine-grained history and manages its granularity by applying granularity transformations.

[1]  Stas Negara,et al.  Is It Dangerous to Use Version Control Histories to Study Source Code Evolution? , 2012, ECOOP.

[2]  Zhongxian Gu.  Capturing and exploiting fine-grained IDE interactions , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[3]  Andreas Zeller,et al.  Change Bursts as Defect Predictors , 2010, 2010 IEEE 21st International Symposium on Software Reliability Engineering.

[4]  David Hovemeyer,et al.  Software repository mining with Marmoset , 2005, MSR.

[5]  Shinji Kusumoto,et al.  Hey! are you committing tangled changes? , 2014, ICPC 2014.

[6]  Daniel M. Germán,et al.  An empirical study of fine-grained software modifications , 2004, 20th IEEE International Conference on Software Maintenance, 2004. Proceedings..

[7]  Martin Erwig,et al.  A calculus for modeling and implementing variation , 2012, GPCE '12.

[8]  Brad A. Myers,et al.  A longitudinal study of programmers' backtracking , 2014, 2014 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC).

[9]  Elliot Soloway,et al.  Where the bugs are , 1985, CHI '85.

[10]  Stas Negara,et al.  Use, disuse, and misuse of automated refactorings , 2012, 2012 34th International Conference on Software Engineering (ICSE).

[11]  Yuriy Brun,et al.  Early Detection of Collaboration Conflicts and Risks , 2013, IEEE Transactions on Software Engineering.

[12]  Yuriy Brun,et al.  Proactive detection of collaboration conflicts , 2011, ESEC/FSE '11.

[13]  Jacky Chan,et al.  Supporting empirical studies by non-intrusive collection and visualization of fine-grained revision history , 2007, eclipse '07.

[14]  Miryung Kim,et al.  Discovering and representing systematic code changes , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[15]  Andreas Zeller,et al.  The impact of tangled code changes , 2013, 2013 10th Working Conference on Mining Software Repositories (MSR).

[16]  Daniela E. Damian,et al.  The promises and perils of mining GitHub , 2009, MSR 2014.

[17]  Brad A. Myers,et al.  Capturing and analyzing low-level events from the code editor , 2011, PLATEAU '11.

[18]  Boris Magnusson,et al.  Fine-grained revision control for collaborative software development , 1993, SIGSOFT '93.

[19]  Andreas Zeller,et al.  Simplifying and Isolating Failure-Inducing Input , 2002, IEEE Trans. Software Eng..

[20]  Frank Tip,et al.  Chianti: a tool for change impact analysis of java programs , 2004, OOPSLA.

[21]  Zhongxian Gu,et al.  Toward Effective Debugging by Capturing and Reusing Knowledge , 2013 .

[22]  Danny Z. Chen,et al.  A Consistency Model and Supporting Schemes for Real-time Cooperative Editing Systems , 1996 .

[23]  Brad A. Myers,et al.  Supporting Selective Undo in a Code Editor , 2015, 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering.

[24]  Ben Collins-Sussman,et al.  The subversion project: buiding a better CVS , 2002 .

[25]  Yuriy Brun,et al.  Making offline analyses continuous , 2013, ESEC/FSE 2013.

[26]  Harald C. Gall,et al.  Does distributed development affect software quality? An empirical case study of Windows Vista , 2009, 2009 IEEE 31st International Conference on Software Engineering.

[27]  Andreas Zeller,et al.  Yesterday, my program worked. Today, it does not. Why? , 1999, ESEC/FSE-7.

[28]  Aaron G. Cass,et al.  Modeling Dependencies for Cascading Selective Undo , 2005 .

[29]  Benjamin Livshits,et al.  DynaMine: finding common error patterns by mining software revision histories , 2005, ESEC/FSE-13.

[30]  Ayse Basar Bener,et al.  AI-Based Software Defect Predictors : Applications and Benefits in a Case Study , 2011 .

[31]  David Hovemeyer,et al.  An Eclipse-based course project snapshot and submission system , 2004, eclipse '04.

[32]  Andreas Zeller,et al.  Mining metrics to predict component failures , 2006, ICSE.

[33]  Stas Negara,et al.  Mining fine-grained code changes to detect unknown change patterns , 2014, ICSE.

[34]  Marsha Chechik,et al.  Semantic Slicing of Software Version Histories (T) , 2015, ASE.

[35]  Yuriy Brun,et al.  Reducing Feedback Delay of Software Development Tools via Continuous Analysis , 2015, IEEE Transactions on Software Engineering.

[36]  Daniel M. Germán,et al.  The promises and perils of mining git , 2009, 2009 6th IEEE International Working Conference on Mining Software Repositories.

[37]  Mark Mahoney.  The storyteller version control system: tackling version control, code comments, and team learning , 2012, SPLASH '12.

[38]  Andreas Zeller,et al.  Mining Version Histories to Guide Software Changes , 2004 .

[39]  Harald C. Gall,et al.  Change Distilling:Tree Differencing for Fine-Grained Source Code Change Extraction , 2007, IEEE Transactions on Software Engineering.

[40]  Udo Kelter,et al.  A fine-grained version and configuration model in analysis and design , 2002, International Conference on Software Maintenance, 2002. Proceedings..

[41]  Ayse Basar Bener,et al.  Defect prediction from static code features: current results, limitations, new approaches , 2010, Automated Software Engineering.