
I only have one big research question, but I attack it from a lot of different angles. The question is representation. How do people make, see and use things that carry meaning? The angles from which I attack my question include various ways in which r...
More about Alan >>I am a Professor of Information Sciences and Technology, and Affiliate Professor of Instructional Systems in the College of Education. With Dr. John Carroll, I co-direct the Computer-Supported Collaboration and Learning (CSCL). I am also a founding member of P...
More about Mary >>
Reviewer 1: Name suppressed
Reviewer 2: Name suppressed
Peer-review is based on the reviewing guidelines and coordinated by the Reviewing Board.
Authoritative overview of Social Computing by Tom Erickson - veteran researcher at IBM Research Lab. It includes 9 HD videos filmed in Copenhagen.
Read Thomas's chapterComputer users have rapidly increased in both number and diversity (Scaffidi et al 2005). They include managers, accountants, engineers, home makers, teachers, scientists, health care workers, insurance adjusters, salesmen, and administrative assistants. Many of these people work on tasks that rapidly vary on a yearly, monthly, or even daily basis. Consequently, their software needs are diverse, complex, and frequently changing. Professional software developers cannot directly meet all of these needs because of their limited domain knowledge and because their development processes are too slow.
End-user development (EUD) helps to solve this problem. EUD is "a set 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 software artifact" (Lieberman et al 2006). In particular, EUD enables end users to design or customize the user interface and functionality of software. This is valuable because end users know their own context and needs better than anybody else, and they often have real-time awareness of shifts in their respective domains. Through EUD, end users can tune software to fit their requirements more closely than would be possible without EUD. Moreover, because end users outnumber professional software developers by a factor of 30-to-1 (Figure 10.1), EUD "scales out" software development activities by enabling a much larger pool of people to participate.
However, EUD is inherently different from traditional software development, and trying to support EUD by simply mimicking traditional approaches is often insufficient to produce successful results. End users usually do not have training in professionals' programming languages, formal development processes, or modeling and diagramming notations. Moreover, end users often lack the time or motivation to learn these traditional techniques, since end users usually write code in order to achieve a short- or medium-term goal rather than to create a durable software asset that will produce a continuing revenue stream. Consequently, supporting EUD requires providing appropriate tools, social structures, and development processes that are highly usable, quickly learned, and easily integrated into domain practice.
EUD overlaps with two similar concepts, end-user programming and end-user software engineering. End-user programming (EUP) enables end users to create their own programs (Ko et al 2011). This subset of EUD is the most mature from a research and practice perspective, so we focus a later section of this article on that portion of EUD. The difference between EUP and EUD is that EUD methods, techniques, and tools span the entire software development lifecycle, including modifying and extending software, not just the "create" phase.
The other related concept overlapping with EUD is end-user software engineering (EUSE). EUSE is a relatively new subset of EUD that began about a decade ago. Its emphasis is on the quality of the software end users create, modify, or extend; thus its research focuses on methods, techniques, and tools that promote the quality of such software. This area has arisen because of the ample evidence that the programs end users create are filled with expensive errors (Panko 1998; Burnett 2010; Ko et al 2011). We therefore focus on the EUSE subset of EUD in a later section of this article.
Prior to the 1980's, most computing occurred on mainframes controlled by professional developers in information systems departments. End users had little influence over the form and function of software running on a mainframe, which they generally viewed through simple terminal windows and controlled with simple textual commands (Figure 10.2). Information systems departments rarely had enough staff time to design and implement all of the software enhancements requested by users (Brancheau & Wetherbe 1987).
EUD grew out of a confluence of innovations embodied in the machines known as "microcomputers" (a term eventually replaced with "personal computer"). First, these machines were inexpensive enough that organizations could afford to provide each user with a machine. Having their own machines made it viable for users to modify ("tailor") the machine's software settings without impacting the computing environment of other users. Second, microcomputers had sufficient hardware power so that users could compile (or interpret) new code in languages such as Basic. This in turn provided infrastructure for end users to create new applications. Third, microcomputers soon came to include innovative new features such as the mouse and powerful graphics cards, which accelerated usability advances such as graphical user interfaces (GUIs) and direct manipulation; these advances, in turn, opened up the possibility of novel programming tools specifically designed to meet the needs of users.
Spreadsheets were the first major EUD programming environment made possible by these innovations (Bricklin et al 1979), beginning with VisiCalc (Figure 10.3), then continuing with Lotus 1-2-3 and Excel. Although users of spreadsheet systems may not think of themselves as "doing programming," spreadsheet systems are programming environments because their formulas are first-order functional programs (Jones et al 2003). In such programs, the formulas can refer to input "variables" (cell names) and the results of the formulas are computed output values. The availability of spreadsheet software was a major factor in spurring early demand for microcomputers (Ichbiah 1993). Newer technologies such as the web and mobile computing have since opened up increasingly diverse and powerful opportunities for end users to create and tailor software.
Tailoring is any "activity to modify a computer application within its context of use" (Won et al 2006). Tailoring can be a simple or complex activity. At each increased level of complexity, users have more ability to redesign the interaction and functionality of an application. At the most basic level, tailoring encompasses specifying parameters to an existing application in a way that changes its behavior at a high level of granularity. For example, a person might use a graphical user interface to indicate which features of a spreadsheet editor should be visible (Figure 10.4) or how a word processor should respond to various inputs (Figure 10.5). Once tailoring begins to involve creating full-fledged programs in order to extend the functionality of an application, the activity seamlessly encompasses end-user programming (below). For instance, a user might create scripts called "macros" that manipulate the buttons, text, or other graphical user interface elements within an application. Such macros can extend applications with new functionality or make existing functionality more usable (Figure 10.6). Researchers have proposed a variety of component-based frameworks that can be used to implement easily-tailored applications (Won et al 2006). For instance, the "Selection" object referenced in Figure 10.6 is actually a component representing the region of text that is currently highlighted by the user in the word processor. The component-based framework makes it possible for an interpreter to manipulate the highlighted text in response to macros' instructions.
End-user programming (EUP) is defined as "programming to achieve the result of a program, rather than the program itself" (Ko et al 2011). In EUP, the developer's goal is to actually use the program; this contrasts with professional programming, where the goal is to create a program for other people to use, often in exchange for monetary compensation. The programs created through EUP can be extensions of existing applications (as in Figure 10.6, above), or they can be new applications that run separately from existing applications. End users can perform EUP through a wide range of interaction styles (Nardi 1993), as we discuss next.
In environments supporting the visual programming style of interaction, at least some of a program's semantics is expressed through the visual layout of the program. For example, the grid-like arrangement of cells in a spreadsheet carries a certain semantics; specifically, cells that are vertically or horizontally aligned with one another are part of a composite object defined solely based on the visual layout of cells (e.g, the range B:B references all of the second column in Microsoft Excel). In a visual language, semantics can hypothetically be encoded in many attributes of a visual representation, such as position, color, size, and intersection with other shapes. As another example, Figure 10.7 shows a visual language where each instruction is a colored block whose color indicates what kind of instruction it is and whose shape indicates what other blocks can appear next or before this block. Figure 10.8 shows a third example of a visual language. As with many visual languages, the LabView programming tool allows users to drag and drop these shapes using the GUI. Another common way of interacting through a visual language is with a form (Figure 10.9). In such an interface, the user cannot freely drag and drop shapes but rather must make selections from pre-defined fields.
Programming-by-demonstration (PBD), sometimes called programming-by-example, is a programming technique whereby the user demonstrates the new program's logic, from which the programming environment infers a program representing that logic. Some PBD systems are able to deductively infer the entire program, while others deduce what they can and ask the user for help for the rest (Cypher 1993). PBD-based tools are available for creating animations (Repenning & Perrone 2000; McDaniel & Myers 1999) and many other kinds of programs (Cypher 1993). One problem with PBD has been representing the final program in a form useful to the user (Cypher 1993; Yang et al 1997), to enable the end-user developer to review, test, and debug the program. Thus, PBD is often used in combination with visual or textual languages.
For example, a user could create a Microsoft Word macro (like those shown in Figure 10.6) through PBD. The user would first click a button or menu item indicating that the application should start watching the user's actions. The user would then use the GUI to demonstrate the desired behavior for the macro; for example, the user might use a series of menu items and dialog windows to paste the system clipboard as text. The user would click the "stop recording" button so that Microsoft Word stops watching the user's actions. At that point, the application would generate a macro containing VBScript instructions for repeating the demonstrated actions. The user could give the macro a keyboard shortcut and a name, if desired, in order to simplify running or editing it later. In addition, the user might want to edit the macro's instructions so that they perform a task slightly different than the one that was demonstrated, particularly if the user wants the macro to complete a task that is impossible with the existing GUI (rather than merely hard-to-use). In this way, the user could add completely new functionality to an application, with PBD serving to provide a starting point for another approach to programming.
Programming-by-specification is an interaction style where the user describes a desired program, and a tool then generates the program for the user. As in PBD, the generated program can then be represented to facilitate review and customization by the user. For example, Liu & Lieberman (2005) implemented a system that accepts a specification in natural language and generates a corresponding program written in Python. A key limitation of this approach, as with inference-based PBD approaches, is that it is difficult for a user to predict what program will be generated from any particular input. Another is that, as with PBD, representation can be a difficult issue. For example, if the input interaction is done with English but the output is a traditional programming language such as Python, the end user must be fluent in both languages. Another limitation is that the programming tool can often correctly process only a limited range of inputs. This restricts the usefulness of the tool and also makes it difficult for a user to predict whether (and how) some particular input will be "understood" by the tool (e.g, could the Liu and Lieberman tool mentioned above generate games, and if so, what kinds of games?) In order to make the bounds of a tool's input language more obvious to users, some systems provide a forms-based visual interface (Figure 10.10) rather than a textual interface, thereby restricting users' specifications to only those that can actually be handled by the tool (Scaffidi et al 2009).
Programming with text is the most traditional interaction technique for programming, and for a time, some believed that this style of programming would not be appropriate for EUP. However, as the previous examples have shown, most programming environments that support other interaction styles also include text to some extent. As another example, Figure 10.11 shows the textual language that the CoScripter tool uses to represent a web macro, which is a script that directs a web browser to navigate the web and manipulate web sites in a particular way (Leshed et al 2008); such a web macro is typically created through PBD and then customized in textual form as needed. Despite the proliferation of alternative interaction styles, text remains widely used because of its conciseness and effectiveness for communicating abstract concepts.
End-user software engineering (EUSE) is defined as "end-user programming involving systematic and disciplined activities that address software quality issues" (Ko et al 2011). Attention to quality is important for EUP because poorly-written software can cause data loss, security breaches, financial loss, or even physical harm, even when the software is created by end-user developers. The software qualities relevant to EUSE are the same as those of interest to professional developers who sell their products. These qualities include reliability, performance, maintainability, reusability, privacy, and security. Some qualities, such as maintainability and reusability, only become apparent after a program has been written and in operation for some time. Thus, EUSE combines the goal of EUP, which focuses on enabling end users to create software, with the concern for quality of that software across its entire lifecycle. This lifecycle includes requirements, design, verification, debugging and code reuse (in addition to actual implementation, which has already been described above in the context of EUP tools).
Requirements describe what a program should do, and design refers to determining how a program should do it. For example, a requirement might be that a program should be able to sort a list of mailing addresses, and its design might detail the sorting algorithm to be used.
Examples of requirements (goals) in EUD include personalizing the way that an application or computer behaves, automating time-consuming tasks, performing computations that are hard to do accurately by hand, or communicating information (Ko et al 2011; Blackwell 2004; Blackwell 2006; Rosson et al 2002). Getting these requirements right is a critical aspect from the perspective of EUSE, because of its emphasis on quality. Professional developers are expected to investigate, document, and refine requirements before they start to design or code an application. For example, they might try to identify inconsistencies in requirements by applying one of several painstaking techniques (e.g, stakeholder review or formal modeling). In contrast, end users often live in their domain every day and know it very well, so they often already have an idea about what the requirements, and do not do any extra work to arrive at them, document them, or check them.
However, sometimes end users do not know the requirements in advance and do not aspire to a "design" per se; they may expect these matters to be clarified as the program's implementation evolves (Costabile et al 2006; Fischer & Giaccardi 2006; Morch and Mehandjiev 2000; Segal 2007). (Professional developers sometimes do not know the requirements in advance either, but they are expected to take steps to deal with that situation, such as employing an iterative method that fills in requirements as prototypes evolve, rather than entirely omitting the concept and moving on.) In this case, end-user developers may jump directly into coding without taking the time to document their requirements or look for inconsistencies (Rosson et al 2010). A related situation is that, because of the tight coupling of EUD to a domain, external shifts in the domain can cause evolution in requirements; for example, changes to accounting rules might require a financial analyst to compute different data, which might in turn cause modifications to an existing spreadsheet. Due to its highly iterative nature, EUD requirements-refinement has been likened to a form of highly agile programming (Lieberman et al 2006).
Thus, end-user programmers' requirements tend to be emergent and tightly intertwined with design. Given this, many design approaches that have been targeted toward end-user programmers aim to support evolutionary or exploratory approaches. DENIM is one example (a sketching system for designing web site), which allows users to leave parts of the design in a rough and ambiguous state until that section is better understood (Newman et al 2003). The process of exploratory design can also be assisted by a design critic, which is a software feature that can review a user's design and give suggestions for improvement (Figure 10.12). For example, Janus is a tool with a visual language enabling users to design floor plans for homes (Fischer et al 1990). It contains a design critic with an extensible expert system that can identify suboptimal combinations of objects in floor plans and suggest revisions to fix those design problems. It also displays a rationale for each suggestion, so that the user can reason about whether and how to apply the advice.
Another approach is for less experienced end-user developers to seek a review from more experienced peers. By identifying short lists of best practices and providing appropriate tools, researchers have tried to make this review as efficient as possible so that it can be applied without greatly slowing the EUD lifecycle (Ronen et al 1989; Powell & Baker 2003; Rosson et al 2008). Such an approach seems most likely to be successful in an organizational setting, where end-user developers have peers that they can call upon (and where the management hierarchy can be used, if appropriate, to mandate and enforce design reviews). Another variant of this idea that has emerged recently is meta-design, a team-of-equals collaborative approach in which professional developers handle some of the design task, and end-user domain experts handle different aspects (Fischer & Giaccardi 2006; Costabile et al 2006).
Researchers have also begun to explore approaches for adapting existing software engineering design techniques to the EUD context. For example, design patterns might be relevant but need adaptation to meet the needs of end-user developers (Diaz et al 2008). Another relatively new approach is the combination of design/specifications with verification capabilities, as with the Topes system discussed earlier (Scaffidi 2009).
Verification and/or validation (V&V) cover activities attempting to make sure that a program does what it is supposed to do. Testing is the most common approach for V&V (even among professional developers). One of the first works supporting V&V in EUD was to help users evaluate whether their programs contained bugs by encouraging end users to test strategically. Perhaps the most developed end-user testing approach is "What You See Is What You Test" (WYSIWYT), which guides users through the process of systematically testing spreadsheets (Fisher et al 2006). WYSIWYT employs a "Surprise-Explain-Reward" strategy (Wilson et al 2003), in which surprises such as colored borders attract users' attention to areas of the spreadsheet that need testing, and tool tips explain the colors' meaning and the potential reward in using the testing devices (Figure 10.13). Behind the scenes, WYSIWYT uses a formal test adequacy criterion to reason about elements of the formulas that have been covered by tests so far.
An alternative approach for finding errors in programs is for the programming tool to automatically look for errors on the basis of types, dimensions, or units (Erwig & Burnett 2002; Abraham & Erwig 2007; Coblenz et al 2005; Chambers & Erwig 2009). This approach can be regarded as specific kinds of assertions. For example, one system associates types with spreadsheet cells (based on the placement of labels at the top of columns and at the left end of rows) and specifies how these types propagate through the spreadsheet (Figure 10.14). If two cells with different types are combined, then their type is generalized if an applicable type is available (e.g.: "3 apples + 3 oranges = 6 fruit"), or else an error message is shown.
After a programming error is detected, the next step is to remove it by debugging. Some of the debugging techniques used by professional developers have been adapted for use in EUP tools. In addition to inserting "print" statements that display the value of variables as a program executes, end user developers can step through instructions one at a time, watching for incorrect operations (Leshed et al 2008). Assertions represent another important traditional technique that has been adapted for use in EUP: a user can insert a conditional into the code, and the program will call attention to that point if the conditional evaluates to false at execution (Burnett et al 2003; Koesnandar et al. 2008; Scaffidi 2009).
Several EUP tools provide tight integration between testing and debugging. For example, assertions can be inserted proactively when a program is created, in order to perform automatic tests and initiation of debugging if an assertion fails. For instance, when a web macro is initially created, it might perform properly; however, upon later execution, invalid outputs might arise either because of a bug in the macro itself or because of changes in the structure and content of websites (the macro inputs). An assertion can catch such errors that arise, halt execution, and bring them to the user's attention to prevent the macro from running awry (Figure 10.15). Several other EUP tools that support testing techniques, such as those mentioned above, also leverage test results to facilitate debugging. For example, once incorrect spreadsheet cells have been identified through testing, dependencies can be traced back automatically to identify and highlight the formulas that are most likely to have caused those erroneous outputs (Ayalew & Mittermeir 2003; Burnett et al 2003).
A new class of debugging tools based on question asking has recently emerged and has proven effective in EUSE. The first tool to take this approach was the Whyline, which was prototyped for the Alice programming environment that enables users to program animations (Ko & Myers 2004). Users execute their program, and when they see a behavior they have a question about, they press a "Why" button. This brings up a menu of "why did" and "why didn't" questions, organized according to the structure of the visible 3D objects manipulated by the program. Once the user selects a question, the system analyzes the program's execution history and generates an answer explaining the error in terms of the events that occurred during execution. The Whyline approach has also been applied to debugging other kinds of programs (e.g, Ko & Myers 2008; Kulesza et al 2009).
After code is written, reuse can speed the creation of later programs. Supporting reuse of end-user programs is challenging because end-user developers rarely have the opportunity or training required to design highly reusable programs. Another challenge is that end-user developers can make mistakes when creating programs or other files for tailoring applications, and reusing these can propagate errors across an organization (Mackay 1990). Therefore, even though systems such as repositories or file servers can make it easy for end-user developers to post programs for others to reuse, it can be extremely difficult and time-consuming for other developers to evaluate the reusability of these programs. To help reduce the difficulty of reusing programs, models of what makes end-user programs reusable are now being developed in the hopes of helping users to search repositories for reusable programs related to the user's particular interests (Scaffidi et al 2010). Outside of repositories, other work has begun to explore how to help users to extract reusable pieces (Oney & Myers 2009).
As users continue to grow in number and diversity, EUD is likely to play an increasingly central role in shaping software to meet the broad, varied, rapidly changing needs of the world. Along the way, further research is needed to help end-user developers create and adapt new kinds of programs in new kinds of ways. For example, as the Web 2.0 era unfolds, researchers are investigating new ways of helping users to automate the synthesis of data from multiple websites through web macros and mashups (Scaffidi et al 2008; Zang et al 2008). Another ongoing shift is the rapidly-increasing role of small mobile computers, such as smart phones; work has recently begun on enabling end users to create "apps" or other programs for these devices (Google App Inventor 2010).
With the continually broadening scope and power of end-user programming, substantial additional attention to quality will become increasingly crucial. In particular, as users continue to interact with larger numbers of anonymous peers (e.g, through social networks or "app stores"), their code may become more visible to others and therefore more susceptible to attack. Moreover, since users can now share their programs with any person on the web, many more people could be affected by an error in an end-user programmer's code. Therefore, further research is needed to help end-user developers produce software with stronger guarantees of security and privacy, without interfering with the lightweight, iterative nature of the EUD lifecycle. Moreover, as massive amounts of data become accessible through the web to users, they may need better support for designing and implementing programs with increased scalability. It will be necessary for researchers to develop new approaches, since approaches used by professional software developers, such as buffer-overrun analysis for security or Big-O analysis for performance, may be irrelevant or too complex for the needs of end-user programmers.
More broadly, EUD's continuing development as a social phenomenon has important implications for the relationship between end users and professional software developers (Fischer & Giaccardi 2006, Costabile et al 2006). The rise of EUD to date enables end users to respond to professional developers' backlog of software work, and to the reality that professional software developers are not likely to understand and plan for every user requirement when developing software. With continuing advances in EUSE, end users will not only be able to create a variety of software on their own, but they will also to be able to assess and improve that software's quality on their own—so that they know to what extent to rely upon it, and what to do to increase the software's quality if needed. As a result, the fit between software's form and individual users' needs might be closer than has been possible before, vastly increasing the usefulness of software in peoples' lives.
How to cite this commentary in your report
Margaret Burnett and Chris Scaffidi provide an excellent overview of the evolving requirements in end-user development (EUD), and the technical approaches that have been taken to address them. In some ways, EUD provides one of the greatest challenges in interaction design - not because EUD tools are necessarily more complex than other specialist software categories, but because it can be harder to recognise the usability requirements. Designers in other fields must always stay alert to any presumption that customers will have exactly the same needs and habits as the designers themselves. However in the case of programming tools, it is all too easy for professional software developers to assume that every other person should approach his or her programming work in the same way as a professional does. Specialist research attention to end-users is necessary to avoid this trap when software professionals create new EUD technologies.
Successful EUD research can also provide benefits far beyond the target users. Software development can suffer from a "cobbler's children" effect - the usability of development environments is often poor by comparison to mass-market software categories where more has been invested in user research and interaction design. If EUD research leads to usability innovations for end-users, those same innovations can be later imported into mainstream software tools. A classic example is the Smalltalk language, which had superior usability because it had originally been motivated by the desire to create a programming language for children. Although children did find it useful, Smalltalk ultimately delivered far greater benefits by becoming one of the most usable object-oriented programming environments.
EUD is also providing new insights for HCI more generally. A recent focus on user-experience, and on products that meet market demand for "walk up and use" interfaces, has resulted in a lack of methods to understand requirements of more complex tasks, which involve interaction with information structures [1]. Simple media appliances and game-like interaction are welcome and desirable, but as Burnett and Scaffidi note in their conclusion, more sophisticated capabilities can also empower users. Lack of usability is frustrating, even in situations as commonplace as configuring social network privacy, or modifying a financial budget. The information structure in such tasks can be described as "programming-like", with more insight coming from EUD research than from standard usability methods. The field of Psychology of Programming [2] is able to provide guidance both to EUD, and to more domestic programming-like tasks, for example through the Cognitive Dimensions of Notations framework [3], and the Attention Investment model of abstraction use [4]. That field offers complementary insights to the very useful technical overview provided in this article.
1. Blackwell, A.F. & Fincher, S. (2010). PUX: Patterns of User Experience. interactions 17(2), 27-31.
http://www.cl.cam.ac.uk/~afb21/publications/BlackwellFincher-PUX.pdf
2. http://www.ppig.org/
3. Blackwell, A.F. and Green, T.R.G. (2003). Notational systems - the Cognitive Dimensions of Notations framework. In J.M. Carroll (Ed.) HCI Models, Theories and Frameworks: Toward a multidisciplinary science. San Francisco: Morgan Kaufmann, 103-134.
http://www.cl.cam.ac.uk/~afb21/publications/BlackwellGreen-CDsChapter.pdf
4. Blackwell, A.F. (2002). First steps in programming: A rationale for Attention Investment models. In Proceedings of the IEEE Symposia on Human-Centric Computing Languages and Environments, pp. 2-10.
http://www.cl.cam.ac.uk/~afb21/publications/HCC02a.pdf
How to cite this commentary in your report
End-user development is happening all around us. Burnett and Scaffidi do a good job of getting this message across, as well as surveying the many paths and supports for end users who participate in software development. But one issue that is hard to pin down is the why and who of EUD. HCI researchers have known for many years that people rarely become experts even in the use of their existing software applications (Rosson, 1984). So why would they choose to develop new software?
The answer to why lies in people’s real world goals. In some situations the task at hand depends entirely on building a computational artifact – e.g., creating a spreadsheet model, building a website for oneself or a group, learning science via a simulation, or connecting a set of equipment and their inputs and outputs for a lab experiment. Such situations qualify as EUD because the creator is not trained in software development and is building an artifact to meet other primary goals (e.g., education, business models). End users in these situations need tools and languages that can guide design: they must decompose their problems in a way that lets them map from domain knowledge and goals to computational abstractions and procedures. Sometimes a domain-specific language is the best approach, other times a generic creativity medium like a spreadsheet or web authoring tool.
An even larger set of EUD situations falls under the concept of tailoring as summarized by Burnett and Scaffidi. In these cases a person becomes dissatisfied with the functionality of a piece of software and changes it. This may be a change to how a bit of functionality is accessed or viewed (e.g., customization of keys, buttons or layout); a small and focused extension (e.g., defining a new document formatting style or recording steps to be repeated as a macro); or the redefinition of central aspects of an application (e.g., designing a better install configuration for a work group). Morch (1997) posits three levels of tailoring: customizing existing functionality; integrating functionality available elsewhere; and extending a system with new functionality created by end users. The degree of modification increases at each level, along with the impact of the sociotechnical context of use. That is, while simple customization may be entirely up to an individual user and his or her preferences, extending an organizational tool is the result of a complex social network of stakeholders, even if the actual change is enacted by a single individual (Mackay, 1990; Nardi, 1993). When a situation calls for tailoring, a critical aspect of the supporting EUD tools is integration with the abstractions and mechanisms of the existing application and associated practices (Costabile et al., 2006).
That leaves us with the question of who. Many scholars have pointed to the emergence of specific individuals in organizations, using metaphors like “gardener” to describe some people’s willingness to synthesize, abstract and support the computational needs present in their sociotechnical context (Mackay, 1990; Nardi, 1993). Others have noted the personal characteristics of individuals who appear intrinsically motivated to notice and explore new technology options (Rosson, Ballin & Nash, 2004; Zang & Rosson, 2010). The design of EUD languages and tools might certainly begin with an emphasis on evoking and supporting these tendencies. More worrying however, is evidence that some groups of end users (e.g., women and minorities) have a sort of learned avoidance about EUD, likely due to a myriad of personal, technical and social factors (Beckwith, 2007). The paradox of the active user (Carroll & Rosson, 1987) and the attention investment model (Blackwell, 2001) offer an essential lesson: only when EUD tools or languages can suggest or evoke benefits that are perceived to be significant enough – at the moment in time that an opportunity arises – should we expect to see a full range of end users enjoying the power that such tools bring.
Interviewing Margaret Burnett and Chris Scaffidi in Rome, It...
Interviewing Margaret Burnett and Chris Scaffidi in Rome, It...
Interviewing Margaret Burnett and Chris Scaffidi in Rome, It...
Interviewing Margaret Burnett and Chris Scaffidi in Rome, It...
Give us your opinion! Do you have any comments/additions
that you would like other visitors to see?
Abraham, Robin and Erwig, Martin (2007): UCheck: A spreadsheet type checker for end users. In J. Vis. Lang. Comput., 18 (1) pp. 71-95
© All rights reserved Abraham and Erwig and/or their publisher
Abraham, Robin and Erwig, Martin (2004): Header and Unit Inference for Spreadsheets Through Spatial Analyses. In: VL-HCC 2004 - IEEE Symposium on Visual Languages and Human-Centric Computing 26-29 September, 2004, Rome, Italy. pp. 165-172
© All rights reserved Abraham and Erwig and/or IEEE Computer Society
Ayalew, Yirsaw and Mittermeir, Roland (2008): Spreadsheet Debugging. In CoRR, 0
Ayalew, Y. and Mittermeir, R. (2003): Spreadsheet debugging. In: Proceedings of the European Spreadsheet Risks Interest Group 2003. pp. 22-23
Blackwell, Alan (2006): Gender in Domestic Programming: from Bricolage to Séances d'Essayage. In: CHI2006 Workshop on End User Software Engineering 2006.
Blackwell, Alan (2004): End-user developers at home. In Communications of the ACM, 47 (9) pp. 65-66
Boal, Augusto (1992): Games for Actors and Non-Actors. Routledge
Boehner, Kirsten, dePaula, Rogerio, Dourish, Paul and Sengers, Phoebe (2007): How emotion is made and measured. In International Journal of Human-Computer Studies, 65 (4) pp. 275-291
Boehner, Kirsten, dePaula, Rogerio, Dourish, Paul and Sengers, Phoebe (2005): Affect: from information to interaction. In: Bertelsen, Olav W., Bouvin, Niels Olof, Krogh, Peter Gall and Kyng, Morten (eds.) Proceedings of the 4th Decennial Conference on Critical Computing 2005 August 20-24, 2005, Aarhus, Denmark. pp. 59-68
Brancheau, James C. and Wetherbe, James C. (1987): Key Issues in Information Systems Management. In MIS Quarterly, 11 (1) pp. 23-45
Brancheau, James C., Janz, Brian D. and Wetherbe, James C. (1996): Key Issues in Information Systems Management: 1994-95 SIM Delphi Results. In MIS Quarterly, 20 (2) pp. 225-242
Bricklin, D., Frankston, B. and Fylstra, D. (1979). VisiCalc, Software Arts. Retrieved 31 May 2011 from http://www.bricklin.com/history/intro.htm
Burnett, Margaret M. (2010): End-User Software Engineering and Why it Matters. In JOEUC, 22 (1) pp. 1-22
Burnett, Margaret M., Cook, Curtis R., Pendse, Omkar, Rothermel, Gregg, Summet, Jay and Wallace, Chris S. (2003): End-User Software Engineering with Assertions in the Spreadsheet Paradigm. In: Proceedings of the 25th International Conference on Software Engineering May 3-10, 2003, Portland, Oregon, USA. pp. 93-105
© All rights reserved Burnett et al. and/or IEEE Computer Society
Burnett, Margaret M., Sheretov, Andrei, Ren, Bing and Rothermel, Gregg (2002): Testing Homogeneous Spreadsheet Grids with the "What You See Is What You Test" Methodology. In IEEE Trans. Software Eng., 28 (6) pp. 576-594
Chambers, Chris and Erwig, Martin (2009): Automatic detection of dimension errors in spreadsheets. In J. Vis. Lang. Comput., 20 (4) pp. 269-283
© All rights reserved Chambers and Erwig and/or their publisher
Coblenz, Michael J., Ko, Andrew Jensen and Myers, Brad A. (2005): Using Objects of Measurement to Detect Spreadsheet Errors. In: VL-HCC 2005 - IEEE Symposium on Visual Languages and Human-Centric Computing 21-24 September, 2005, Dallas, TX, USA. pp. 314-316
© All rights reserved Coblenz et al. and/or IEEE Computer Society
Costabile, Maria Francesca, Fogli, Daniela, Mussio, Pero and Piccinno, Antonio (2006): End-user development: The software shaping workshop approach. In: Lieberman, Henry, Paterno, Fabio and Wulf, Volker (eds.). "End User Development (Human-Computer Interaction Series)". Springerpp. 183-205
Cypher, Allen (1993): Watch What I Do: Programming by Demonstration. Cambridge, MA, The MIT Press
Diaz, Paloma, Aedo, Ignacio and Rosson, Mary Beth (2008): Visual representation of web design patterns for end-users. In: Levialdi, Stefano (ed.) AVI 2008 - Proceedings of the working conference on Advanced Visual Interfaces May 28-30, 2008, Napoli, Italy. pp. 408-411
Dittrich, Yvonne, Lindeberg, Olle and Lundberg, Lars (2006): End-user development as adaptive maintenance. In: Lieberman, Henry, Paterno, Fabio and Wulf, Volker (eds.). "End User Development (Human-Computer Interaction Series)". Springerpp. 295-313
Erwig, Martin and Burnett, Margaret M. (2002): Adding Apples and Oranges. In: Krishnamurthi, Shriram and Ramakrishnan, C. R. (eds.) Practical Aspects of Declarative Languages, 4th International Symposium - PADL 2002 January 19-20, 2002, Portland, OR, USA. pp. 173-191
Fischer, Gerhard and Giaccardi, Elisa (2006): A framework for the future of end-user development. In: Lieberman, Henry, Paterno, Fabio and Wulf, Volker (eds.). "End User Development (Human-Computer Interaction Series)". Springerpp. 427-457
Fischer, Gerhard, Lemke, Andreas C., Mastaglio, Thomas W. and Morch, Anders (1990): Using Critics to Empower Users. In: Carrasco, Jane and Whiteside, John (eds.) Proceedings of the ACM CHI 90 Human Factors in Computing Systems Conference 1990, Seattle, Washington,USA. pp. 337-347
Fisher, Marc, Rothermel, Gregg, Brown, Darren, Cao, Mingming, Cook, Curtis R. and Burnett, Margaret M. (2006): Integrating automated test generation into the WYSIWYT spreadsheet testing methodology. In ACM Trans. Softw. Eng. Methodol., 15 (2) pp. 150-194
Google (2010). Google App Inventor. Retrieved [Date unavailable] from Google:
Ichbiah, Daniel and Knepper, Susan (1992): The Making of Microsoft: How Bill Gates and His Team Created the World's Most Successful Software Company. Prima Lifestyles
Jones, Simon L. Peyton, Blackwell, Alan and Burnett, Margaret M. (2003): A user-centred approach to functions in Excel. In SIGPLAN Notices, 38 (9) pp. 165-176
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
Ko, Andrew Jensen and Myers, Brad A. (2008): Debugging reinvented: asking and answering why and why not questions about program behavior. In: Schäfer, Wilhelm, Dwyer, Matthew B. and Gruhn, Volker (eds.) 30th International Conference on Software Engineering ICSE 2008 May 10-18, 2008, Leipzig, Germany. pp. 301-310
Ko, Andrew J., Abraham, Robin, Beckwith, Laura, Blackwell, Alan, Burnett, Margaret M., Erwig, Martin, Scaffidi, Christopher, Lawrance, Joseph, Lieberman, Henry, Myers, Brad A., Rosson, Mary Beth, Rothermel, Gregg, Shaw, Mary and Wiedenbeck, Susan (2011): The State of the Art in End-User Software Engineering. In ACM Computing Surveys, 43 (3) pp. 1-44
Koesnandar, Andhy, Elbaum, Sebastian G., Rothermel, Gregg, Hochstein, Lorin, Scaffidi, Christopher and Stolee, Kathryn T. (2008): Using assertions to help end-user programmers create dependable web macros. In: Harrold, Mary Jean and Murphy, Gail C. (eds.) Proceedings of the 16th ACM SIGSOFT International Symposium on Foundations of Software Engineering November 9-14, 2008, Atlanta, Georgia, USA. pp. 124-134
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
Leshed, Gilly, Haber, Eben M., Matthews, Tara and Lau, Tessa (2008): CoScripter: automating & sharing how-to knowledge in the enterprise. In: Proceedings of ACM CHI 2008 Conference on Human Factors in Computing Systems April 5-10, 2008. pp. 1719-1728
Letondal, Catherine (2006): Participatory programming: Developing programmable bioinformatics tools for end-users. In: Lieberman, Henry, Paterno, Fabio and Wulf, Volker (eds.). "End User Development (Human-Computer Interaction Series)". Springerpp. 207-242
Lieberman, Henry, Paterno, Fabio, Klann, Markus and Wulf, Volker (2006): End-user development: An emerging paradigm. End User Development. In: Lieberman, Henry, Paterno, Fabio and Wulf, Volker (eds.). "End User Development (Human-Computer Interaction Series)". Springerpp. 1-8
Liu, Hugo and Lieberman, Henry (2005): Metafor: visualizing stories as code. In: Amant, Robert St., Riedl, John and Jameson, Anthony (eds.) Proceedings of the 2005 International Conference on Intelligent User Interfaces January 10-13, 2005, San Diego, California, USA. pp. 305-307
Mackay, Wendy E. (1990): Patterns of Sharing Customizable Software. In: Halasz, Frank (ed.) Proceedings of the 1990 ACM conference on Computer-supported cooperative work October 07 - 10, 1990, Los Angeles, California, United States. pp. 209-221
McDaniel, Richard G. and Myers, Brad A. (1999): Getting More Out of Programming-by-Demonstration. In: Altom, Mark W. and Williams, Marian G. (eds.) Proceedings of the ACM CHI 99 Human Factors in Computing Systems Conference May 15-20, 1999, Pittsburgh, Pennsylvania. pp. 442-449
Morch, Anders and Mehandjiev, Nikolay D. (2000): Tailoring as Collaboration: The Mediating Role of Multiple Representations and Application Units. In Computer Supported Cooperative Work, 9 (1) pp. 75-100
© All rights reserved Morch and and/or Kluwer Academic Publishers
Nardi, Bonnie A. (1993): A Small Matter of Programming: Perspectives on End User Computing. Cambridge, Massachusetts, MIT Press
Newman, Mark W., Lin, James J. W., Hong, Jason I. and Landay, James A. (2003): DENIM: An Informal Web Site Design Tool Inspired by Observations of Practice. In Human-Computer Interaction, 18 (3) pp. 259-324
© All rights reserved Newman et al. and/or Taylor and Francis
Oney, Stephen and Myers, Brad A. (2009): FireCrystal: Understanding interactive behaviors in dynamic web pages. In: IEEE Symposium on Visual Languages and Human-Centric Computing - VL/HCC 2009 20-24 September, 2009, Corvallis, OR, USA. pp. 105-108
Panko, R. (1998): What we know about spreadsheet errors. In Journal of End User Computing, 10 pp. 15-21
Powell, Stephen G. and Baker, Kenneth R. (2003): The Art of Modeling with Spreadsheets: Management Science, Spreadsheet Engineering, and Modeling Craft. Wiley
Repenning, Alexander and Perrone, Corrina (2000): Programming by Analogous Examples. In Communications of the ACM, 43 (3) pp. 90-97
Resnick, Mitchel, Maloney, John, Monroy-Hernández, Andrés, Rusk, Natalie, Eastmond, Evelyn, Brennan, Karen, Millner, Amon, Rosenbaum, Eric, Silver, Jay S., Silverman, Brian and Kafai, Yasmin B. (2009): Scratch: programming for all. In Communications of the ACM, 52 (11) pp. 60-67
Ronen, Boaz, Palley, Michael A. and Jr., Henry C. Lucas (1989): Spreadsheet Analysis and Design. In Communications of the ACM, 32 (1) pp. 84-93
Rosson, Mary Beth, Sinha, Hansa and Edor, Tisha (2010): Design Planning in End-User Web Development: Gender, Feature Exploration and Feelings of Success. In: Hundhausen, Christopher D., Pietriga, Emmanuel, Diaz, Paloma and Rosson, Mary Beth (eds.) IEEE Symposium on Visual Languages and Human-Centric Computing, VL/HCC 2010 21-25 September 2010, 2010, Leganés-Madrid, Spain. pp. 141-148
Rosson, Mary Beth, Carroll, John M., Seals, Cheryl D. and Lewis, Tracy L. (2002): Community design of community simulations. In: Proceedings of DIS02: Designing Interactive Systems: Processes, Practices, Methods, & Techniques 2002. pp. 75-83
Rosson, Mary Beth, Sinha, Hansa, Bhattacharya, Mithu and Zhao, Dejin (2008): Design planning by end-user web developers. In J. Vis. Lang. Comput., 19 (4) pp. 468-484
Rosson, Mary Beth, Sinha, Hansa, Bhattacharya, Mithu and Zhao, Dejin (2007): Design Planning in End-User Web Development. In: VL-HCC 2007 - IEEE Symposium on Visual Languages and Human-Centric Computing 23-27 September, 2007, Coeur dAlene, Idaho, USA. pp. 189-196
© All rights reserved Rosson et al. and/or IEEE Computer Society
Scaffidi, Christopher (2009). Topes: Enabling End-User Programmers to Validate and Reformat Data, PhD Dissertation, Technical Report CMU-ISR-09-105. Institute for Software Research (ISR), Carnegie Mellon University
Scaffidi, Christopher, Cypher, Allen, Elbaum, Sebastian G., Koesnandar, Andhy and Myers, Brad A. (2008): Using scenario-based requirements to direct research on web macro tools. In J. Vis. Lang. Comput., 19 (4) pp. 485-498
Scaffidi, Christopher, Bogart, Christopher, Burnett, Margaret M., Cypher, Allen, Myers, Brad A. and Shaw, Mary (2010): Using traits of web macro scripts to predict reuse. In J. Vis. Lang. Comput., 21 (5) pp. 277-291
Scaffidi, Christopher, Myers, Brad A. and Shaw, Mary (2009): Fast, Accurate Creation of Data Validation Formats by End-User Developers. In: Pipek, Volkmar, Rosson, Mary Beth, Ruyter, Boris E. R. de and Wulf, Volker (eds.) End-User Development - 2nd International Symposium - IS-EUD 2009 March 2-4, 2009, Siegen, Germany. pp. 242-261
Scaffidi, Christopher, Shaw, Mary and Myers, Brad A. (2005): Estimating the Numbers of End Users and End User Programmers. In: VL-HCC 2005 - IEEE Symposium on Visual Languages and Human-Centric Computing 21-24 September, 2005, Dallas, TX, USA. pp. 207-214
Segal, Judith (2007): Some Problems of Professional End User Developers. In: VL-HCC 2007 - IEEE Symposium on Visual Languages and Human-Centric Computing 23-27 September, 2007, Coeur dAlene, Idaho, USA. pp. 111-118
Wilson, Aaron, Burnett, Margaret M., Beckwith, Laura, Granatir, Orion, Casburn, Ledah, Cook, Curtis, Durham, Mike and Rothermel, Gregg (2003): Harnessing curiosity to increase correctness in end-user programming. In: Cockton, Gilbert and Korhonen, Panu (eds.) Proceedings of the ACM CHI 2003 Human Factors in Computing Systems Conference April 5-10, 2003, Ft. Lauderdale, Florida, USA. pp. 305-312
Won, Markus, Stiemerling, Oliver and Wulf, Volker (2006): Component-based approaches to tailorable systems. In: Lieberman, Henry, Paterno, Fabio and Wulf, Volker (eds.). "End User Development (Human-Computer Interaction Series)". Springerpp. 115-141
Wulf, Volker, Pipek, Volkmar and Won, Markus (2008): Component-based tailorability: Enabling highly flexible software applications. In International Journal of Human-Computer Studies, 20 (1) pp. 1-22
Yang, Sherry, Burnett, Margaret M., DeKoven, Elyon and Zloof, Moshé M. (1997): Representation Design Benchmarks: A Design-Time Aid for VPL Navigable Static Representations. In J. Vis. Lang. Comput., 8 (5) pp. 563-599
Zang, Nan, Rosson, Mary Beth and Nasser, Vincent (2008): Mashups: who? what? why?. In: Proceedings of ACM CHI 2008 Conference on Human Factors in Computing Systems April 5-10, 2008. pp. 3171-3176
...with the exception of materials described in...:
Furthermore, your use of Interaction-Design.org signifies your consent to:
THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.
BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.
1. Definitions
2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.
3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:
For the avoidance of doubt:
The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats, but otherwise you have no rights to make Adaptations. Subject to Section 8(f), all rights not expressly granted by Licensor are hereby reserved.
4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:
5. Representations, Warranties and Disclaimer
UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.
6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
7. Termination
8. Miscellaneous
The Interaction-Design.org Addendum to the Creative Commmons licence is a placeholder for additions to the Creative Commons licence, which are deemed necessary to include in consideration of Danish law and the operation of this site and The Interaction-Design.org Foundation.
Attribution must be clearly given, i.e. the author's name, the title and URL of this work/publication/web page must clearly appear. The attribution must be given in a manner appropriate to the medium in which it is given: For example, electronic copies must include a clickable URL, which does not use the nofollow attribute value.
The Interaction-Design.org Foundation reserves the unilateral right to update, modify, change and alter its Site Terms and Conditions as well as Copyright Terms at any time. All such updates, modifications, changes and alterations are binding on all users and browsers of Interaction-Design.org and will be posted here.
In some cases, a page/work may include content, such as an image, that is not covered by the copyright terms (i.e. "The Interaction-Design.org Addendum to the Creative Commons licence" and the "Creative Commons Attribution-NoDerivs 3.0 Unported"). When this is the case, we clearly label the content. For images, we also include the copyright label inside the image file (i.e. the full-resolution version) in metadata types like EXIF, IPTC, and XMP. We only include and label content with the following copyright terms:
In addition, content linked from a page is not covered by one of our licenses unless specifically noted. For example, pages may link to videos or slide decks that are not covered. The design of Interaction-Design.org (graphics, html, client-side scripts, etc.) is copyright of Mads Soegaard.
Please read these terms and conditions (the "Terms") carefully before using Interaction-Design.org. By using Interaction-Design.org you signify your consent to these Terms. If you do not agree to the Terms please do not use Interaction-Design.org. The Terms addresses your legal rights and obligations and includes important disclaimers and choice of law and forum provisions. Please read carefully.
Interaction-Design.org is owned and operated by The Interaction-Design.org Foundation, a privately held corporation incorporated under the laws of Denmark, with office in Aarhus, Denmark.
Address:
The Interaction-Design.org Foundation
Att: Mads Soegaard
Chr. Molbechs Vej 4
DK-8000 Aarhus C.
Denmark
Interaction-Design.org is run by The Interaction-Design.org Foundation, a privately held corporation residing in Aarhus, Denmark. You agree that these Terms and your use of Interaction-Design.org are governed by the laws of Denmark. You hereby consent to the exclusive jurisdiction and venue of the courts, tribunals, agencies and other dispute resolution organizations in Denmark in all disputes
The Interaction-Design.org Foundation has endeavoured to comply with all legal requirements known to it in creating and maintaining Interaction-Design.org, but makes no representation that materials on Interaction-Design.org are appropriate or available for use in any particular jurisdiction. You are responsible for compliance with applicable laws. Any use in contravention of this provision or any provision of these Terms is at your own risk and, if any part of these Terms is invalid or unenforceable under applicable law, the invalid or unenforceable provision will be deemed superseded by a valid, enforceable provision that most closely matches the intent of the original provision and the remainder of these Terms shall govern such use.
Your use of and browsing Interaction-Design.org is at your own risk. The Interaction-Design.org Foundation does not warrant that the software used for Interaction-Design.org, and the information, material, and content on it, or any other services provided by means of Interaction-Design.org are error-free, or that their use will be uninterrupted. The Interaction-Design.org Foundation expressly disclaims all warranties related to the above-mentioned subject matter, including, without limitation, those of accuracy, condition, merchantability and fitness for particular purpose. Notwithstanding anything to the contrary on Interaction-Design.org, in no event shall The Interaction-Design.org Foundation be liable for any loss of profits, revenues, indirect, special, incidental, consequential, or other similar damages arising out of or in connection with Interaction-Design.org or out of the use of any of the services proposed by means of Interaction-Design.org.
The Interaction-Design.org Foundation reserves the unilateral right to update, modify, change and alter its Site Terms and Conditions as well as Copyright Terms at any time. All such updates, modifications, changes and alterations are binding on all users and browsers of Interaction-Design.org and will be posted here.
The Interaction-Design.org Foundation and its authors make no representations as to accuracy, completeness, currentness, suitability, or validity of any information, material, or content on Interaction-Design.org.
THE MATERIAL AND CONTENT POSTED ON INTERACTION-DESIGN.ORG ARE PROVIDED "AS IS" WITHOUT ANY EXPRESS WARRANTY OR IMPLIED WARRANTY OF ANY KIND INCLUDING WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT OF INTELLECTUAL PROPERTY, OR FITNESS FOR ANY PARTICULAR PURPOSE. IN NO EVENT SHALL THE INTERACTION-DESIGN.ORG FOUNDATION BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF PROFITS, BUSINESS INTERRUPTION, LOSS OF INFORMATION) ARISING OUT OF THE USE OF OR INABILITY TO USE THE MATERIALS, EVEN IF THE INTERACTION-DESIGN.ORG FOUNDATION HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
Because some jurisdictions prohibit the exclusion or limitation of liability for consequential and or incidental damages, the above limitation may not apply to you. Furthermore, The Interaction-Design.org Foundation does not warrant the accuracy or completeness of information of links or other items contained within these materials that have been provided by third parties.
Please contact us at mads@interaction-design.org if you, or your organization, wish to correct or change attribution or presentation of any image/material used on Interaction-Design.org, which you, or your organization, are the rightful copyright holder of. We will request that you submit proof of your ownership of the copyright on this material but will act immediately on any reasonable request.
Every effort has been made by the individual contributing authors as well as The Interaction-Design.org Foundation to discover and contact copyright holders of artwork/illustrations/content used on Interaction-Design.org. To the extent that a copyright holder could not be found or an inadvertent permissions or copyright error was made, The Interaction-Design.org Foundation stands ready to remove content upon notice and request by a copyright holder. In the case that you believe that any content or other material provided through Interaction-Design.org infringes your copyright, you should notify The Interaction-Design.org Foundation of your infringement claim in accordance with the procedure set forth below.
We will process each notice of alleged infringement which The Interaction-Design.org Foundation receives and take appropriate action in accordance with applicable intellectual property laws. A notification of claimed copyright infringement should be emailed to mads@interaction-design.org (subject: "Takedown Request"). You may also contact us by mail at:
The Interaction-Design.org Foundation
Att: Mads Soegaard
Chr. Molbechs Vej 4
DK-8000 Aarhus C.
Denmark
To be effective, the notification must be in writing and contain the following information:
All trademarks, logos, service marks, collective marks, design rights, personality rights or similar rights that are mentioned, used or cited on Interaction-Design.org are the property of their respective owners. The use of any trademark on Interaction-Design.org does not vest in the author or The Interaction-Design.org Foundation any trademark ownership rights in such trademarks, nor does the use of such trademarks imply any affiliation with or endorsement of The Interaction-Design.org Foundation and its authors by such owners. As such The Interaction-Design.org Foundation can not grant any rights to use any otherwise protected materials. Your use of any such or similar incorporeal property is at your own risk.
Screenshots of copyrighted computer software, for which the copyright is held by the author(s) or the company that created the software, is believed to fall under the fair use doctrine in the US (and similar laws in other countries). It is believed that reproduction for purposes such as criticism, comment, news reporting, teaching, or research is not copyright infringement. If you reuse screenshots, as well as any other information on Interaction-Design.org, you do so at your own risk and under the copyright laws of your country.
Abstracts in the Wiki Bibliography (/references/) are submitted by their authors who use the wiki to make their research as accessible as possible. When a page on Interaction-Design.org cites/references/lists a work from the bibliography, its abstract is included. However, abstracts have varying copyrights depending which publisher the work is published through. You should assume that an abstract is copyright, all rights reserved, of its publisher and/or author and therefore always use/cite abstracts according to Fair Use. You may visit the publisher's website to learn about the specific copyright terms (e.g. ACM, IEEE, or Springer) or contact the author directly. Bottom line: Cite/use abstracts according to the principles of fair use as it may otherwise be construed as a copyright infringement and subject to legal action.
You understand and acknowledge that additions to the Wiki Bibliography (including article abstracts), additions the Conference Calendar (including conference descriptions), user-contributed notes on each page (including text, photographs, graphics), or other materials posted by users on Interaction-Design.org ("Content") are the sole responsibility of the person from whom such Content originated. This means that you, and not The Interaction-Design.org Foundation, are entirely responsible for all Content that you upload, post or otherwise make available to other users of Interaction-Design.org.
When submitting content to Interaction-Design.org, you agree to not:
You acknowledge that The Interaction-Design.org Foundation shall have the right to remove any Content that violates these Site Terms and Conditions or is otherwise objectionable.
If we provide links or pointers to other websites, no inference or assumption should be made that The Interaction-Design.org Foundation operates, controls, or is otherwise connected with these websites. When you click on a link within Interaction-Design.org, we will not warn you that you have left a Site and are subject to the terms and conditions (including privacy policies) of the destination website. In some cases it may be less obvious than others that you have left a Site and reached another website. Please be careful to read the terms of use and privacy policy of any website before you provide any confidential information or engage in any transactions. You should not rely on these Terms for another website. The Interaction-Design.org Foundation is not responsible for the content or practices of any other website. By using Interaction-Design.org, you acknowledge and agree that The Interaction-Design.org Foundation is not responsible or liable to you for any content or other materials hosted and served from any third party website.
Email messages sent from members of The Interaction-Design.org Foundation, including emails generated from the use of the interaction-design.org website, are proprietary to The Interaction-Design.org Foundation, and are intended solely for the use of the individual to whom they are addressed. Such messages may contain privileged or confidential information and should not be circulated or used for any purpose other than for what they are intended. If you receive a message from a member of The Interaction-Design.org Foundation in error, please notify the sender immediately. If you are not the intended recipient, you are hereby notified that you are strictly prohibited from using, copying, altering, or disclosing the contents of the message. The Interaction-Design.org Foundation accepts no responsibility for loss or damage arising from the use of the information transmitted by email message including damage from virus.
Please make sure that you understand that the information provided by The Interaction-Design.org Foundation is being provided freely, and that no kind of agreement or contract is created between you and the owners, partners, users, or authors of this site, the owners of the servers upon which it is housed, the individual contributors of the The Interaction-Design.org Foundation, any project administrators, sysops or anyone else who is in any way connected with this project. If you choose to use or copy anything from from this site it does not create or imply any contractual or extracontractual liability on the part of The Interaction-Design.org Foundation or any of its members, partners, sponsors, contributors or other users. Your use of any such or similar incorporeal property is at your own risk.
Any dispute arising from the use of Interaction-Design.org or the interpretation of the terms is governed by the laws of Denmark, and shall be settled by the courts of Denmark. All communications regarding legal matters must be made in writing to
The Interaction-Design.org Foundation
Att: Mads Soegaard
Chr. Molbechs Vej 4
DK-8000 Aarhus C.
Denmark

I only have one big research question, but I attack it from a lot of different angles. The question is representation. How do people make, see and use things that carry meaning? The angles from which I attack my question include various ways in which r...
More about Alan >>I am a Professor of Information Sciences and Technology, and Affiliate Professor of Instructional Systems in the College of Education. With Dr. John Carroll, I co-direct the Computer-Supported Collaboration and Learning (CSCL). I am also a founding member of P...
More about Mary >>
Reviewer 1: Name suppressed
Reviewer 2: Name suppressed
Peer-review is based on the reviewing guidelines and coordinated by the Reviewing Board.
Authoritative overview of Social Computing by Tom Erickson - veteran researcher at IBM Research Lab. It includes 9 HD videos filmed in Copenhagen.
Read Thomas's chapter