Novice Programming Environments

Explorations in Human-Computer Interaction and Artificial Intelligence

Marc Eisenstadt, Mark Keane, Tim Rajan, Marc Eisenstadt, Mark Keane, Tim Rajan, Marc Eisenstadt, Mark T. Keane, Tim Rajan

• Publisher: Taylor & Francis
• Year: 2018
• Print ISBN: 9780815351627
• eBook ISBN: 9781351141260
• Edition: 1
• Topic: Psychology
• Subtopic: Cognitive Psychology & Cognition
• Index: Psychology

This book, originally published in 1992, encapsulates ten years of research at the Open University's Human Cognition Research Laboratory. The research investigates the problems of novice programmers, and is strongly oriented toward the design and implementation of "programming environments" aimed at eliminating or easing novices' problems. A range of languages is studied: Pascal, SOLO, Lisp, Prolog and "Knowledge Engineering Programming". The primary emphasis of the empirical studies is to gain some understanding of novices' "mental models" of the inner workings of computers. Such (erroneous) models are constructed by novices in their own heads to account for the idiosyncrasies of particular programming languages. The primary emphasis of the implementations described in the book is the provision of "automatic debugging aids", i.e. artificial intelligence programs which can analyse novices' buggy programs, and make sense of them, thereby providing useful advice for the novices.

Another related strand taken in some of the work is the concept of "pre-emptive design", i.e. the provision of tools such as syntax-directed editors and graphical tracers which help programmers avoid many frequently-occurring errors. A common thread throughout the book is its Cognitive Science/Artificial Intelligence orientation. AI tools are used, for instance, to construct simulation models of subjects writing programs, in order to provide insights into what their deep conceptual errors are. At the other extreme, AI programs which were developed in order to help student debug their programs are observed empirically in order to ensure that they provide facilities actually needed by real programmers.

This book will be of great interest to advanced undergraduate, postgraduate, and professional researchers in Cognitive Science, Artificial Intelligence, and Human-Computer Interaction.

IDesign Issues in Programming Environments

The first part of this book contains four chapters which look at the design issues involved in programming environments. The programming environments described vary both in their intended user group, the scope of the programming domain, and the mode of presentation.

For example, the first chapter by Eisenstadt presents an environment which combines a programming language, SOLO, and a curriculum which aims to support Psychology undergraduates who have no previous experience of programming. Although the design issues pervade all aspects of the user’s interaction with the computer, the scope of the domain is small (i.e. to build simple AI models of psychological theories in a limited time period). The SOLO language is therefore very simple, and limited in its expressive power. This trade-off means that while SOLO is perfect for the task and group it was designed for, it is very limited for use elsewhere. However, the lessons learned from the design and use of this environment have been put to good use as can be seen in Chapter 3.

In Chapter 2, Rajan describes the design of an Animated Program Tracer, APT, which aims to provide a faithful story of the execution of Prolog programs. As in the previous chapter the user group is limited to novice programmers, although in this case the language being supported is a full blown artificial intelligence programming language which exhibits complex and unintuitive behaviour. The technique used by APT to explain the behaviour of Prolog programs is that of text animation, where each step of the execution represents one frame of the animated sequence. The user moves through the animation which is designed to reflect the dynamic behaviour of the Prolog interpreter.

The paper by Eisenstadt and Brayshaw presented in Chapter 3 builds on and extends the design principles detailed in the previous two chapters. It describes the Transparent Prolog Machine and its associated curriculum. Whereas SOLO and APT are limited in their intended user group and/or the scope of the language, TPM provides a “cradle to grave” environment for Prolog programmers. As such, it provides a medium both for learning Prolog, and developing and debugging complex programs. The technique used to explain execution behaviour is, as with APT, animation. However, where APT used text, TPM uses graphics as the basis for its animation. The use of graphics allows TPM to cater for all manner of Prolog users, ranging from beginners through to old hands, and are used extensively throughout the course material.

The last chapter, by Domingue and Eisenstadt, describes TRI, the Transparent Rule Interpreter. TRI is a debugging environment for the rule-based component of a knowledge engineering environment, and as such covers both forward chaining and backward chaining rule interpreters. This chapter explores not only how to present a story of the behaviour of a rule interpreter, but also how to present an execution model of two interacting programming languages. The TPM model described in the previous chapter is used as the execution story for the backward chaining rule interpreter.

In summary, the research described in this part explores the design issues involved in creating programming environments for a variety of domains, user groups, and programming languages. The chapters are presented in the chronological order of research, with the work carried out in each chapter building on the lessons learned in the earlier work. The section should therefore convey a progression in the corpus of design issues, and the presentation techniques of the programming environment whether it be computer based or book based.

1Design Features of a Friendly Software Environment For Novice Programmers*

Marc Eisenstadt

Human Cognition Research Laboratory, The Open University, Milton Keynes, England

OVERVIEW

This paper describes a highly-friendly, software environment for novice programmers. The environment, based around a non-numerical programming language called SOLO¹, has been used extensively by Social Science students. The paper outlines several features which could benefit designers of other software environments, concentrating in particular on the interaction among three aspects of software design: the programming language itself, the user environment, and the curriculum used to introduce students to programming. The language has an “explicit flow of control” construct in conditional statements which eliminates the elementary flow of control bugs normally found in novices’ programs. The environment is simple, consistent, and “visible” in that it displays all changes to the values of global variables as soon as they occur. The curriculum is non-standard: students begin with the concepts of “assertional data base” and “pattern matching”, which they find highly intuitive, motivating, and relevant to their academic interests (Psychology, in this case).

1. INTRODUCTION

This paper describes the results of a six year period of design, implementation, testing, and iterative re-design of a programming language, user aids, and curriculum materials for use by Psychology students learning how to write simple computer programs. The resulting product, called “SOLO”¹ has now been used by 2000 Open University students. SOLO itself is a very simple programming language, but the design philosophy of the language, the user aids, and the curriculum materials embody many principles which could pay off if adopted in the teaching of other programming languages. The next section describes the background to the project and the reason it was undertaken. Sections 3–5 describe in turn the programming language, the surrounding “software environment”, and the curriculum materials, listing the important principles underlying the design of each of these. Throughout the paper, the principles which can benefit designers of other software environments are emphasized.

2. BACKGROUND

The Open University, in existence since 1969, is a “long-distance” teaching institution. We have 70,000 undergraduates currently enrolled. Students typically hold full-time jobs, studying at home for roughly 12 hours per week. We make extensive use of correspondence text, BBC television and radio programmes, small home experimental kits, and one-week residential summer schools. Through a special arrangement with colleges and polytechnics around the country we have established 250 study centres, where students can meet with tutors, and where they can use a computer terminal via dial-up facilities to one of our main central computers. These computers run a variety of Computer Assisted Instruction packages, simulation games, and programming languages. Students attending summer school have hands-on access to a large range of microcomputers, and an increasing number of Open University courses are using microcomputers as part of their home experimental kits.

In 1976 a team of Open University lecturers under the direction of Professor Judith Greene began to design a course on Cognitive Psychology. The course was to be presented for the first time in 1978. A course such as this runs for 32 weeks every year, for approximately six to eight years, and is almost entirely pre-packaged with the exception of yearly changes to some assignments and exam questions. Thus, there is tremendous pressure on us to get the material right before it goes into print. Two important principles were agreed by the course team early in 1976: (a) the course would contain a fairly large amount of material on Artificial Intelligence (AI), because such material was becoming increasingly relevant for Cognitive Psychologists, and (b) all the course materials would undergo two rounds of drafting and group criticism, after which a third draft of the materials would be produced and used by a trial group of thirty students in 1977 (they received credit for taking the course in this unpolished form). The comments of these “developmental testers” would then provide the basis for revisions of the material to appear in the final curriculum in 1978.

Our desire to include a lot of material on Artificial Intelligence meant that our students had to become conversant with a number of basic ideas involving computation. We felt this was essential, because it would enable our students to feel more comfortable when encountering AI articles or cognitive science theories which are expressed in some computational form. The best way to achieve this was clearly to require the students to undertake an elementary programming project. The goals of the project are summarised in this excerpt from the students’ project booklet (Eisenstadt, 1978):

By the time you finish this project you should be able to:

1. connect to and log in to the computer;

2. define the following terms, and state their relevance to models of cognitive processing:

symbol	relation
computer	pattern-matching
program	parameter
programming language	variable
procedure	flow of control
subroutine	recursion
data base	iteration
semantic network	inference
node	proposition

3. write working computer programs using all of the above concepts;

4. explain the aspects of cognitive processing which are embodied in your programs;

5. explain why “representation” is a problem

Students at summer school used SOLO to develop some elementary models of human memory and reasoning. A typical project involved students setting up a database of “facts” about some murder mystery, and then writing a program to search through the database, exploring the motive, the alibi, the weapon, etc., to try to find the culprit.

The Open University, as one of its founding principles, has no entrance requirements, and our course has no prerequisites (though students invariably will have first taken a “foundation” course in Social Sciences, and an introductory Psychology course). Thus, we had t...

Table of contents

• Cover
• Half Title
• Title Page
• Copyright Page
• Table of Contents
• List of Contributors
• Preface
• Acknowledgements
• Part I Design Issues in Programming Environments
• Part II Empirical Studies and Cognitive Models
• Part III Artificial Intelligence User Aids
• Indices