Sometimes, when programmers use a search engine, they know more or less what they need. Other times, programmers use the search engine to look around and generate possible ideas for the programming problem on which they are working. The key insight we explore in this dissertation is that, in the latter case, the results found tend to serve as inspiration or triggers for the next queries issued.

We introduce two search engines, CodeExchange and CodeLikeThis, both of which are specifically designed to enable the user to directly leverage results from a previous query in formulating a next query. CodeExchange does this with a set of four features that enable the programmer to use characteristics of the results to find other code with or without those characteristics. For instance, by selecting characteristics of the results the programmer likes (e.g., libraries used or method calls) or dislikes (e.g., code complexity or size), the programmer can refine their query for results with or without those characteristics. CodeLikeThis explores a different mechanism of supporting iteration by letting developers simply select an entire result to find code that is analogous, to some degree, to that result. For instance, the developer can select an algorithm implementation (e.g., quick sort) with a directive to find more similar implementations, less similar implementations (e.g., heap sort), or somewhat similar implementations.

We evaluated the impact of CodeExchange and CodeLikeThis on the experience, time, and success of the code search process. We compared our iterative approaches with two approaches not explicitly supporting iteration, a baseline and Google, in a laboratory experiment among 24 developers. We found that search engines that support using results to form the next query can improve the programmers' search experience and different approaches to iteration can provide better experiences depending on the kind of task.

The main contributions of this dissertation are six-fold. First, it contributes a new approach to code search, implemented in CodeExchange, that supports the programmer in iteratively searching by bringing characteristics of the results into their query. Second, it contributes, a new approach to code search, implemented in CodeLikeThis, that supports the programmer in iteratively searching by simply selecting a result to issue a query for other similar code. Third, it contributes an extensive laboratory experiment evaluating the impact of iterative approaches on the experience, time, and success of the code search process. Fourth, it contributes new findings about how developers search for code . Fifth, it contributes the implementation of CodeExchange and CodeLikeThis as fully functioning search engines over 10 million Java classes mined off the Internet. Sixth, it contributes an Index of 10 million Java classes indexed by different technical and social properties.

Bug triaging is an important activity in any software development project. It involves triagers working through the set of unassigned bugs, determining for each of the bugs whether it represents a new issue that should receive attention, and, if so, assigning it to a developer and a milestone. Current bug tracking tools provide only minimal support for bug triaging, and especially break down when users must triage a large number of bug reports, since those reports can only be viewed one-by-one.

This dissertation seeks to further our understanding of bug triaging, particularly the conjecture that allowing triagers to work and organize bugs in sets better matches what they want to do when they triage. Our vehicle for exploring this conjecture is PorchLight, a prototype triaging environment that uses tags, assigned to individual bug reports by queries expressed in a specialized bug tagging language, to organize bug reports into meaningful sets so triagers can more easily explore, organize, and ultimately work with bugs in sets. We describe the current challenges in supporting bug triaging, the design decisions upon which PorchLight rests, and the technical aspects of the implementation.

We conducted two studies using PorchLight. The first was a preliminary user study to test the concept, assess the usability of the tool, and to determine if triagers would be able to employ the basic features. The second was a participant observation study with four participants over a set of six sessions in which we engaged them in discussions about their approach to triaging, and performed triaging using bugs from projects with which they were familiar.

Our study led to several key findings. We found that triaging can be a highly context-dependent activity that varies between individuals and projects. Through our discussions with the participants, we also uncovered latent workflows that were realized through the exploration of bugs in sets. Finally, the ability to directly work with bugs in sets rather than individually seems to have enabled triagers to both think about, and work with, bugs more naturally, particularly when there are a large number of bugs that need to be triaged.

This thesis presents a prototype sketching tool designed to address the problem of reusing sketches. Our goal is to help designers preserve, understand, and communicate meaning that is represented in groups of sketches. To this end, we introduce workspaces, which provide an interface for arranging and annotating groups of sketches in flexible configurations. We also provide new sketch metadata, a navigation interface, and filtering capabilities to assist designers in locating sketches of interest.

To evaluate this prototype, we conducted a small user study. Eight participants working in development roles at a local business were recruited for this study. Participants worked individually through a set of tasks using our prototype, while we observed whether and how they used the tool’s various features. We interviewed each participant upon completion of the tasks to gather more data about their experience.

Based on our observations of the participants as well as their feedback, we determined several important findings. We believe that workspaces represent an important step toward helping designers visualize, understand, and explain groups of sketches and the design stories they embody, and that the prototype succeeds in making it easier to locate sketches of interest. Additionally, we identified several feature enhancements that would make the tool even more useful.

In software engineering, a whiteboard is a commonly used tool. One particular setting is that of software developers using a whiteboard when they hold software design meetings. They do so because whiteboards offer a fluid and flexible drawing experience. At the same time, the simplicity of the interaction on the physical whiteboard (only drawing and erasing) can be a weakness. Researchers in the past have proposed different variations of whiteboards to make up for this weakness, but to date they have not addressed the fact that novices are prone to becoming lost in their design work precisely because of the fluidity and flexibility. This thesis presents Tabbie, an electronic whiteboard tool with preloaded tabs that are meant to guide novices when they engage in design work. To assess Tabbie, I performed a preliminary experiment with 15 university students designing a ride-sharing service. I present preliminary results that the existence of tabs can be helpful to novices when theywork on software design.

Meetings have always been a significant part of all types of work. Software development is no exception, with meetings of all kinds taking place daily. One type of meeting that is critical to software development is the Regularly Scheduled Software Maintenance Design Meeting (RSSMDM): a recurring meeting during which the primary product leads of a software development team consider emerging issues and new directions for an already deployed and functioning software system. To date, RSSMDMs have not been widely studied and particularly ignored is the perspective of the role of information in shaping the discussions in these meetings.This dissertation contributes a foundational understanding of how information flows in and out of RSSMDMs through a single case study of ten such meetings at a healthcare software company. Through a thematic analysis, it particularly characterizes the variety of information that the participants in these meetings on the one hand share and on the other hand capture while they engage in their design work. In addition, the dissertation identifies the tools that the meeting participants use to share and capture information and the various ways in which they use the tools. The results from the thematic analysis are varied, with several of the more important findings being: (1) many different types of information are shared, with the range much greater than what traditionally has been considered as important to capture for future use, (2) much of the information shared is fleeting, concerning the current state of the deployed software and the current state of its code base, (3) sharing is frequent, with new information shared on average once or twice a minute, (4) the diversity and frequency of information captured is much less than information shared, and (5) traditional design tools such as diagramming and sketching tools are not used in support of the meetings, displaced by the use of Confluence (a wiki-style knowledge repository) and Jira (an issue tracker). These and other findings establish a baseline for future research into RSSMDMs, provide insights into current practices, and offer suggestions for the development of improved tools to support participants with information sharing and information capture in RSSMDMs.

In today’s world, we work with a collection of artifacts generated across different tasks in almost all domains. These artifacts could be documents, sketches, images or code snippets based on the domain. Clearly, sometimes we have to go back in time to access these artifacts for various reasons. One reason could be to recall when and why certain decisions were made, to see what the impact of a decision was, to clarify a decision made by another person, or to see what other alternatives we might have created at the time. Currently, a combination of solutions like Google Docs, GitHub, Confluence and Slack are employed for this purpose. Most of these tools offer a repository where artifacts are archived based on informal or sub-optimal practices improvised by the group of people working together. A research project at the University of California, Irvine called Linecept, is exploring a different approach, namely storing artifacts in timelines. Almost akin to Gantt charts, Linecept tracks which artifacts are produced, when they are produced, and by what team members. A limitation of the original implementation of Linecept was scalability. In particular, Linecept utilized an open-source timeline visualization component in its implementation that created problems when too many artifacts were present or too long a time was being tracked. In this thesis, I provide the motivation for such a tool, introduce Linecept briefly and provide an overview of other alternative libraries that exist. I also present a list of requirements that are important for a timeline-based visualization tool. Then, I introduce and discuss an architecture that helps to overcome the limitations of the original implementation of Linecept and existing code libraries and tools. Subsequently, I present the implementation of the design and evaluate the prototype built using this architecture.

Team-based projects are a cornerstone of contemporary software engineering programs. Although they can be effective in improving learning of the course materials and imparting teamwork skills, teamwork can present challenges for both instructors and students. Well-known problems include teams not following recommended processes (e.g., producing all necessary artifacts at the last minute) and team dynamics interfering with progress (e.g., social loafing, dominating personalities, failing to consider others and their ideas). This thesis introduces TeamCAST, a tool I specifically designed to track both progress and contributions over the course of a team project. TeamCAST is based on the notion of students submitting all intermediate work, which TeamCAST then displays on a dashboard for the instructor to monitor. This thesis reports on the primary design decisions underlying TeamCAST and presents the results of a pilot study in a 179 student software design class.

The growing prominence of esports and competitive gaming has not only attracted a global audience but captured the curiosity of academic researchers. With increased research interest, the necessity for tools to collect contextual game data has subsequently risen significantly. Currently, a combination of generalized software solutions such as keyloggers, screen recorders, and audio recorders can be used to gather artifacts regarding an individual player. However, these solutions are inadequate when used to support research questions concerning player interactions in a multiplayer context. To address this problem, I introduce CapturEsports, a software tool to facilitate research in esports by supporting the capture and organization of multiple streams of player data. Focusing on League of Legends developed by Riot Games as a proof of concept, CapturEsports enables researchers to capture screen video recordings, voice communication, keystrokes, and in-game contextual events (such as player kills, buildings destroyed, and item purchases) for multiple players simultaneously, thereby facilitating analysis of team behavior. CapturEsports performs data collection and provides access to the data remotely, allowing studies to be conducted in a distributed manner. In this thesis, I present the motivation behind CapturEsports, an examination of alternative software tools, and a detailed description of the tool I developed. I also discuss the primary design decisions and underlying requirements, the overall architecture and organization of data structures, and a preliminary evaluation and analysis of CapturEsports as an esports research application.

Crowdsourcing is gradually becoming an accepted form of work across different disciplines. Not surprisingly, it has attracted the attention of the software engineering community as well. Previous work started exploring the feasibility of crowdsourcing for software design by conducting experiments in which workers from Amazon Mechanical Turk were asked to engage in a set of software design tasks. It was found that, when workers are exposed to examples of previous designs, they generate overall lower quality contributions. The intuition is that, since these experiments displayed all previous contributions as examples to workers, the presence of low quality examples may have negatively influenced workers.

This thesis compares the designs produced in the previous experiments to designs obtained in a new experiment in which examples were evaluated against pre-defined quality criteria before being displayed to workers. Only examples that were of sufficient quality were shared with workers, with the hope of stimulating them to provide higher quality designs.

We report results from an analysis in which we compare the designs from the current and previous experiments in terms of quantity, diversity of ideas, quality, completeness, perceived task difficulty, and how often workers borrow elements from examples. The major findings are twofold. First, workers who were exposed to sufficient quality examples produced better quality work as compared to workers exposed to all examples. Second, the quality of the designs they produced still did not reach the quality of the designs produced by workers who were not exposed to examples at all.

In this paper, I look at applications to the INNO Fund ACORN, a biannualprogram that gives fifty thousand dollar grants to start-up companies that show promise. I attempt to answer many of the common questions that entrepreneurs might have about applying to receive grant funding by using many of the advanced software tools that have been developed for natural language processing purposes. This study would be useful to anyone interested in raising money for a company, as well as someone looking to better understand the field of natural language processing, with applications in business. A transformer encoder-decoder model was used to efficiently and effectively summarize applications. This model was necessary to summarize applications through the synthesis of new sentences with novel words and phrases, as opposed to simply extracting sentences containing the most common words in the document. It was found that companies tend to receive funding more often if they have larger teams, that a founding team's tenacity is an important factor in attempting to raise money multiple times if the original attempt fails, and that many founders are serial v entrepreneurs, meaning they often are involved in the creation of multiple start-up companies throughout their career. Finally, Latent Dirichlet Allocation (LDA) was used to automatically classify the topics of all of the applications in the dataset with high confidence.