The StoryTime project explores the benefits of and issues surrounding the use of mobile finger-touch devices to support struggling writers. StoryTime is a mobile finger-touch tool designed from a learner-centered design perspective to be a supportive writing tool for children 7--9 years old. StoryTime allows children to write stories by providing simpler writing mechanics, increased user engagement, and a contextualized writing experience. The combination of these attributes allows struggling writers to focus more on the sentence construction task. Here we describe the iterative design and testing of three versions of StoryTime on 13 children to date.

Chemation, a simple 2-D modeling and animation tool for handhelds (e.g., PalmOS computers), was developed to help teach important chemistry concepts, such as chemical reaction, conservation of mass, and the particulate nature of matter (as specified in national standards). Users build 2-D molecular models of substances and then, through a process of copying and modifying the model, create flipbook-style animations to illustrate various processes. Chemation is currently being piloted by teachers using a standards-based, inquiry-oriented 7th grade chemistry curriculum. The tool is intended to be an alternative or a supplement to current hands-on activities in which students build physical (ball-and-stick) models to represent various chemical phenomena. In this demonstration, we will show the basic functions of Chemation highlighting its important features---modeling and animation of chemical processes on a handheld tool. We will also show example student models of various chemical processes.

Handheld computers are mobile, flexible devices that can provide real-time, one-to-one support for students from within the context of their learning activities. This paper describes the design of three learner-centered handheld tools used as part of a nine-month classroom study involving thirty-three eighth grade students. A review of related work identifies some of the challenges of building educational software within the constraints of handheld screens, and two broad design guidelines are synthesized to help address these challenges. The first design guideline focuses on decomposing the learning activity to identify salient tasks and the type of supports (or scaffolds) students need to engage in these tasks, then building separate handheld workspaces to support each task. The second guideline focuses on methods for implementing scaffolds within these task-based workspaces while preserving the usability of the overall handheld software.

Our project explores the benefits and challenges of using handheld computers to support learners in creating concept maps (a type of visual outline). By synthesizing research on small user interfaces with guidelines for building desktop learning tools, we identified potential challenges to using handhelds for complex learning tasks and developed new design guidelines to address these issues. We applied these guidelines to the design of Pocket PiCoMap, a learner-centered concept mapping tool for handheld Pocket PCs. As part of a 9-month classroom study, students used both the handheld Pocket PiCoMap and a comparable desktop concept mapping tool called PiViT. The goal of this comparison between handheld and desktop tools was to better understand how the different form factors of these computers impact students' work processes and products. Our results suggest that students can successfully complete complex learning activities using handheld tools, and that specialized supports (called scaffolds) can be used to help students create better concept maps. This study also identifies several areas where handheld learning tools need further improvements, such as helping students organize their work within the confines of small handheld screens, and we discuss ways in which scaffolds might be used to improve future handheld learning tools.

A challenge for HCI researchers and designers involves developing software tools for learners to support them in mindfully doing and learning complex new work practices. Such "learner-centered" tools incorporate scaffolds-software features that address the cognitive obstacles learners face so they can engage in the work in an educationally productive manner. However, designers still lack specific scaffolding design guidelines for developing effective scaffolded tools. The HCI contribution of this paper is a set of scaffolding guidelines distilled from an empirical case study. The study evaluated Symphony, a scaffolded environment for high school students learning science inquiry. The study evaluated the "effects with" the Symphony scaffolds, which described how students worked with the scaffolds to do their science work. The scaffolds were evaluated using several usability and learner-centered criteria, and the resulting information was correlated with structural characteristics of the scaffolds to distill a set of structural scaffolding guidelines

Research into student use of scaffolding features and representation issues encountered while using the ARTEMIS Digital Library is discussed. Research agenda, methods, preliminary findings, and future research directions are presented. Preliminary findings indicate that students exhibit some commonalities in their patterns of system and scaffold use.

Inquiry-based curricula encourage students to develop research and collaboration skills by working with evidence and exploring real problems. Students engaging in inquiry projects must be supported in learning the content and work practices of a domain. SWEets, or scaffolded work environments, are one method of providing this support. We present a new software engineering process for designing SWEets for any educational domain and describe the application of this process to the development of Clio, a Web-based SWEet for high school history students. The Clio SWEet was piloted in two classroom studies and preliminary data indicate that students were able to use the software to successfully gather and analyze data as part of an inquiry-based classroom curriculum.

Learner-centered design is an evolving design perspective focusing on the design of software scaffolds to support novice learners in using software to do and learn previously unknown work practices. Scaffolding evaluation is necessary to see how well learners can perform new work activity using the scaffolded software. However, scaffolding evaluation is challenging because of the need to address several issues resulting from the interplay between user-centered and learner-centered perspectives. Scaffolding evaluation methods need specific criteria to address learner-centered concerns, traditional usability measures to address user-centered concerns, and considerations of the instances when usability conflicts with the learning goals of scaffolded tools. The authors discuss these learner-centered evaluation issues and a scaffolding evaluation method to assess, not just the usability of the software, but also the effectiveness of the scaffolds in terms of the learning goals behind the software.

Learner-centered design (LCD) is an evolving design approach for designing tools that support learners trying to engage in and understand complex work practices in which they are novices. Learner-centered design focuses on developing tools that incorporate support (or “scaffolding”) to support the novice in seeing and doing complex, unknown work so that the learner can begin developing an understanding of that work in a “learning by doing” fashion. In this tutorial, we will give participants a more in-depth treatment of learnercentered design by describing a definition for LCD, theoretical background, and the LCD process and methods to give participants experience with the mindset needed for the LCD approach.

We are exploring a new class of tools for learners: scaffolded integrated tool environments (or SITES), which address the needs of learners trying to engage in new, complex work processes. A crucial phase within a learner-centered design approach for SITE design involves analyzing the work process to identify areas where learners need support to engage in the process. Here we discuss the design of Symphony, a SITE for high-school science students. Specifically, we discuss how the process-space model helped us analyze the science inquiry process to help us identify a detailed set of learner needs, leading to a full set of process scaffolding strategies for Symphony.

Article Free Access Share on The design of guided learner-adaptable scaffolding in interactive learning environments Authors: Shari L. Jackson College of Engineering, School of Education, School of Information, University of Michigan, 1101 Beal Ave., Ann Arbor, MI College of Engineering, School of Education, School of Information, University of Michigan, 1101 Beal Ave., Ann Arbor, MIView Profile , Joseph Krajcik College of Engineering, School of Education, School of Information, University of Michigan, 1101 Beal Ave., Ann Arbor, MI College of Engineering, School of Education, School of Information, University of Michigan, 1101 Beal Ave., Ann Arbor, MIView Profile , Elliot Soloway College of Engineering, School of Education, School of Information, University of Michigan, 1101 Beal Ave., Ann Arbor, MI College of Engineering, School of Education, School of Information, University of Michigan, 1101 Beal Ave., Ann Arbor, MIView Profile Authors Info & Claims CHI '98: Proceedings of the SIGCHI Conference on Human Factors in Computing SystemsJanuary 1998 Pages 187–194https://doi.org/10.1145/274644.274672Published:01 January 1998Publication History 75citation1,984DownloadsMetricsTotal Citations75Total Downloads1,984Last 12 Months181Last 6 weeks13 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Article ARTEMIS: learner-centered design of an information seeking environment for K-12 education Share on Authors: Raven Wallace University of Michigan, School of Education, 610 East University, Ann Arbor, MI University of Michigan, School of Education, 610 East University, Ann Arbor, MIView Profile , Elliot Soloway University of Michigan, School of Information, 550 East University, Ann Arbor, MI University of Michigan, School of Information, 550 East University, Ann Arbor, MIView Profile , Joseph Krajcik University of Michigan University of MichiganView Profile , Nathan Bos University of Michigan University of MichiganView Profile , Joseph Hoffman University of Michigan University of MichiganView Profile , Heather Eccleston Hunter University of Michigan University of MichiganView Profile , Dan Kiskis University of Michigan University of MichiganView Profile , Elisabeth Klann University of Michigan University of MichiganView Profile , Greg Peters University of Michigan University of MichiganView Profile , David Richardson University of Michigan University of MichiganView Profile , Ofer Ronen University of Michigan University of MichiganView Profile Authors Info & Claims CHI '98: Proceedings of the SIGCHI Conference on Human Factors in Computing SystemsJanuary 1998 Pages 195–202https://doi.org/10.1145/274644.274673Online:01 January 1998Publication History 27citation726DownloadsMetricsTotal Citations27Total Downloads726Last 12 Months13Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteGet Access

No abstract available.

No abstract available.

The design of software for learners must be guided by educational theory. We present a framework for learner-centered design (LCD) that is theoretically motivated by sociocultural and constructivist theories of learning. LCD guides the design of software in order to support the unique needs of learners: growth, diversity, and motivation. To address these needs, we incorporate scaffolding into the context, tasks, tools, and interface of software learning environments. We demonstrate the application of our methodology by presenting two case studies of LCD in practice.

No abstract available.

Software maintenance programmers face the daunting task of understanding and modifying complex, unfamiliar programs that contain delocalized plans (conceptually related code that is not located contiguously in a program). Our research shows that programmers use an as-needed strategy when searching for the delocalized components which they need to understand. We have developed a maintenance tool, Whorf, that provides explicit support for visualizing and understanding delocalized plans using an as-needed strategy. Whorf supports this strategy through multiple, concurrent views of the software with instant, easy access to additional views. It supports the understanding of delocalized plans by providing hypertext links between views to highlight interactions between physically disparate components. A study comparing the usage of Whorf and paper documentation shows that the dynamic views and structure supported by Whorf provide information more quickly and easily than the static structure of paper documentation.

No abstract available.

The notion that children learn by constructing their own knowledge is highly popular these days among educational theorists. But what are the particular abilities that enable learners to be successful? And how must computer systems, and in particular their user interfaces, be designed to foster and support those abilities? The panel members represent several nationally-recognized education projects, all designed to give children control over their own learning while, at the same time, providing supports for effective learning strategies. They will discuss the unique design issues–resolved and unresolved–that arise as cognitive theories meet classroom realities. CSILE, a collaborative, user-constructed database, JASPER, a video-based mathematics program, and MediaText, a multi-media authoring environment, are available for use and review by CHI92 attendees prior to the panel presentation.

Software documentation should be useful to the programmer trying to understand a program. The key in that sentence was the word should: by and large documentation has a very bad reputation. We have been working on trying to improve documentation, in order that it may realize its potential. In this case study, we examine a programmer's use of documentation constructed along some specific guidelines. These guidelines, developed from our previous studies of documentation, are intended to help programmers draw causal connections between non-contiguous portions of programming plans in the program. This documentation appears to be helpful to a particular class of programmers, i.e., those who come to a program without the requisite background knowledge.

In this paper, we investigate whether or not most novice programming bugs arise because students have misconceptions about the semantics of particular language constructs. Three high frequency bugs are examined in detail — one that clearly arises from a construct-based misconception, one that does not, and one that is less cut and dry. Based on our empirical study of 101 bug types from three programming problems, we will argue that most bugs are not due to misconceptions about the semantics of language constructs.

In this article we present a preliminary cognitive model of the process of software design. Our goal was to develop a model of expert problem-solving skills for a task in which domain knowledge played an extensive role. In our model the process of design is captured via goals-and-operators interacting with a knowledge base. We have defined the goals and operators as ones which are general to design, rather than specific to the current task. In addition, we have structured the atomic level operators so that they are able to access domain specific knowledge acquired through experience. This structure enables both general processes and domain specific knowledge to play critical roles in producing any particular design artifact. From our protocol analysis we have built a model which unites several recurring behaviors into an interpretable whole. the behaviors we account for include the building of mental models, mental simulation, and balanced development.

Research issues concerning human interaction with computers have become crucial because of dramatic increases in the number of computer users who have no formal mathematical, engineering, or computer science training. This review focuses on the state of the art in Software Psychology--the study of human factors in computer systems. One area of software psychology, the psychology of programming, is picked for an in-depth discussion of research results. This area was selected for its interest to the readers of the PROCEEDINGS OF THE IEEE. The review then discusses the methodological issues involved in performing experimental research in software psychology. Future trends are discussed both for the programming research reviewed here and for the whole field of software psychology. The conclusions identify multidisciplinary training and research as critical to further progress in this field.

In this paper we propose one explanation of why some novice programs are buggier than others. Central to our explanation is the notion of merged goals/plans in which multiple goals are achieved in a single integrated plan. Our arguments are based on our theory of the knowledge — plans and goals — used by a novice in creating a program, and an analysis of actual buggy novice programs.

We present a process model to explain bugs produced by novices early in a programming course. The model was motivated by interviews with novice programmers solving simple programming problems. Our key idea is that many programming bugs can be explained by novices inappropriately using their knowledge of step-by-step procedural specifications in natural language. We view programming bugs as patches generated in response to an impasse reached by the novice while developing a program. We call such patching strategies bug generators. Several of our bug generators describe how natural language preprogramming knowledge is used by novices to create patches. Other kinds of bug generators are also discussed. We describe a representation both for novice natural language preprogramming knowledge and novice fragmentary programming knowledge. Using these representations and the bug generators, we evaluate the model by analyzing four interviews with novice programmers.

"Introduction to this Special issue on Novice Programming." Human–Computer Interaction, 1(2), pp. 105–106

In this paper, we present a descriptive theory of buggy novice programs and a bug categorization scheme that is based on this theory. Central to this theory is the cognitively plausible knowledge - goals and plans - that underlies programming. The bug categorization scheme makes explicit problem-dependent goal and plan knowledge at many different levels of detail. We provide several examples of how the scheme permits us to focus on bugs in a way that facilitates generating plausible accounts of why the bugs may have arisen. In particular, our approach has led us to one explanation of why some novice programs are buggier than others. A basic part of this explanation is the notion of merged goals and merged plans in which a single integrated plan is used to achieve multiple goals.

A designer's expertise rests on the knowledge and skills which develop with experience in a domain. As a result, when a designer is designing an object in an unfamiliar domain he will not have the same knowledge and skills available to him as when he is designing an object in a familiar domain. In this paper we look at the software designer's underlying constellation of knowledge and skills, and at the way in which this constellation is dependent upon experience in a domain. What skills drop out, what skills, or interactions of skills come forward as experience with the domain changes? To answer the above question, we studied expert designers in experimentally created design contexts with which they were differentially familiar. In this paper we describe the knowledge and skills we found were central to each of the above contexts and discuss the functional utility of each. In addition to discussing the knowledge and skills we observed in expert designers, we will also compare novice and expert behavior.

This paper describes a program called PROUST which does on-line analysis and understanding of Pascal written by novice programmers. PROUST takes as input a program and a nonalgorithmic description of the program requirements, and finds the most likely mapping between the requirements and the code. This mapping is in essence a reconstruction of the design and implementation steps that the programmer went through in writing the program. A knowledge base of programming plans and strategies, together with common bugs associated with them, is used in constructing this mapping. Bugs are discovered in the process of relating plans to the code; PROUST can therefore give deep explanations of program bugs by relating the buggy code to its underlying intentions.

We suggest that expert programmers have and use two types of programming knowledge: 1) programming plans, which are generic program fragments that represent stereotypic action sequences in programming, and 2) rules of programming discourse, which capture the conventions in programming and govern the composition of the plans into programs. We report here on two empirical studies that attempt to evaluate the above hypothesis. Results from these studies do in fact support our claim.

While programmers may differ in their assessment of the comprehensibility of a program, there are nonetheless some clear cut cases of programs that are truly difficult to understand. In this paper, we analyze three programs—two of which are relatively incomprehensible—using Halstead's Volume Metric, Propositional Analysis and Plan Analysis. We argue that only Plan Analysis provides a satisfactory explanation for why the programs in question differ with respect to understandability. Moreover, we suggest that a qualitative analysis, such as provided by Plan Analysis, is the desired type of evaluation: rather than simply providing a numerical ranking for programs, the qualitative analysis can pinpoint the troublesome area in the code and provide prescriptive information for correcting the difficulty.

It is widely known that programming, even at a simple level, is a difficult activity to learn. Why is this so? Are novice difficulties really inherent in programming or are they related, to the nature of the programming tools currently given to novices? To answer this question we have used novice Pascal computer programs collected from their terminal sessions, controlled clinical studies focusing on specific aspects of novice programming techniques, and video-taped interviews of novice programming [Bonar, 1982]. In each we focused on bugs and buggy programs. Bugs and errors illuminate what a novice is actually thinking -- providing us a window on the difficulties as they are experienced by the novice.In previous reports we presented evidence that current programming languages do not accurately reflect the cognitive strategies used by novice programmers [Soloway et al, 1981]. Instead, we have found that novice programmers possess knowledge about and experience with step-by-step specifications in natural language. This knowledge and experience gives them powerful intuitions for using a programming language. Programming languages, however, are, not designed to appeal to these intuitions. On a semantic and pragmatic level, there are incompatibilities between the way, natural and programming languages are used. Many novice programming bugs can be directly traced to an inappropriate use of natural language specification style or strategy.As an example of these incompatibility bugs consider the "while demon" bug. Novices with this bug assume that the actions in the body of the while loop are continuously monitored for the exit condition to become true. This interpretation is consistent with the English language usage of the word while: e.g."while the highway is two lanes, continue, north". In an earlier written study [Soloway et al, 1981] found that 34% of the students in an introductory programming course thought the test in a Pascal while loop was performed, as a demon. Furthermore, a later interview study showed that novices could even describe the implementation mechanism for such a demon:"… everytime I [the variable tested in the while condition] is assigned a new value, the machine needs to check that value …"In this report we describe our use of video-taped interview studies for understanding how novices use a programming system. Interviews provide valuable information not available through statistical analysis of written studies. Written studies allow us to manipulate specific factors and guage the results to performance or style. Furthermore, we can have statistical confidence in those results. An interview study, on the other hand, allows us to examine the source of performance or style differences uncovered. Interviews give us an "execution trace" while written studies give us the final output. We use both kinds of studies, depending on the kind of information needed.We have interviewed seventeen novice programmers. Four were interviewed regularly for the first 8-10 weeks of their introductory programming course. For these regular subjects we have about 15 hours of interviews tracing their learning and maturation through the course.In this report we show an example natural language specification and discuss strategies used in that specification. We then discuss two examples of novice programming difficulties stemming from an inappropriate use of natural language specification strategies. These examples are illustrated with video tape transcripts. We conclude with a brief discussion of the implications of this work.

The Cognition and Programming Group at Yale University is engaged in two complementary efforts:

An important learning skill is the ability to make abstractions, i.e., to construct classification schemes which highlight similarities and differences. In this paper we shall outline the content of a undergraduate course which attempts to teach this skill in the context of teaching introductory LISP programming and problem solving. The key to this enterprise has been the development of: