Find Unique Usages: Helping Developers Understand Common Usages

When working in large and complex codebases, developers face challenges using \textit{Find Usages} to understand how to reuse classes and methods. To better understand these challenges, we conducted a small exploratory study with 4 participants. We found that developers often wasted time reading long lists of similar usages or prematurely focused on a single usage. Based on these findings, we hypothesized that clustering usages by the similarity of their surrounding context might enable developers to more rapidly understand how to use a function. To explore this idea, we designed and implemented \textit{Find Unique Usages}, which extracts usages, computes a diff between pairs of usages, generates similarity scores, and uses these scores to form usage clusters. To evaluate this approach, we conducted a controlled experiment with 12 participants. We found that developers with Find Unique Usages were significantly faster, completing their task in 35% less time

An End-User Development Perspective on State-of-the-Art Web Development Tools

We reviewed and analyzed nine commercially available web development tools from the perspective of suitability for end-user development to compare and contrast alternative and best-of-breed approaches for particular problem areas within web application development (Getting Started, Workflow, Level of Abstraction, Layout, Database, Application Logic, Testing and Debugging, Learning and Scaling, Security, Collaboration, and Deployment). End-user development involves the creation of dynamic websites with support for features like authentication, conditional display, and searching/sorting by casual web developers who have some experience creating static websites but little or no programming knowledge. We found that current tools do not lack functionality, but rather have a variety of problems in ease of use for end users who are nonprogrammers. In particular, while many tools offer wizards and other features designed to facilitate specific aspects of end-user development, none of the tools that we reviewed supports a holistic approach to web application development. We discuss the implications of these problems and conclude with recommendations for the design of improved web development tools that would lower the entry barrier into web programming

How Designers Use Design Principles: Design Behaviors and Application Modes

This paper investigates how information systems design professionals use design principles (extracted from a prior design science research project) in a new design situation. We do this by capturing think-aloud protocols from experienced design professionals who are given access to potentially useful design principles. Our analysis identifies two dimensions of use: design behaviors (what designers do) and application modes (how designers apply the principles). Mapping across the dimensions suggests two use pathways: forward chaining and backward chaining. Our study shows how empirically studying expert designers can shed light on the microprocesses of design principles in use, and how an empirical turn in the investigation can contribute to clarifying the fundamental nature of design principles. We conclude by highlighting the implications of these insights for crafting more useful design principles

Enhancing intelligent API tutors with information about how APIs are used in practice

Application Programming Interfaces (APIs) enable software developers to utilize and create functionality that would otherwise take a lot of time and effort to build from scratch. Consequently, an essential part of software engineering training is for students to learn how to use APIs effectively. The existing jTutors system enables an expert library user to harvest code examples from the web and semi automatically create intelligent tutors for various Java APIs. This interactive instructional material teaches a learner how to perform tasks with APIs through a series of examples and quizzes presented in a computer adaptive manner. This thesis presents two new features that enhance the jTutors system by incorporating additional information into intelligent tutors about how APIs are used in practice. The new 'Industry Code Search' feature enables users to search for API code usages by mining through a repository of open source projects. This system has been further enhanced to mine FAQs, articles and other API related links so users can learn more about APIs, all in one place. A qualitative study demonstrated that the new features helped students to learn intricacies of multiple APIs and also to familiarize themselves with actual usage in real world projects

Code Puzzle Completion Problems in Support of Learning Programming Independently

Middle school children often lack access to formal educational opportunities to learn computer programming. One way to help these children may be to provide tools that enable them to learn programming on their own independently. However, in order for these tools to be effective they must help learners acquire programming knowledge and also be motivating in independent contexts. I explore the design space of using motivating code puzzles with a method known to support independent learning: completion problems. Through this exploration, I developed code puzzle completion problems and an introductory curriculum introducing novice programmers to basic programming constructs. Through several evaluations, I demonstrate that code puzzle completion problems can motivate learners to acquire new programming knowledge independently. Specifically, I found that code puzzle completion problems are more effective and efficient for learning programming constructs independently compared to tutorials. Puzzle users performed 33% better on transfer tasks compared to tutorial users, while taking 21% less time to complete the learning materials. Additionally, I present evidence that children are motivated to choose to use the code puzzles because they find the experience enjoyable, challenging, and valuable towards developing their programming skills. Given the choice between using tutorials and puzzles, only 10% of participants opted to use more tutorials than puzzles. Further, 80% of participants also stated a preference towards the puzzles because they simply enjoyed the experience of using puzzles more than the tutorials. The results suggest that code puzzle completion problems are a promising approach for motivating and supporting independent learning of programming

The Example Guru: Suggesting Examples to Novice Programmers in an Artifact-Based Context

Programmers in artifact-based contexts could likely benefit from skills that they do not realize exist. We define artifact-based contexts as contexts where programmers have a goal project, like an application or game, which they must figure out how to accomplish and can change along the way. Artifact-based contexts do not have quantifiable goal states, like the solution to a puzzle or the resolution of a bug in task-based contexts. Currently, programmers in artifact-based contexts have to seek out information, but may be unaware of useful information or choose not to seek out new skills. This is especially problematic for young novice programmers in blocks programming environments. Blocks programming environments often lack even minimal in-context support, such as auto-complete or in-context documentation. Novices programming independently in these blocks-based programming environments often plateau in the programming skills and API methods they use. This work aims to encourage novices in artifact-based programming contexts to explore new API methods and skills. One way to support novices may be with examples, as examples are effective for learning and highly available. In order to better understand how to use examples for supporting novice programmers, I first ran two studies exploring novices\u27 use and focus on example code. I used those results to design a system called the Example Guru. The Example Guru suggests example snippets to novice programmers that contain previously unused API methods or code concepts. Finally, I present an approach for semi-automatically generating content for this type of suggestion system. This approach reduces the amount of expert effort required to create suggestions. This work contains three contributions: 1) a better understanding of difficulties novices have using example code, 2) a system that encourages exploration and use of new programming skills, and 3) an approach for generating content for a suggestion system with less expert effort