Joseph Lawrance

The state of the art in end-user software engineering

Most programs today are written not by professional software developers, but by people with expertise in other domains working towards goals for which they need computational support. For example, a teacher might write a grading spreadsheet to save time grading, or an interaction designer might use an interface builder to test some user interface design ideas. Although these end-user programmers may not have the same goals as professional developers, they do face many of the same software engineering challenges, including understanding their requirements, as well as making decisions about design, reuse, integration, testing, and debugging. This article summarizes and classifies research on these activities, defining the area of End-User Software Engineering (EUSE) and related terminology. The article then discusses empirical research about end-user software engineering activities and the technologies designed to support them. The article also addresses several crosscutting issues in the design of EUSE tools, including the roles of risk, reward, and domain complexity, and self-efficacy in the design of EUSE tools and the potential of educating users about software engineering principles.

An Information Foraging Theory Perspective on Tools for Debugging, Refactoring, and Reuse Tasks

Theories of human behavior are an important but largely untapped resource for software engineering research. They facilitate understanding of human developers’ needs and activities, and thus can serve as a valuable resource to researchers designing software engineering tools. Furthermore, theories abstract beyond specific methods and tools to fundamental principles that can be applied to new situations. Toward filling this gap, we investigate the applicability and utility of Information Foraging Theory (IFT) for understanding information-intensive software engineering tasks, drawing upon literature in three areas: debugging, refactoring, and reuse. In particular, we focus on software engineering tools that aim to support information-intensive activities, that is, activities in which developers spend time seeking information. Regarding applicability, we consider whether and how the mathematical equations within IFT can be used to explain why certain existing tools have proven empirically successful at helping software engineers. Regarding utility, we applied an IFT perspective to identify recurring design patterns in these successful tools, and consider what opportunities for future research are revealed by our IFT perspective.

Scents in Programs:Does Information Foraging Theory Apply to Program Maintenance?

Spatial problems (SP) are inevitable in reasoning with diagrams. In this paper, we investigate general representations and computational strategies for a SP-solver such that it can accept problems from a human in a high-level language and output the solution without human intervention. We propose a language in which a variety of domain- independent 2D SPs can be specified in terms of constraints. The constraints are specified in first-order logic over the real domain using a vocabulary of objects, properties, relations and actions. We also propose two general and independent computational strategies - constraint satisfaction and spatial search - for autonomously solving the SPs. Ideas about how to make these strategies computationally efficient are discussed and illustrated by examples.

Using cognitive dimensions: Advice from the trenches

Abstract Many researchers have analyzed visual language design using Cognitive Dimensions (CDs), but some have reinterpreted the purpose, vocabulary, and use of CDs, potentially creating confusion. In particular, those who have used CDs to convince themselves or others that their language is usable have tended to ignore or downplay the tradeoffs inherent in design, resulting in evaluations that provide few insights. Researchers who do not consider who , when , and how best to analyze a visual language using CDs are likely to miss the most useful opportunities to uncover problems in their visual languages. In this paper, we consider common breakdowns when using CDs in analysis. Then, using three case studies, we demonstrate how the who , when , and how circumstances under which CDs are applied impact the gains that can be expected.

Sharing reasoning about faults in spreadsheets: An empirical study

Although researchers have developed several ways to reason about the location of faults in spreadsheets, no single form of reasoning is without limitations. Multiple types of errors can appear in spreadsheets, and various fault localization techniques differ in the kinds of errors that they are effective in locating. In this paper, we report empirical results from an emerging system that attempts to improve fault localization for end-user programmers by sharing the results of the reasoning systems found in WYSIWYT and UCheck. By evaluating the visual feedback from each fault localization system, we shed light on where these different forms of reasoning and combinations of them complement - and contradict - one another, and which heuristics can be used to generate the best advice from a combination of these systems

Git on the cloud in the classroom

Numerous CS faculty have demonstrated the benefits of using version control in courses other than software engineering. However, they maintained their own servers, and to the best of our knowledge, none published experiences with version control in CS1 courses for non-CS engineering majors. As a result, even faculty experienced with version control may hesitate to adopt it in some classes, fearing that it is too difficult, time consuming or distracting. In this paper, we describe how we adopted version control in a CS1 course for non-CS engineering majors, and how software hosting services facilitated its use. Our experience indicates that undergraduate engineering majors in CS courses can gain competence in version control, and software hosting services simplify class administration.

Can information foraging pick the fix? A field study

Previous findings have revealed the ability of information foraging to model or predict where developers will navigate within source code. However, the previous investigation did not consider whether the places developers went were the right places to go. In this paper, we present afield study in which we investigated over 200 open source bug reports and feature requests. We analyzed the textual similarity of these issues in relation to the source code, and determined what files developers had changed to fix these issues. Our results demonstrate that information scent can narrow down quite well where developers should make fixes, implying that future software navigation tools can predict the appropriate places to make fixes based solely on the contents of the issue and the source code.

End-user software engineering and distributed cognition

End-user programmers may not be aware of many software engineering practices that would add greater discipline to their efforts, and even if they are aware of them, these practices may seem too costly (in terms of time) to use. Without taking advantage of at least some of these practices, the software these end users create seems likely to continue to be less reliable than it could be. We are working on several ways of lowering both the perceived and actual costs of systematic software engineering practices, and on making their benefits more visible and immediate. Our approach is to leverage the users cognitive effort through the use of distributed cognition, in which the system and user collaboratively work systematically to reason about the program the end user is creating. This paper demonstrates this concept with a few of our past efforts, and then presents three of our current efforts in this direction.

Impact of high-intensity negotiated-style interruptions on end-user debugging

Extending our previous work [T. Robertson, S. Prabhakararao, M. Burnett, C. Cook, J. Ruthruff, L. Beckwith, A. Phalgune, Impact of interruption style on end-user debugging, ACM Conference on Human Factors in Computing Systems (2004)], we delve deeper into the question of which interruption style best supports end-user debugging. Previously, we found no advantages of immediate-style interruptions (which force the user to divert attention to the interruption at hand) over negotiated-style interruptions (which notify users without actually preventing them from working) in supporting end-user debugging. In this study, we altered our negotiated-style interruptions [A. Wilson, M. Burnett, L. Beckwith, O. Granatir, L. Casburn, C. Cook, M. Durham, G. Rothermel, Harnessing curiosity to increase correctness in end-user programming, Proceedings of the CHI 2003 (2003), 305-312] (which were shown to help end-user debuggers learn about and use debugging features of our programming language) such that they were more intense (larger, blinking, and/or accompanied by text).

Web information retrieval and filtering course to undergraduates using open source programming

This paper describes how to engage actively students in web information retrieval and filtering course using open source programming. To teach this course, I utilized hands-on lab projects from various open source projects including the Galago search engine. Projects included, but were not limited to, implementing information retrieval (IR) algorithms, collaborative filtering (CF) algorithms, web-based interfaces, and adding features into an open-source search engine. By practicing with real-world open source programming, students found that they better understood how to connect background knowledge to real-world applications in preparation for industry jobs.