@conference {1357,
	title = {Content classification of developer emails},
	booktitle = {Proceedings of the 34th IEEE/ACM International Conference On Software Engineering (ICSE 2012)},
	year = {2012},
	note = {We created a web application to manually classify email content in the chosen categories. We classified a statistically significant set of emails from four java open source software (OSS) systems, used to evaluate the accuracy of our approach.
The contributions of this paper are:
1) a novel approach that fuses parsing and ML techniques
for classification of email lines;
2) a web application to manually classify email content; 3) the manual classification of a statistically significant
sample set of emails (for a total of 67,792 lines) from mailing lists of four different software systems{\textendash}in the form of a freely available benchmark; and
4) the empirical evaluation of our approach against the benchmark},
	month = {06/2012},
	abstract = {Emails related to the development of a software system contain information about design choices and issues encountered during the development process. Exploiting the knowledge embedded in emails with automatic tools is challenging, due to the unstructured, noisy and mixed language nature of this communication medium. Natural language text is often not well-formed and is interleaved with languages with other syntaxes, such as code or stack traces.

We present an approach to classify email content at line level. Our technique classifies email lines in five categories (i.e., text, junk, code, patch, and stack trace) to allow one to subsequently apply ad hoc analysis techniques for each category. We evaluated our approach on a statistically significant set of emails gathered from mailing lists of four unrelated open source systems.},
	keywords = {email, Emails, Empirical software engineering, mailing list, natural language, Unstructured Data Mining},
	url = {http://www.inf.usi.ch/phd/bacchelli/publications.php},
	attachments = {https://flosshub.org/sites/flosshub.org/files/icse2012.pdf},
	author = {Bacchelli, Alberto and Dal Sasso, Tommaso and D{\textquoteright}Ambros, Marco and Lanza, Michele}
}
@conference {1358,
	title = {Extracting source code from e-mails},
	booktitle = {Proceedings of ICPC 2010 (18th IEEE International Conference on Program Comprehension)},
	year = {2010},
	note = {"We want to extract source code fragments from e-mail messages. To do this, we first need to select e-mails that contain source code fragments, and then we extract such fragments from the content in which they are enclosed."

"we manually build a statistically significant benchmark taking sample e- mails from five unrelated open source Java software systems."

},
	pages = {24-33},
	abstract = {E-mails, used by developers and system users to communicate over a broad range of topics, offer a valuable source of information. If archived, e-mails can be mined to support program comprehension activities and to provide views of a software system that are alternative and complementary to those offered by the source code.

However, e-mails are written in natural language, and therefore contain noise that makes it difficult to retrieve the important data. Thus, before conducting an effective system analysis and extracting data for program comprehension, it is necessary to select the relevant messages, and to expose only the meaningful information.

In this work we focus both on classifying e-mails that hold fragments of the source code of a system, and on extracting the source code pieces inside the e-mail. We devised and analyzed a number of lightweight techniques to accomplish these tasks. To assess the validity of our techniques, we manually inspected and annotated a statistically significant number of e-mails from five unrelated open source software systems written in Java. With such a benchmark in place, we measured the effectiveness of each technique in terms of precision and recall.},
	keywords = {argouml, email, freenet, jmeter, mailing lists, mina, natural language, openjpa, source code},
	url = {http://www.inf.usi.ch/phd/bacchelli/publications.php},
	attachments = {https://flosshub.org/sites/flosshub.org/files/icpc2010.pdf},
	author = {Bacchelli, Alberto and D{\textquoteright}Ambros, Marco and Lanza, Michele}
}
@conference {Hill:2008:AAM:1370750.1370771,
	title = {AMAP: automatically mining abbreviation expansions in programs to enhance software maintenance tools},
	booktitle = {Proceedings of the 2008 international working conference on Mining software repositories},
	series = {MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {79{\textendash}88},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {When writing software, developers often employ abbreviations in identifier names. In fact, some abbreviations may never occur with the expanded word, or occur more often in the code. However, most existing program comprehension and search tools do little to address the problem of abbreviations, and therefore may miss meaningful pieces of code or relationships between software artifacts. In this paper, we present an automated approach to mining abbreviation expansions from source code to enhance software maintenance tools that utilize natural language information. Our scoped approach uses contextual information at the method, program, and general software level to automatically select the most appropriate expansion for a given abbreviation. We evaluated our approach on a set of 250 potential abbreviations and found that our scoped approach provides a 57\% improvement in accuracy over the current state of the art.},
	keywords = {automatic abbreviation expansion, azureus, itext.net, liferay, maintenance, natural language, openoffice.org, program comprehension, source code, tiger envelopes, tools},
	isbn = {978-1-60558-024-1},
	doi = {http://doi.acm.org/10.1145/1370750.1370771},
	url = {http://doi.acm.org/10.1145/1370750.1370771},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p79-hill.pdf},
	author = {Hill, Emily and Fry, Zachary P. and Boyd, Haley and Sridhara, Giriprasad and Novikova, Yana and Pollock, Lori and Vijay-Shanker, K.}
}
@conference {Wang:2008:ADD:1368088.1368151,
	title = {An approach to detecting duplicate bug reports using natural language and execution information},
	booktitle = {Proceedings of the 30th international conference on Software engineering},
	series = {ICSE {\textquoteright}08},
	year = {2008},
	pages = {461{\textendash}470},
	publisher = {ACM},
	organization = {ACM},
	address = {New York, NY, USA},
	abstract = {An open source project typically maintains an open bug repository so that bug reports from all over the world can be gathered. When a new bug report is submitted to the repository, a person, called a triager, examines whether it is a duplicate of an existing bug report. If it is, the triager marks it as DUPLICATE and the bug report is removed from consideration for further work. In the literature, there are approaches exploiting only natural language information to detect duplicate bug reports. In this paper we present a new approach that further involves execution information. In our approach, when a new bug report arrives, its natural language information and execution information are compared with those of the existing bug reports. Then, a small number of existing bug reports are suggested to the triager as the most similar bug reports to the new bug report. Finally, the triager examines the suggested bug reports to determine whether the new bug report duplicates an existing bug report. We calibrated our approach on a subset of the Eclipse bug repository and evaluated our approach on a subset of the Firefox bug repository. The experimental results show that our approach can detect 67\%-93\% of duplicate bug reports in the Firefox bug repository, compared to 43\%-72\% using natural language information alone.},
	keywords = {bug report, duplicate bug report, execution information, information retrieval, natural language},
	isbn = {978-1-60558-079-1},
	doi = {10.1145/1368088.1368151},
	url = {http://doi.acm.org/10.1145/1368088.1368151},
	author = {Wang, Xiaoyin and Zhang, Lu and Xie, Tao and Anvik, John and Sun, Jiasu}
}
@conference {972,
	title = {Extracting structural information from bug reports},
	booktitle = {Proceedings of the 2008 international workshop on Mining software repositories  - MSR {\textquoteright}08},
	year = {2008},
	month = {05/2008},
	pages = {27-30},
	publisher = {ACM Press},
	organization = {ACM Press},
	address = {New York, New York, USA},
	abstract = {In software engineering experiments, the description of bug reports is typically treated as natural language text, although it often contains stack traces, source code, and patches. Neglecting such structural elements is a loss of valuable information; structure usually leads to a better performance of machine learning approaches. In this paper, we present a tool called infoZilla that detects structural elements from bug reports with near perfect accuracy and allows us to extract them. We anticipate that infoZilla can be used to leverage data from bug reports at a different granularity level that can facilitate interesting research in the future.},
	keywords = {bug reports, eclipse, enumerations, infozilla, natural language, patches, source code, stack trace},
	isbn = {9781605580241},
	doi = {10.1145/1370750.1370757},
	attachments = {https://flosshub.org/sites/flosshub.org/files/p27-bettenburg.pdf},
	author = {Premraj, Rahul and Zimmermann, Thomas and Kim, Sunghun and Bettenburg, Nicolas}
}
@conference {1054,
	title = {LASER: a lexical approach to analogy in software reuse},
	booktitle = {International Workshop on Mining Software Repositories (MSR 2004)},
	volume = {2004},
	year = {2004},
	pages = {112 - 116},
	publisher = {IEE},
	organization = {IEE},
	address = {Edinburgh, Scotland, UK},
	abstract = {Software reuse is the process of creating a software system from existing software components, rather than creating it from scratch. With the increase in size and complexity of existing software repositories, the need to provide intelligent support to the programmer becomes more pressing. An analogy is a comparison of certain similarities between things which are otherwise unlike. This concept has shown to be valuable in developing UML-level reuse techniques. In the LASER project we apply lexically-driven Analogy at the code level, rather than at the UML-level, in order to retrieve matching components from a repository of existing components. Using the lexical ontology Word-Net, we have conducted a case study to assess if class and method names in open source applications are used in a semantically meaningful way. Our results demonstrate that both hierarchical reuse and parallel reuse can be enhanced through the use of lexically-driven Analogy.},
	keywords = {class, developers, functions, jrefactory, method, naming, natural language, reuse, source code, wordnet},
	doi = {10.1049/ic:20040487},
	attachments = {https://flosshub.org/sites/flosshub.org/files/112LASER.pdf},
	author = {Amin, R. and Mel O Cinneide and Veale, Tony}
}
