The State of the Art in End-User Software Engineering 
ANDREW J. KO 
The Information School, DUB Institute, University of Washington 
ROBIN ABRAHAM 
Microsoft Corporation 
LAURA BECKWITH 
http://hciresearcher.com 
ALAN BLACKWELL 
The Computer Laboratory, University of Cambridge 
MARGARET BURNETT, MARTIN ERWIG, AND CHRIS SCAFFIDI 
School of Electrical and Engineering and Computer Science, Oregon State Uni-
versity 
JOSEPH LAWRANCE 
MIT CSAIL 
HENRY LIEBERMAN 
MIT Media Laboratory 
BRAD MYERS 
Human-Computer Interaction Institute, Carnegie Mellon University 
MARY BETH ROSSON 
Information Sciences and Technology, Penn State University 
GREGG ROTHERMEL 
Department of Computer Science and Engineering, University of Nebraska at 
Lincoln 
MARY SHAW 
Institute for Software Research, Carnegie Mellon University 
SUSAN WIEDENBECK 
College of Information Science and Technology, Drexel University 
________________________________________________________________________ 
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 re-
e-
quirements, 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 engi-
i-
neering 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. 
Categories and Subject Descriptors: D.2 [Software Engineering], D.3 [Programming Languages], H.5 [In-
n-
formation Interfaces and Presentation], K.4 [Computers and Society], J.4 [Social and Behavioral Sci-
i-
ences] 
General Terms: Reliability, Human Factors, Languages, Experimentation, Design 
Additional Key Words and Phrases: end-user software engineering, end-user programming, end-user develop-
lop-
ment, visual programming, human-computer interaction. 
________________________________________________________________________ 
Accepted for publication in ACM Computing Surveys 
To tiff - application control tool:C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net, ASP.NET MVC, Ajax, WinForms, WPF
Online C# Tutorial for How to Convert PDF File to Tiff Image File
www.rasteredge.com
To tiff - application control tool:VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.net, ASP.NET MVC, Ajax, WinForms, WPF
Free VB.NET Guide to Render and Convert PDF Document to TIFF
www.rasteredge.com
1. INTRODUCTION 
From the first digital computer programs in the 1940’s to today’s rapidly growing soft-
ware industry, computer programming has become a technical skill of millions. As this 
profession has grown, however, a second, perhaps more powerful trend has begun to take 
shape. According to statistics from the U.S. Bureau of Labor and Statistics, by 2012 in 
the United States there will be fewer than 3 million professional programmers, but more 
than 55 million people using spreadsheets and databases at work, many writing formulas 
and queries to support their job [Scaffidi et al. 2005]. There are also millions designing 
websites with Javascript, writing simulations in MATLAB [Gulley 2006], prototyping 
user interfaces in Flash [Myers et al. 2008], and using countless other platforms to sup-
port their work and hobbies. Computer programming, almost as much as computer use, is 
becoming a widespread, pervasive practice. 
What makes these “end-user programmers” different from their professional counter-
r-
parts is their goals: professionals are paid to ship and maintain software over time; end 
users, in contrast, write programs to support some goal in their own domains of expertise. 
End-user programmers might be secretaries, accountants, children [Petre and Blackwell 
2007], teachers [Wiedenbeck 2005], interaction designers [Myers et al. 2008], scientists 
sts 
[Segal 2007] or anyone else who finds themselves writing programs to support their work 
or hobbies. Programming experience is an independent concern. For example, despite 
their considerable programming skills, many system administrators view programming as 
only a means to keeping a network and other services online [Barrett et al. 2004]. The 
The 
same is true of many research scientists [Carver et al. 2007, Segal 2007]. 
Despite their differences in priorities from professional developers, end-user pro-
ro-
grammers face many of the same software engineering challenges. For example, they 
must choose which APIs, libraries, and functions to use [Ko et al. 2004]. Because their 
programs contain errors [Panko 1998], they test, verify and debug their programs. They 
They 
also face critical consequences to failure. For example, a Texas oil firm lost millions of 
dollars in an acquisition deal through an error in a spreadsheet formula [Panko 1995]. 
The consequences are not just financial. Web applications created by small-business 
owners to promote their businesses do just the opposite if they contain bad links or pages 
that display incorrectly, resulting in loss of revenue and credibility [Rosson et al. 2005]. 
application control tool:Online Convert PDF file to Tiff. Best free online PDF Tif
Online PDF to Tiff Converter. Download Free Trial. Convert a PDF File to Tiff. Just upload your file by clicking on the blue
www.rasteredge.com
application control tool:RasterEdge XDoc.Tiff for .NET - SDK for Tiff Document Imaging
XDoc.Tiff for .NET. View, Convert, Edit, Process, Annotate Tiff Image Files. Convert Jpeg Images to Tiff. Tiff File Process. Create, Load, and Save Tiff File.
www.rasteredge.com
Software resources configured by end users to monitor non-critical medical conditions 
ns 
can cause unnecessary pain or discomfort for users who rely on them [Orrick 2006]. 
Because of these quality issues, researchers have begun to study end-user program-
-
ming practices and invent new kinds of technologies that collaborate with end users to 
improve software quality. This research area is called end-user software engineering 
(EUSE). This topic is distinct from related topics in end-user development in its focus on 
software quality. For example, there have been prior surveys of novice programming en-
n-
vironments [Kelleher and Pausch 2005], discussing systems that either help students ac-
quire computing skills or enable the creation of computational artifacts; while quality is a 
concern in these contexts, this work focuses largely on learning goals. There have also 
been surveys on end-user programming [Sutcliffe and Mehandjiev 2004, Lieberman et al. 
l. 
2006][Wulf et al. 2006], but these focus on the construction of programs to support other 
er 
goals, but not on engineering activities peripheral to construction, such as requirements, 
specifications, reuse, testing, and debugging. 
In this article, these software engineering activities are our primary focus. We start by 
proposing definitions of programming, end-user programming, and end-user software 
ftware 
engineering, focusing on differences in intents and priorities between end-user program-
m-
ming and professional software development. We follow with a lifecycle-oriented treat-
-
ment of end-user software engineering research, organizing more than a decade of re-
e-
search on incorporating requirements, design, testing, verification, and debugging into 
end users’ existing work practices. We then discuss a variety of crosscutting issues in 
end-user software engineering research, including the role of risk, reward, and domain of 
practice on end users’ decision-making, as well as strategies for persuading users to en-
-
gage in more rigorous software engineering activities as part of their normal work. We 
also discuss individual factors, such as self-efficacy and gender, and their influence on 
how effectively people use EUSE tools. 
What we found in our review of these research efforts were two different histories. 
First, studies of end-user software engineering concerns have had a consistently broad 
ad 
scope. Researchers have studied children [Petre and Blackwell 2007], middle-school stu-
-
dents [Baker 2007, Kelleher et al. 2007], system administrators [Barrett et al. 2004], peo-
-
ple at home [Blackwell 2004], knowledge workers in large companies [Bogart et al. 
2008, Scaffidi et al. 2006], interaction designers [Ko et al. 2004, Brandt et al. 2008, 
Myers et al. 2008], natural scientists [Carver et al. 2007, Segal 2007], software architects 
[Lakshminarayanan et al. 2006], bioinformatics professionals [Letondal 2006], web de-
-
application control tool:C# WPF Viewer: Load, View, Convert, Annotate and Edit Tiff
C# WPF Viewer: Load, View, Convert, Annotate and Edit Tiff. Tiff Image Viewing and Edit Functionalities in RasterEdge WPF Viewer for C#.NET. Tiff File Formats.
www.rasteredge.com
application control tool:C# WinForms Viewer: Load, View, Convert, Annotate and Edit Tiff
C# WinForms Viewer: Load, View, Convert, Annotate and Edit Tiff. Supported Tiff Image Processing Features in RasterEdge WinForms Viewer for C#.NET. Overview.
www.rasteredge.com
signers [Rode and Rosson 2003], and even volunteers helping with disaster relief [Scaf-
-
fidi et al. 2007]. 
In contrast to studies of EUSE, contributions to EUSE tools have historically had a 
narrow scope. Early work focused largely on spreadsheets and event-based computing 
paradigms and on perfective aspects of end-user software engineering, such as testing, 
verification and debugging. Part of this historical bias is due to the fact that doing re-
search on a particular paradigm has required mature and flexible programming languages, 
platforms, and IDEs on which to build more helpful software engineering tools, and most 
end-user programming platforms have not exhibited these properties. More recently how-
-
ever, this bias has been eliminated, with recent work focusing on a much broader set of 
domains and paradigms, including the web, mobile devices, personal information man-
agement, business processes, and programming in the home. Researchers have also ex-
tended their focus from perfective activities to design, including work on requirements, 
specifications, and reuse. Part of this shift is due to the advent of interactive web applica-
tions, as sharing code is becoming much more common. 
These trends, coupled with the fact that computing is rapidly being incorporated into 
an incredible array of human activities, suggest that EUSE research will become similarly 
diverse. This will pose many challenges for the field, since the various domains studied 
and supported by research may have little in common. This is also an opportunity, how-
ever, for researchers to identify what is common across these diverse areas of practice. 
This article represents an effort at identifying some of these fundamental challenges, 
grounded in lessons from prior work. 
2. DEFINITIONS 
One contribution of this article is to identify existing terms in EUSE research and fill in 
in 
terminology gaps, creating a well-defined vocabulary upon which to build future re-
e-
search. In this section, we start with a basic definition of programming and end with a 
ith a 
definition of end-user software engineering. 
2.1. Programming and Programs 
We define programming similarly to modern English dictionaries, as the process of plan-
n-
ning or writing a program. This leads to the need for a definition of the term program. 
Some definitions of “program” are in terms of the language, in which the program is writ-
-
ten, requiring, for example, that the notation be Turing complete, and able to specify se-
quence, conditional logic and iteration. However, definitions such as these are heavily 
application control tool:C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Tiff
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Tiff. Supported Tiff Image Processing Functionalities in RasterEdge XDoc. Tiff File Formats.
www.rasteredge.com
application control tool:C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
C# Tiff - Read & Edit Tiff File in C#. Use C#.NET Tiff Reading and Editing Control to Process & Manipulate TIFF File. C#.NET TIFF Processing & Reading Control.
www.rasteredge.com
influenced by the type of activity being automated. To remove these somewhat arbitrary 
constraints from the definition, for the purposes of this paper we define a program as a 
collection of specifications that may take variable inputs, and that can be executed (or 
interpreted) by a device with computational capabilities. Note that the variability of input 
ut 
values requires that the program has the ability to execute on future values, which is one 
way it is different from simply doing a computation once manually. This definition cap-
tures general purpose languages in wide use, such as Java and C, but also notations as 
simple as VCR programs, written to record a particular show when the time of day (in-
put) satisfies the specified constraint, and combinations of HTML and CSS, which are 
re 
interpreted to produce a specific visual rendering of shapes and text. It also captures the 
use of report generators, which take some abstract specification of the desired report and 
automatically create the finished report. 
2.2. End-User Programming 
We now turn to end-user programming, a phrase popularized by Nardi [1993] in her in-
n-
vestigations into spreadsheet use in office workplaces. An end user
er
1
is simply any com-
puter user. We then define end-user programming as programming to achieve the result 
ult 
of a program primarily for personal, rather public use. The important distinction here is 
that program itself is not primarily intended for use by a large number of users with vary-
-
ing needs. For example, a teacher may write a grades spreadsheet to track students’ test 
scores, a photographer might write a Photoshop script to apply the same filters to a hun-
dred photos, or a caretaker might write a script to help a person with cognitive disabilities 
be more independent [Carmien and Fischer 2008]. In these end-user programming situa-
a-
tions, the program is a means to an end and only one of potentially many tools that could 
be used to accomplish a goal. This definition also includes a skilled software developer 
writing “helper” code to support some primary task. For example, a developer is engag-
-
ing in end-user programming when writing code to visualize a data structure to help di-
-
agnose a bug. Here, the tool and its output are intended to support the developers’ par-
ticular task, but not a broader group of users or use cases. 
In contrast to end-user programming, professional programming has the goal of pro-
o-
ducing code for others to use. The intent might be to make money, or to write it for fun, 
or perhaps as a public service (as is the case for many free and open source projects). 
1
The “end” in “end user” comes from economics and business, where the person who purchases a software 
product may be different from the “end user” who uses it. Our use of the phrase in this article is more for his-
torical consistency than because we need to make this distinction.
application control tool:VB.NET TIFF: Read, Edit & Process TIFF with VB.NET Image Document
VB.NET TIFF - How to Read and Handle TIFF File. Read, View and Edit TIFF File by Applying VB.NET TIFF Reader & Processer. Visual C#.
www.rasteredge.com
application control tool:C# Create PDF from Tiff Library to convert tif images to PDF in C#
C#.NET PDF - .NET PDF Library for Creating PDF from Tiff in C#. C#.NET Demo Code: Tiff to PDF Conversion in Visual C# .NET Class. Add necessary references:
www.rasteredge.com
Therefore, the moment novice web designers move from designing a web page for them-
selves to designing a web page for someone else, the nature of their activity has changed. 
The same is true if the developer mentioned above decides to share the data structure 
visualization tool with the rest of his team. The moment this shift in intent occurs, the 
developer must plan and design for a broader range of possible uses, increasing the im-
portance of design and testing, and the prevalence of potential bugs.  
It is also important to clarify two aspects of this “intent”-based definition. First, our 
definition is not intended to be dichotomous, but continuous. After all, there is no clear 
distinction between a program intended for use by five people and a program intended for 
fifty. Instead, the key distinction is that as the number of intended uses of the program 
increases, a programmer will have to increasingly consider software engineering con-
cerns in order to satisfy increasingly complex and diverse constraints. Second, even if a 
programmer does not intend for a program to be used by others, circumstances may 
change: the program may have broader value, and the code which was originally un-
n-
tested, hacked together, and full of unexercised bugs may suddenly require more rigorous 
software engineering attention. 
While our definition of end-user programming is a departure from previously pub-
b-
lished definitions, we do so both to bring clarity to field and to discuss some of the under-
lying dimensions of historical use. For example, a number of connotations of the phrase 
have emerged in research, many using it to refer to “novice” programming or “non-
professional” programming, or system design that involves the participation of end users. 
Many have also used it to describe an individual’s identity [Nardi 1993]. We believe 
these connotations conflate a number of related, but non-equivalent concepts. 
For example, consider its use as an identity. A wide variety of people may engage in 
end-user programming; Table 1 gives just a glimpse of the diversity of people’s computa-
a-
tional creations. While it is natural to use the phrase “end-user programmers” to describe 
be 
these groups, it is not always accurate, because a persons’ intent in programming can 
depend on their task. For example, an accountant may use spreadsheets at home to keep 
track of a family loan, but use and share a spreadsheet at work to manage annual tax 
preparation activities with other accountants. It would be inaccurate to call this account-
-
ant an end-user programmer in all situations, when the spreadsheet at home is intended 
for personal, short-term use, but the one at work is heavily maintained and repeatedly 
used by multiple people. Thus, when we use the phrase “end-user programmer” in this 
paper, we are indicating the intent behind a programming task, not a fundamental aspect 
of the programmer’s identity. 
Class of people 
Activities of programming and tools and languages used 
System administrators 
Write scripts to glue systems together, using text editors and scripting languages 
Interaction designers 
Prototype user interfaces with tools like Visual Basic and Flash 
Artists 
Create interactive art with languages like Processing (http://processing.org) 
Teachers 
Teach science and math with spreadsheets [Niess et al. 2007] 
Accountants 
Tabulate and summarize financial data with spreadsheets 
Actuaries 
Calculate and assess risks using financial simulation tools like MATLAB 
Architects 
Model and design structures using FormZ and other 3D modelers 
Children 
Create animations and games with Alice [Dann et al. 2006] and Scratch 
Middle school girls 
Use Alice to tell stories [Kelleher and Pausch 2006, Kelleher and Pausch 2007] 
Webmasters 
Manage databases and websites using Access, FrontPage, HTML, Javascript 
Health care workers 
Write specifications to generate medical report forms  
Scientists/engineers 
Use MATLAB and Prograph [Cox et al. 1989] to perform tests and simulations 
E-mail users 
Write e-mail rules to manage, sort and filter e-mail 
Video game players 
Author “mods” for first person shooters, online multiplayer games, and The Sims 
Musicians 
Create digital music with synthesizers and musical dataflow languages  
VCR and TiVo users 
Record television programs in advance by specifying parameters and schedules 
Home owners 
Write control schedules for heating and lighting systems with X10 
Apple OS X users 
Automate workflow using AppleScript and Automator 
Calculator users 
Process and graph mathematical data with calculator scripting languages 
Managers 
Author and generate data-base backed reports with Crystal Reports 
Table 1. A partial list of class of people who write programs and the kinds of programs they write. 
It is also important to not conflate end-user programming with inexperience. Profes-
s-
sional developers with decades of experience can engage in end-user programming by 
writing code for personal use, with no intent to share their program with others. They 
may complete their end-user programming task more quickly and with fewer bugs, but 
they will not approach the work with the same quality goals that they would for produc-
tion code. To illustrate this distinction, consider Figure 1, which portrays programming 
experience and intent as two separate dimensions. Computer science students and profes-
s-
sional programmers code with the intent of creating software for people to use (or grade), 
but vary in their experience. Similarly, end-user programming involves programming for 
personal use, but can include a wide range of programming expertise (of course, there are 
many more inexperienced programmers than experienced ones; we are not arguing that 
the distribution of experience is uniform). 
Similarly, it is important to not conflate end-user programming with the use of “sim-
m-
ple” languages. Experienced developers may use general purpose languages like C++ to 
achieve end-user programming goals, and in fact, many scientists do use such languages 
to do exploratory scientific analyses, without the intent of sharing the code or polishing it 
for future use [Segal 2007]. Similarly, experienced developers may use simple markup 
languages such as HTML and CSS to design commercial web sites. In general, end-user 
programming can involve a wide range of languages, from macro recording, to domain-
specific languages, to conventional, general-purpose languages. The key distinction in the 
choice of language is whether it helps a person achieve their personal goal (e.g., “choos-
ing the right tool for the job”). 
Related to the choice of language, end-user programming should not be conflated 
Figure 1. Programming activities along dimensions of experience and intent. The diagram is not intended to 
d to 
suggest the distribution of programmers (as there are many more without experience than with), but simply the 
underlying dimensions that characterize programming activity. The upward slant in end-user programming 
indicates that people with more experience tend to plan for other uses of their code. 
with the use of particular interaction technique for constructing code. Java programs can 
be written with a text editor or a visual editor [Ko and Myers 2006] and languages that 
are traditionally written with visual editors, such as dataflow languages like Yahoo Pipes 
(http://pipes.yahoo.com) and Prograph [Matwin & Petrzykowski 1985], can also be ex-
pressed in textual syntax. The use of visual code editors has more to do with the difficulty 
of learning and manipulating textual syntax than the intent of the programmer. 
There are a number of phrases related to “end-user programming” that are worth dis-
-
cussing relative to our definition. End-user development has been defined as “a set of 
of 
methods, techniques, and tools that allow users of software systems, who are acting as 
non-professional software developers, at some point to create, modify, or extend a soft-
-
ware artifact” [Lieberman et al. 2006]. This notion of end-user development also focuses 
on the use and adaptations of software over time, and focuses on elements of the software 
re 
lifecycle  beyond  the  stage  of  creating a  new  program.  More  specifically,  mutual-
-
development, co-development, and participatory design refer to activities in which end 
end 
users are involved in a system design, but may or may not be involved in its actual coding 
[Henderson and Kyng 1991, Costabile et al. 2009, Mackay 1990]. These accounts of or-
or-
ganizational, social, and collaborative perspectives on end-user development offer several 
ral 
valuable perspectives on how people appropriate and customize software, most of which 
are beyond the scope of this survey. 
Terms such as customization, configuring [Eagan and Stasko 2008], and tailoring 
ring 
[Trigg and Bødker 1994, Kahler 2001] include parameterization of existing programs, but 
but 
not direct modification of a program’s source code. Visual programming refers to a set of 
et of 
interaction techniques and visual notations for expressing programs. The phrase often 
implies use by end-user programmers, but visual notations are not always targeted at a 
particular type of programming practice. Domain-specific languages are programming 
ing 
languages designed for writing programs for a particular kind of context or practice. End-
user programming may or may not involve such languages, since what defines end-user 
programming is the intent, not the choice of languages or tools. Finally, scripts and 
nd 
scripting languages are often distinguished from programs and programming languages 
by the use of machine interpretation rather than compilation and their “high-level” use in 
coordinating the functions of multiple programs or services. The phrase end-user pro-
o-
gramming, because it is often conflated with inexperience, often connotes the use of 
scripting languages since these languages have the reputation of being easier to learn. 
10 
2.3. End-User Software Engineering 
With definitions of programming and end-user programming, we now turn to the central 
topic of this article, end-user software engineering. As we discussed in the previous sec-
c-
tion, the intent behind programming is what distinguishes end-user programming from 
other activities. This is because programmers’ intents determine to what extent they con-
sider concerns such as reliability, reuse, and maintainability and the extent to which they 
engage in activities that reinforce these qualities, such as testing, verification, and debug-
ging. Therefore, if one defines software engineering as systematic and disciplined activi-
-
ties that address software quality issues
es
2
, the key difference between professional soft-
ware engineering and end-user software engineering is the amount attention given to 
en to 
software quality concerns. 
In professional software engineering, the amount of attention is much greater: if a 
program is intended for use by millions of users, all with varying concerns and unique 
contexts of use, a programmer must consider quality regularly and rigorously in order to 
succeed. This is perhaps why definitions of software engineering often imply rigor. For 
example, IEEE Standard 610.12 defines software engineering as “the application of sys-
tematic, disciplined, quantifiable approaches to the development, operation, and mainte-
nance of software.” Systematicity, discipline, and quantification all require significant 
time and attention, so much so that professional software developers spend more time 
testing and maintaining code than developing it [Tassey 2002] and they often structure 
their teams, communication, and tools around performing these activities [Ko et al. 
2007]. 
In contrast, end-user software engineering still involves systematic and disciplined 
ed 
activities that address software quality issues, but these activities are secondary to the 
goal that the program is helping to achieve. Because of this difference in priorities and 
2
Because the meaning of the phrase software engineering is still under much debate, we use the definition from 
from 
current IEEE standards.
Software Engineering Activity  Professional SE 
End-user SE 
Requirements 
explicit 
implicit 
Specifications 
explicit 
implicit 
Reuse 
planned 
unplanned 
Testing and Verification 
cautious 
overconfident 
Debugging 
systematic 
opportunistic  
Table 2. Qualitative differences between professional and end-user software engineering. 
Documents you may be interested
Documents you may be interested