Stephen W. Thomas | Publications

Main | Bio | Activities | Publications

Using Information Retrieval Models to Mine Software Repositories

• Explaining Software Defects Using Topic Models
  Tse-Hsun Chen, Stephen W. Thomas, Meiyappan Nagappan, and Ahmed E. Hassan
  Proceedings of the 9th Working Conference on Mining Software Repositories, 2012 (to appear).
  (abstract) (bib) (preprint)

  Researchers have proposed various metrics based on measurable aspects of the source code entities (e.g., methods, classes, files, or modules) and the social structure of a software project in an effort to explain the relationships between software development and software defects. However, these metrics largely ignore the actual functionality, i.e., the conceptual concerns, of a software system, which are the main technical concepts that reflect the business logic or domain of the system. For instance, while lines of code may be a good general measure for defects, a large entity responsible for simple I/O tasks is likely to have fewer defects than a small entity responsible for complicated compiler implementation details. In this paper, we study the effect of conceptual concerns on code quality. We use a statistical topic modeling technique to approximate software concerns as topics; we then propose various metrics on these topics to help explain the defect-proneness (i.e., quality) of the entities. Paramount to our proposed metrics is that they take into account the defect history of each topic. Case studies on multiple versions of Mozilla Firefox, Eclipse, and Mylyn show that (i) some topics are much more defect-prone than others, (ii) defect-prone topics tend to remain so over time, and (iii) defect-prone topics provide additional explanatory power for code quality over existing structural and historical metrics.

  @inproceedings{chen_explaining_2012,
title = {Explaining software defects using topic models},
booktitle = {Proceedings of the 9th Working Conference on Mining Software Repositories},
author = {T. Chen and S. W. Thomas and M. Nagappan and A. E. Hassan},
year = {2012},
}

  
  
  
• Mining Software Repositories with Topic Models
  Stephen W. Thomas
  Technical Report No. 2012-586, School of Computing, Queen's University, February 2012, 39+iv pages.
  (bib) (pdf)

  @techreport{thomas_mining_2012,
title = {Mining software repositories with topic models},
number = {2012-586},
institution = {School of Computing, Queen's University},
author = {S. W. Thomas},
year = {2012},
}

  
  
  
• Using Fuzzy Code Search to Link Code Fragments in Discussions to Source Code
  Nicolas Bettenburg, Stephen W. Thomas, and Ahmed E. Hassan
  Proceedings of the 16th European Conference on Software Maintenance and Reengineering, 2012.
  (abstract) (bib) (preprint)

  When discussing software, practitioners often reference parts of the project's source code. Such references have different motivations, such as mentoring and guiding less experienced developers, pointing out code that needs changes, or proposing possible strategies for the implementation of future changes. The fact that particular parts of a source code are being discussed makes these parts of the software special. Knowing which code is being talked about the most can not only help practitioners to guide important software engineering and maintenance activities, but also act as a high-level documentation of development activities for managers. In this paper we use clone-detection as specific instance of a code search based approach for establishing links between code fragments that are discussed by developers and the actual source code of a project. Through a case study on the Eclipse project we explore the traceability links established through this approach, both quantitatively and qualitatively, and compare code search based traceability linking to classical approaches, in particular change log analysis and information retrieval. We demonstrate a sample application of code search based traceability links by visualizing those parts of the project that are most discussed in issue reports with a Treemap visualization. The results of our case study show that the traceability links established through code search based traceability linking are conceptually different than classical approaches based on change log analysis or information retrieval.

  @inproceedings{bettenburg_modeling_2011,
title = {Using fuzzy code search to link code fragments in discussions to source code},
booktitle = {Proceedings of the 16th European Conference on Software Maintenance and Reengineering},
author = {N. Bettenburg and S. W. Thomas and A. E. Hassan},
year = {2012},
}

  
  
  
• Modeling the Evolution of Topics in Source Code Histories
  Stephen W. Thomas, Bram Adams, Ahmed E. Hassan, and Dorothea Blostein
  Proceedings of the 8th Working Conference on Mining Software Repositories, pages 173-182. Honolulu, HI, USA. May 21-22, 2011.
  (abstract) (bib) (pdf) (more info)

  Studying the evolution of topics (collections of co-occurring words) in a software project is an emerging technique to automatically shed light on how the project is changing over time: which topics are becoming more actively developed, which ones are dying down, or which topics are lately more error-prone and hence require more testing. Existing techniques for modeling the evolution of topics in software projects suffer from issues of data duplication, i.e., when the repository contains multiple copies of the same document, as is the case in source code histories. To address this issue, we propose the Diff model, which applies a topic model only to the changes of the documents in each version instead of to the whole document at each version. A comparative study with a state-of-the-art topic evolution model shows that the Diff model can detect more distinct topics as well as more sensitive and accurate topic evolutions, which are both useful for analyzing source code histories.

  @inproceedings{thomas_modeling_2011,
title = {Modeling the evolution of topics in source code histories},
booktitle = {Proceedings of the 8th Working Conference on Mining Software Repositories},
author = {S. W. Thomas and B. Adams and A. E. Hassan and D. Blostein},
pages = {173--182},
year = {2011},
}

  
  
  
• Mining Software Repositories with Topic Models
  Stephen W. Thomas
  Proceedings of the 33rd International Conference on Software Engineering (Doctoral Symposium), pages 1138-1139. Honolulu, HI, USA. May 23, 2011.
  (abstract) (bib) (pdf) (poster)

  Software repositories, such as source code, email archives, and bug databases, contain unstructured and unlabeled text that is divcult to analyze with traditional techniques. We propose the use of statistical topic models to automatically discover structure in these textual repositories. This discovered structure has the potential to be used in software engineering tasks, such as bug prediction and traceability link recovery. Our research goal is to address the challenges of applying topic models to software repositories.

  @inproceedings{thomas_mining_2011,
title = {Mining software repositories with topic models},
booktitle = {Proceedings of the 33rd International Conference on Software Engineering},
author = {Stephen W. Thomas},
pages = {1139--1139},
year = "2011"
}

  
  
  
• Validating the Use of Topic Models for Software Evolution
  Stephen W. Thomas, Bram Adams, Ahmed E. Hassan, and Dorothea Blostein
  Proceedings of the 10th International Working Conference on Source Code Analysis and Manipulation, pages 55-64. Timisoara, Romania. September 12-13, 2010.
  (abstract) (bib) (pdf) (errata) (slides)

  Topics are collections of words that co-occur frequently in a text corpus. Topics have been found to be effective tools for describing the major themes spanning a corpus. Using such topics to describe the evolution of a software system's source code promises to be extremely useful for development tasks such as maintenance and re-engineering. However, no one has yet examined whether these automatically discovered topics accurately describe the evolution of source code, and thus it is not clear whether topic models are a suitable tool for this task.
  
  In this paper, we take a first step towards determining the suitability of topic models in the analysis of software evolution by performing a qualitative case study on 12 releases of JHotDraw, a well studied and documented system. We define and compute various metrics on the identifed topics and manually investigate how the metrics evolve over time. We find that topic evolutions are characterizable through spikes and drops in their metric values, and that the large majority of these spikes and drops are indeed caused by actual change activity in the source code. We are thus encouraged by the use of topic models as a tool for analyzing the evolution of software.

  @inproceedings{thomas_validating_2010,
title = {Validating the use of topic models for software evolution},
booktitle = {Proceedings of the 10th International Working Conference on Source Code Analysis and Manipulation},
author = {S. W. Thomas and B. Adams and A. E. Hassan and D. Blostein},
year = {2010},
pages = {55--64}
}

  
  
  
• DiffLDA: Topic Modeling in Software Projects
  Stephen W. Thomas, Bram Adams, Ahmed E. Hassan, and Dorothea Blostein
  Technical Report No. 2010-574, School of Computing, Queen's University, July 2010, 24 pages.
  (abstract) (bib) (pdf) (more info) (data)

  Previous research has shown that topics can be automatically discovered in a software project's source code. Topics are collections of words that co-occur frequently in a text collection and are discovered using topic models such as latent Dirichlet allocation (LDA). Tracking how topics evolve, i.e., grow and spread, over time is useful for supporting software maintenance, comprehension, and re-engineering activities.
  
  The evolution of topics is typically recovered by applying LDA to all versions of a project's source code at once, followed by post processing to map topics across versions. Although this technique works well in applications where each version of the data is completely dirent, for example in the analysis of conference proceedings, the technique does not work well with source code, which typically changes only incrementally and contains significant duplication across versions. In this paper, we present a new approach, called DiffLDA, for automatically mining topic evolution in source code. The approach addresses LDA's sensitivity to document duplication by operating on the differences between versions of a source code document, resulting in a more accurate, finer-grained representation of topic evolution. We validate our approach through case studies on simulated data and two open source projects.

  @techreport{thomas_difflda:_2010,
title = {{DiffLDA:} {T}opic evolution in software projects},
number = {2010-574},
institution = {School of Computing, Queen's University},
author = {S. W. Thomas and B. Adams and A. E Hassan and D. Blostein},
year = {2010},
}

Temporal Databases and Benchmarks

• Temporal Support for Persistent Stored Modules
  Richard T. Snodgrass, Dengfeng Gao, Rui Zhang, and Stephen W. Thomas
  Proceedings of the 28th International Conference on Data Engineering, To appear.
  (abstract) (bib) (preprint) (webpage)

  We show how to extend temporal support of SQL to the Turing-complete portion of SQL, that of persistent stored modules (PSM). Our approach requires minor new syntax beyond that already in SQL/Temporal to define and to invoke PSM routines, thereby extending the current, sequenced, and nonsequenced semantics of queries to PSM routines. Temporal upward compatibility (existing applications work as before when one or more tables are rendered temporal) is ensured. We provide a transformation that converts Temporal SQL/PSM to conventional SQL/PSM. To support sequenced evaluation of PSM routines, we define two different slicing approaches, maximal slicing and per-statement slicing. We compare these approaches empirically using a comprehensive benchmark and provide a heuristic for choosing between them.

  
  
  

  @inproceedings{snodgrass_temporal_2012,
title = {Temporal support for {P}ersistent {S}tored {M}odules},
booktitle = {Proceedings of the 28th International Conference on Data Engineering},
author = {Richard T. Snodgrass and Dengfeng Gao and Rui Zhang and Stephen W. Thomas},
year = "In Press"
}

• Adding Temporal Constraints to XML Schema
  Faiz Currim, Sabah Currim, Curtis Dyreson, Richard T. Snodgrass, Stephen W. Thomas, and Rui Zhang
  IEEE Transactions on Knowledge and Data Engineering, To appear.
  (abstract) (bib) (preprint) (wiki)

  If past versions of XML documents are retained, what of the various integrity constraints defined in XML Schema on those documents? This paper describes how to interpret such constraints as sequenced constraints, applicable at each point in time. We also consider how to add new variants that apply across time, so-called non-sequenced constraints. Our approach supports temporal documents that vary over both valid and transaction time, whose schema can vary over transaction time. We do this by replacing the schema with a (possibly time-varying) temporal schema and replacing the document with a temporal document, both of which are upward compatible with conventional XML and with conventional tools like XMLLINT, which we have extended to support the temporal constraints introduced here.

  
  
  

  @article{currim_adding_2011,
title = {Adding temporal constraints to {XML} {S}chema},
journal = {{IEEE} Transactions on Knowledge and Data Engineering},
author = {Faiz Currim and Sabah Currim and Curtis Dyreson and Richard T. Snodgrass and Stephen W. Thomas and Rui Zhang},
year = "In Press"
}

• τBench: Extending XBench with Time
  Stephen W. Thomas, Richard T. Snodgrass, and Rui Zhang
  TimeCenter TR-92, December 2010, 63+vi pages.
  (bib) (pdf) (more info)

  @techreport{thomas_tbench:_2010,
author = {Stephen W. Thomas and Richard T. Snodgrass and Rui Zhang},
title = {{{$\tau$Bench}: {E}xtending {XB}ench with time}},
institution = {TimeCenter},
number = {TR-93},
month= {December},
year = {2010}
}

  
  
  
• τXSchema- Support for Data- and Schema-Versioned XML Documents
  Faiz Currim, Sabah Currim, Curtis Dyreson, Shailesh Joshi, Richard T. Snodgrass, Stephen W. Thomas, and Eric Roeder
  TimeCenter TR-91, September 2009, 264+xiv pages.
  (abstract) (bib) (pdf) (wiki)

  The W3C XML Schema recommendation defines the structure and data types for XML documents. XML Schema lacks explicit support for time-varying XML documents or for time-varying schemas. An XML document evolves as it is updated over time or as it accumulates from a streaming data source. A temporal document records the entire history of a document rather than just its current state or snapshot. Capturing a document's evolution is vital to providing the ability to recover past versions, track changes over time, and evaluate temporal queries. Capturing the evolution of a document's schema is similarly important. To date, users have to resort to ad hoc, non-standard mechanisms to create schemas for time-varying XML documents and to deal with evolving schemas.
  
  This report presents a data model and architecture, called τXSchema, for constructing and validating temporal XML documents through the use of a temporal schema. A temporal schema guides the construction of a temporal document and is essential to managing, querying, and validating temporal documents. The temporal schema consists of a non-temporal (conventional) schema, logical annotation(s), and physical annotation(s). The annotations specify which portion(s) of an XML document can vary over time, how the document can change, and where timestamps should be placed. These components can themselves individually evolve over time. The advantage of using annotations to denote the time-varying aspects is that logical and physical data independence for temporal schemas can be achieved while remaining fully compatible with both existing XML Schema documents and the XML Schema recommendation. This report also describes how to construct a temporal document by "gluing" individual snapshots into an integrated history.
  
  This technical report is divided into three parts: concerning instance versioning, extending to schema versioning, and reviewing the entire τXSchema language. The first two parts have a parallel structure. Each begins by discussing relevant related work before providing a motivating example that illustrates the challenges of instance and schema versioning, respectively, then lists design decisions made in τXSchema concerning that challenge. Theoretical considerations (separately for instance and schema versioning), architectural considerations, and implementation details are discussed in that order in each of the two parts. Each part ends with full example schema and instance documents. The third part completes the picture with a discussion of related work and research topics to be considered in the future.

  @article{currim_txschema:_2009, author = {Faiz Currim and Sabah Currim and Curtis Dyreson and Shailesh Joshi and Richard T. Snodgrass and Stephen W. Thomas and Eric Roeder},
year = {2009},
title = {{{$\tau$}XSchema}: {S}upport for data- and schema-versioned {XML} documents},
journal = {TimeCenter},
note = {TR-91}
}

  
  
  
• The Implementation and Evaluation of Temporal Representations in XML
  Stephen W. Thomas
  Master's Thesis, Computer Science Department, University of Arizona, March 2009.
  (abstract) (bib) (pdf) (wiki)

  The design space for representing temporal data in XML has thus far received limited empirical attention. As a result, designers do not fully understand the design space and trade-offs between various representational approaches. This thesis presents an initial characterization of that design space and provides a qualitative and quantitative analysis of the extreme ends of the spectrum, as well as an expressive language for describing temporal data. We extend an existing language, τXSchema, to implement three classes of representations and show that the edit-based scheme provides the best performance in terms of creation time and representation size, although the item-based and sliced-based schemes can be validated more quickly. We also provide an analysis of where temporal constraint functionality should be implemented and show that, with a few exceptions, temporal constraint functionality must be implemented within the tools and cannot be implemented in the representational schema. These results provide insight into the overall design space for temporal representations that will be useful to researchers, tool implementers, and users of τXSchema.

  @mastersthesis{thomas_implementation_2009,
author = {Thomas, Stephen W.},
title = {The implementation and evaluation of temporal representations in {XML}},
school = {Computer Science Department, University of Arizona},
year = {2009},
month = {March}
}