Andrew J. Ko
About the author:
No description available of Andrew J. Ko...
Publications by Andrew J. Ko (bibliography)
» 2009 «
Ko, Andrew J. and Myers, Brad A. (2009): Finding causes of program output with the Java Whyline. In: Proceedings of ACM CHI 2009 Conference on Human Factors in Computing Systems 2009. pp. 1569-1578. Available online
“Debugging and diagnostic tools are some of the most important software development tools, but most expect developers choose the right code to inspect. Unfortunately, this rarely occurs. A new tool called the Whyline is described which avoids such speculation by allowing developers to select questions about a program's output. The tool then helps developers work backwards from output to its causes. The prototype, which supports Java programs, was evaluated in an experiment in which participants investigated two real bug reports from an open source project using either the Whyline or a breakpoint debugger. Whyline users were successful about three times as often and about twice as fast compared to the control group, and were extremely positive about the tool's ability to simplify diagnostic tasks in software development work.”
Copyrights may apply
Myers, Brad A., Burnett, Margaret M., Wiedenbeck, Susan, Ko, Andrew J. and Rosson, Mary Beth (2009): End user software engineering: CHI: 2009 special interest group meeting. In: Proceedings of ACM CHI 2009 Conference on Human Factors in Computing Systems 2009. pp. 2731-2734. Available online
“End users create software whenever they write, for instance, educational simulations, spreadsheets, or dynamic e-business web applications. Researchers are working to bring the benefits of rigorous software engineering methodologies to these end users to try to make their software more reliable. Unfortunately, errors are pervasive in end-user software, and the resulting impact is sometimes enormous. This special interest group meeting will bring together the community of researchers who are addressing this topic with the companies that are creating and using end-user programming tools.”
Copyrights may apply
Kulesza, Todd, Wong, Weng-Keen, Stumpf, Simone, Perona, Stephen, White, Rachel, Burnett, Margaret M., Oberst, Ian and Ko, Andrew J. (2009): Fixing the program my computer learned: barriers for end users, challenges for the machine. In: Proceedings of the 2009 International Conference on Intelligent User Interfaces 2009. pp. 187-196. Available online
“The results of a machine learning from user behavior can be thought of as a program, and like all programs, it may need to be debugged. Providing ways for the user to debug it matters, because without the ability to fix errors users may find that the learned program's errors are too damaging for them to be able to trust such programs. We present a new approach to enable end users to debug a learned program. We then use an early prototype of our new approach to conduct a formative study to determine where and when debugging issues arise, both in general and also separately for males and females. The results suggest opportunities to make machine-learned programs more effective tools.”
Copyrights may apply
» 2008 «
Myers, Brad A., Burnett, Margaret, Rosson, Mary Beth, Ko, Andrew J. and Blackwell, Alan (2008): End user software engineering: chi'2008 special interest group meeting. In: Proceedings of ACM CHI 2008 Conference on Human Factors in Computing Systems April 5-10, 2008. pp. 2371-2374. Available online
“End users create software whenever they write, for instance, educational simulations, spreadsheets, or dynamic e-business web applications. Researchers are working to bring the benefits of rigorous software engineering methodologies to these end users to try to make their software more reliable. Unfortunately, errors are pervasive in end-user software, and the resulting impact is sometimes enormous. This special interest group meeting has two purposes: to incorporate attendees' and feedback into an emerging survey of the state of this interesting new sub-area, and generally to bring together the community of researchers who are addressing this topic, with the companies that are creating end-user programming tools.”
Copyrights may apply
Park, Sun Young, Myers, Brad A. and Ko, Andrew J. (2008): Designers' natural descriptions of interactive behaviors. In: VL-HCC 2008 - IEEE Symposium on Visual Languages and Human-Centric Computing 15-19 September, 2008, Herrsching am Ammersee, Germany. pp. 185-188. Available online
» 2007 «
Cherubini, Mauro, Venolia, Gina, DeLine, Rob and Ko, Andrew J. (2007): Let's go to the whiteboard: how and why software developers use drawings. In: Proceedings of ACM CHI 2007 Conference on Human Factors in Computing Systems 2007. pp. 557-566. Available online
“Software developers are rooted in the written form of their code, yet they often draw diagrams representing their code. Unfortunately, we still know little about how and why they create these diagrams, and so there is little research to inform the design of visual tools to support developers' work. This paper presents findings from semi-structured interviews that have been validated with a structured survey. Results show that most of the diagrams had a transient nature because of the high cost of changing whiteboard sketches to electronic renderings. Diagrams that documented design decisions were often externalized in these temporary drawings and then subsequently lost. Current visualization tools and the software development practices that we observed do not solve these issues, but these results suggest several directions for future research.”
Copyrights may apply
» 2006 «
Ko, Andrew J. and Myers, Brad A. (2006): Barista: An implementation framework for enabling new tools, interaction techniques and views in code editors. In: Proceedings of ACM CHI 2006 Conference on Human Factors in Computing Systems 2006. pp. 387-396. Available online
“Recent advances in programming environments have focused on improving programmer productivity by utilizing the inherent structure in computer programs. However, because these environments represent code as plain text, it is difficult and sometimes impossible to embed interactive tools, annotations, and alternative views in the code itself. Barista is an implementation framework that enables the creation of such user interfaces by simplifying the implementation of editors that represent code internally as an abstract syntax tree and maintain a corresponding, fully structured visual representation on-screen. Barista also provides designers of editors with a standard text-editing interaction technique that closely mimics that of conventional text editors, overcoming a central usability issue of previous structured code editors.”
Copyrights may apply
Myers, Brad A., Weitzman, David A., Ko, Andrew J. and Chau, Duen H. (2006): Answering why and why not questions in user interfaces. In: Proceedings of ACM CHI 2006 Conference on Human Factors in Computing Systems 2006. pp. 397-406. Available online
“Modern applications such as Microsoft Word have many automatic features and hidden dependencies that are frequently helpful but can be mysterious to both novice and expert users. The ""Crystal"" application framework provides an architecture and interaction techniques that allow programmers to create applications that let the user ask a wide variety of questions about why things did and did not happen, and how to use the related features of the application without using natural language. A user can point to an object or a blank space and get a popup list of questions about it, or the user can ask about recent actions from a temporal list. Parts of a text editor were implemented to show that these techniques are feasible, and a user test suggests that they are helpful and well-liked.”
Copyrights may apply
Ko, Andrew J., Myers, Brad A. and Chau, Duen Horng (2006): A Linguistic Analysis of How People Describe Software Problems. In: VL-HCC 2006 - IEEE Symposium on Visual Languages and Human-Centric Computing 4-8 September, 2006, Brighton, UK. pp. 127-134. Available online
» 2005 «
Ko, Andrew J. and Myers, Brad A. (2005): Citrus: a language and toolkit for simplifying the creation of structured editors for code and data. In: Proceedings of the 2005 ACM Symposium on User Interface Software and Technology 2005. pp. 3-12. Available online
“Direct-manipulation editors for structured data are increasingly common. While such editors can greatly simplify the creation of structured data, there are few tools to simplify the creation of the editors themselves. This paper presents Citrus, a new programming language and user interface toolkit designed for this purpose. Citrus offers language-level support for constraints, restrictions and change notifications on primitive and aggregate data, mechanisms for automatically creating, removing, and reusing views as data changes, a library of widgets, layouts and behaviors for defining interactive views, and two comprehensive interactive editors as an interface to the language and toolkit itself. Together, these features support the creation of editors for a large class of data and code.”
Copyrights may apply
Fogarty, James, Ko, Andrew J., Aung, Htet Htet, Golden, Elspeth, Tang, Karen P. and Hudson, Scott E. (2005): Examining task engagement in sensor-based statistical models of human interruptibility. In: Proceedings of ACM CHI 2005 Conference on Human Factors in Computing Systems 2005. pp. 331-340. Available online
“The computer and communication systems that office workers currently use tend to interrupt at inappropriate times or unduly demand attention because they have no way to determine when an interruption is appropriate. Sensor?based statistical models of human interruptibility offer a potential solution to this problem. Prior work to examine such models has primarily reported results related to social engagement, but it seems that task engagement is also important. Using an approach developed in our prior work on sensor?based statistical models of human interruptibility, we examine task engagement by studying programmers working on a realistic programming task. After examining many potential sensors, we implement a system to log low?level input events in a development environment. We then automatically extract features from these low?level event logs and build a statistical model of interruptibility. By correctly identifying situations in which programmers are non?interruptible and minimizing cases where the model incorrectly estimates that a programmer is non?interruptible, we can support a reduction in costly interruptions while still allowing systems to convey notifications in a timely manner.”
Copyrights may apply
Ko, Andrew J., Aung, Htet Htet and Myers, Brad A. (2005): Design requirements for more flexible structured editors from a study of programmers' text editing. In: Proceedings of ACM CHI 2005 Conference on Human Factors in Computing Systems 2005. pp. 1557-1560. Available online
“A detailed study of Java programmers' text editing found that the full flexibility of unstructured text was not utilized for the vast majority of programmers' character-level edits. Rather, programmers used a small set of editing patterns to achieve their modifications, which accounted for all of the edits observed in the study. About two-thirds of the edits were of name and list structures and most edits preserved structure except for temporary omissions of delimiters. These findings inform the design of a new class of more flexible structured program editors that may avoid well-known usability problems of traditional structured editors, while providing more sophisticated support such as more universal code completion and smarter copy and paste.”
Copyrights may apply
» 2004 «
Ko, Andrew J. and Myers, Brad A. (2004): Designing the whyline: a debugging interface for asking questions about program behavior. In: Dykstra-Erickson, Elizabeth and Tscheligi, Manfred (eds.) Proceedings of ACM CHI 2004 Conference on Human Factors in Computing Systems April 24-29, 2004, Vienna, Austria. pp. 151-158. Available online
“Debugging is still among the most common and costly of programming activities. One reason is that current debugging tools do not directly support the inquisitive nature of the activity. Interrogative Debugging is a new debugging paradigm in which programmers can ask why did and even why didn't questions directly about their program's runtime failures. The Whyline is a prototype Interrogative Debugging interface for the Alice programming environment that visualizes answers in terms of runtime events directly relevant to a programmer's question. Comparisons of identical debugging scenarios from user tests with and without the Whyline showed that the Whyline reduced debugging time by nearly a factor of 8, and helped programmers complete 40% more tasks.”
Copyrights may apply
SHOW THIS LIST ON YOUR HOMEPAGE
What do YOU think?
Give us your opinion! Do you have any comments/additions that you would like other visitors to see?
You say:
Mar 13th, 2010
Changes to this page (author)
14 Feb 2010: Enabled abstracts to be shown on Andrew J. Ko's author page.17 Jun 2009: Author was edited 16 Jun 2009: Author was edited
02 Jun 2009: Author was edited
09 May 2009: Author was edited
09 May 2009: Author was edited
09 May 2009: Author was edited
12 May 2008: Author was edited
29 Jun 2007: Author was edited
29 Jun 2007: Author was edited
19 Jun 2007: Author was edited
19 Jun 2007: Author was edited
19 Jun 2007: Author was edited
11 Jun 2007: Author was edited
28 Apr 2003: Added the author to the bibliography
