Artificial Intelligence Review (1990) 4, 61-76

Book Reviews

Artificial Intelligence and Education

Title: Empirical Studies of Programmers. Publisher/Date: Ablex Publishing, Volume 1: Edited by E. Soloway & Norwood, New Jersey, 1986 and 1987.

S. Iyengar, Volume 2: Edited by Price: Vol 1 E34.00/~11.50, G. Olsen, S. Sheppard & E. Soloway. Vol 2 f28.95&11.50.

These two volumes, in Ablex’s Human- Computer Interaction series, represent the proceedings of the first two workshops on Empirical Studies of Programmers, held in June, 1986 and December, 1987. The workshops came about through the growing interest in this field, which covers a wide range of topics, from educational effects of learning programming, through good language design, through to improving the reliability of large software projects. The differences between the two volumes reveal the interesting and rapid changes which are occurring in this area and, since the Third Workshop occurred in May 1989, it is also interesting to speculate on the contents of the third volume in this sequence.

In Volume 1 there is just one paper which addresses the software design process (‘Design activity in developing modules for complex software’ by Norcio & Chmura), whilst seven tackle the difficulties faced by novice programmers with small programs (e.g. ‘Fragile knowledge and neglected strategies in novice programmers’ by Perkins & Martin). The remainder of the chapters are either evaluations of specific tools, methods or metrics (e.g. ‘Experiments on slicing-based debugging aids’ by Weiser & Lyle), or experiments addressing the cognitive processes which are involved in programming (e.g. ‘Cognitive processes in program comprehension’ by Letovsky). As well as these empirical papers, there are

four invited contributions covering the route so far (Shneiderman) and future directions (Basili, Curtis & Soloway). The latter emphasize the need to move away from novices and student programmers towards ‘real programmers’ (Curtis) and ‘programming-in-the-large’ (Soloway).

In response to this, the second volume has five papers which examine software design teams, looking in particular at method- ological problems, communication breakdowns during the design process and code inspections (e.g. ‘Breakdowns and processes during the early activities of software dsign by professionals’ by Guindon, Krasner & Curtis). The second volume also reveals a greater interest in the cognitive processes in skilled programming (e.g. ‘Comprehension strategies in program- ming’ by Pennington).

As the titles of the volumes clearly indicate, the emphasis is on empirical work, rather than on the development of programming environments, or theories of programming. As such their appeal to the AI community may seem somewhat limited. However, J. R. Anderson has contributed some interesting data on novice debugging in LISP (Volume 1, Kessler & Anderson) and on ‘change-episodes’ (when large chunks of code are replaced, or restructured) in LISP programming (Volume 2, Gray & Anderson). However, in general, the appeal of these volumes will be greatest to those teaching

61

62 Book Reviews

programming and those developing products rather than computational models.

The quality of the contents is generally high, though a few of the chapters do contribute results which it is hard to find surprising (e.g. that experts recall key-lines of a program better than non-key lines, whereas novices recall them equally]. The main weakness of this book is it has been written by and for people who already know and understand most of the literature on the psychology of programming and the volumes cannot really be recommended to people wishing to find out about this area. For these purposes Green (1986) is probably still the best introduction, along with a special issue of Communications of the ACM (November, 1988).

In order to provide a better feel for the contents, let me describe three of the more interesting contributions. Littman et al. (mental models and software maintenance) collected protocols of experienced programmers modifying a medium-sized program. They observed two strategies, one in which a wholistic, systematic approach was taken to the task, and one in which programmers focused on local, necessary aspects of the code. The former strategy was deemed to be the more successful since the latter led to a failure to detect interactions between different components of the program. This has implications for tool- building, for training and for language designers, who should strive to keep ‘wholes’ as small as possible.

Kessler & Anderson (novice debugging in LISP) provide some interesting data on the relative difficulty of early LISP errors. Whereas their novices solved a quote error (e.g. (defun replace (x y) (cons ‘x (cdr y))) ) in just 6 minutes and a wrong embedding (e.g. (defun ftoc (x) (difference x 32) (quotient X 1.8)) ) in 6 minutes too, parenthesis errors (e.g. (defun first (x) (car (x))) ) took 28 minutes to solution. Unfortunately the production system model of debugging (written in GRAPES) is unconvincing, since it appears to solve the parenthesis problem trivially. Kessler and Anderson attribute this difference to working memory differences, in which the

model is unlimited, but no details are given to support this claim. They also comment on the fact that the model is strictly goal- directed, whereas their observations suggested that novices were very opportun- istic. They conclude that ‘the model captures all the steps a novice is in fact going through when debugging a problem flawlessly’ (my emphasis].

In the second volume one of the most interesting chapters is by Pennington on comprehension strategies. Rather than examine novices versus experts, she compared the best experts (top quartile) with the worst (bottom quartile). She found three strategies, one used by the best programmers and the other two used by the worst. The ‘good’ strategy was ‘cross- referencing’ in which the programmer continually maps between the code and the problem domain. In the other two strategies programmers focused exclusively on either the code, or on the problem domain. This confirms other data (see Curtis, 1988) which has suggested that software design proceeds most successfully when the programmers are also familiar with the application domain.

By way of conclusion, therefore, these are interesting, but not introductory volumes. The quality of the work is generally high, though with a few exceptions. Volume 2 contains the greater variety of content, and being available in paperback, is probably the more worthwhile purchase. As already stated, Volume 3 should be available this summer, and whilst it will certainly contain even more on the software design process, let us hope that problems of AI programming and AI languages get more attention than they have done to date.

References

Curtis, B. (1988) Communications ofthe ACM, November, 1988.

Green, T. R. G. (1980) Programming as a cognitive activity. In Human Interaction With Computers (eds H. T. Smith & T. R. G. Green). Academic Press. London.

DAVID GILMORE, Department of Psychology,

University of Nottingham

Book Reviews 63

Title: Artificial Intelligence and Education, Volume 1.

Editors: Robert W. Lawler & Masoud Yazdani

Publisher/Date: Ablex, 1987. Price: fZr8.50lE26.95.

Many of the papers in this collection were presented at the conference on Artificial Intelligence and Education held in September 1985 in Exeter, U.K. At the conference itself there were, I understand, some rare old slanging matches between protagonists of the intelligent tutoring system (ITS) and microworld camps.

The editors, of course, put it more positively: ‘The 1985 conference ended with the exciting prospect of the ‘coming together’ of the two traditional streams of ‘tutoring systems’ and ‘learning environ- ments’ . . . This volume marks the beginning of a synergy. . .’ (p.vii).

The first nine papers form the learning environments half of the book. There is much on the need to support learner freedom and initiative, and to provide computer tools designed to help a learner explore, build structures and solve problems in the domain of interest. A strongly constructivist view of learning is taken. There is very little mention of learner modelling, the key ingredient in tutoring systems.

Lawler gives a defensive account of why computers have not yet transformed education, records the LOGO and microworld history, and suggests how the microworld enterprise should proceed. Papert plays his customary advocate’s role.

The second half of the book starts with a previously published overview of ITSs by Yazdani, and includes a description by Sleeman of PIXIE, his ITS shell. PIXIE is based on rules and malrules; the account published here has been undercut somewhat by Sleeman’s subsequent declaration that the identify-bug-then- remediate strategy of PIXIE and other ITSs may not be warranted educationally.

Also included is Ohlsson’s paper ‘Some principles of intelligent tutoring’, which has appeared subsequently in Instructional

Science and become well-known. There is a useful survey by du Boulay and Sothcott of ITS approaches to teaching computer programming.

Richer and Clancey describe GUIDON- WATCH, which is a development of the MYCIN, NEOMYCIN and GUIDON medical diagnosis systems. The learner is given facilities designed to allow observation and exploration of the system’s reasoning as it diagnoses individual cases. The learner can call up various views of what is going on- for example, a list of the hypotheses that are currently being considered-and can ask for an explanation of system behaviour. MYCIN and its successors hold an important place in ITS history; GUIDON- WATCH is an imaginative attempt to open up the system for exploration by the user. In GUIDON-WATCH learner initiative, the central concern of the learning environ- ments camp, is being applied to systems generally considered part of the ITS world. This chapter may therefore have been better place in the first half of the book.

Two of the most interesting papers in the book, one from the first half and one from the second, also being together ITS and learning environment features. Feurzeig’s algebra workbench is intended to support learner exploration, but also to offer advice and explanation. White and Frederiksen’s system is designed to do the same in the field of electrical circuits.

These two papers, and di Sessa’s on physics, share a central concern with learning as a process of conceptual change. The naive conceptions of the novice must be recognized, then a sequence of successively more sophisticated conceptions offered.

The division of the AI and Education world into ITS and microworld camps has arisen more from personalities and perceptions than from deep theoretical differences. From the ITS side, learner

64 Book Reviews

initiative had a central role in, for example, SCHOLAR and WEST. From the microworld side, Papert (1980) stressed that learners must be supported as they work to build their new conceptions.

Even so, by bringing together this collection of papers spanning such a broad range, Lawler and Yazdani do mark a moment in the development of the field. Several of the papers show the way forward by transcending the somewhat arbitrary division into learning environment and ITS sections. Several papers, besides Ohlsson’s contribution directly on the topic, emphasize the need to understand better the nature of learning as cognitive change. As always, the big challenges are psychological rather than technical. In this way, the book

set the stage for successors such as Mandl and Lesgold (1988).

Some of the authors have now published more recent accounts of their work, but this book does offer some interesting papers that research workers in the field will want to refer to.

References

Mandl, H. & Lesgold, A. (Eds) (1988) Learning issues for intelligent tutoring systems. Springer, New York.

Papert, S. (1980) Mindstorms: Children, computers, and powerful ideas. Basic Books, New York.

GEOFF CUMMING, Department of Psychology,

La Trobe University, Australia

Title: Artificial Intelligence and Tutoring Systems: Computational and Cognitive Approaches to the Communication of Knowledge.

Author: Etienne Wenger.

Publisher/Date: Morgan Kaufmann Inc, 1987.

Price: E29.95.

This is a very good book. Now I will attempt to tell you why. Let me set the scene by reiterating some of the foreword by J. Seely Brown and J. Green0 . . .

‘One emerges from this book with an altered vision of intelligent tutoring systems

. . ‘ . . . a unique document revealing a young

field’s accomplishments . . .’ and so on. What inspired this sort of praise? In part,

it has to do with the fact that the author tracks the developments in intelligent tutoring systems (ITS), which are presented, examined and reviewed within a coherent conceptual framework. This is something that is missing from the literature in this field which has a surfeit of edited collections and proceedings which all too often do not present a coherent picture of what is going on or what is important (i.e. the quality of contributions is variable and the editorial content is minimal).

The book is divided into three distinct sections: a first glance: introducing the field

(two chapters); a panorama: people, ideas and systems (eleven chapters); a synopsis: the state of the art (seven chapters), a total of 20 chapters and 486 pages-a fairly weighty tome.

In the first section the author defines the field and terms, and the strong relationship with artificial intellience (AI] is stressed both in terms of the theoretical and practical tools of the discipline (which made the idea of intelligent tutoring systems possible) and also the nature of AI which is described as both science and engineering. The author’s view of AI is one that can encompass both the ‘AI as engineering’ school and ‘AI as producing intelligence’ schools of thought. The author’s point being that although people have different personal perspectives -we only advance jointly, ‘hand in hand’ as he puts it.

The second section is the heart of the book, all the significant contributions are concisely covered and reviewed in depth. Starting with early ITS and computer-aided

Book Reviews 65

Diagnosis: can be viewed as extended student-modelling, that is, what is the sufficient information we need in order to make relevant distinctions to enable different strategies? This long chapter centres on diagnosis at the behavioural level (the product of behaviour) and the espistemic level (taking into account the students current state of knowledge, model of domain and strategic knowledge).

‘Didactics’: because we need to have direct effect on the student and explicitly control the route which the student takes, the author counterbalances the diagnosis section with a section concerning the role and nature of intervention and constraints in the learning process.

Knowledge Communication: takes a broader look at the architecture of the model the author has gradually introduced which is followed by an epilogue.

One criticism is that the language gets incredibly dense in places and technical jargon is abundant, although it may be clear to those with the appropriate background- some of the ideas are so tightly compacted that you find yourself having to re-read sections. There is also a tendency toward being what may be described as somewhat philosophical (‘communication at the epistemic level’ and ‘warranted belief’), although the comment is not intended to be derisory it may discourage some readers, especially when the author gets into gear in the last section. I would say that generally it is worth going over these sections because they are identifying fundamental issues.

An excellent bibliography and thorough index section are added bonuses and generally the typesetting and production standards are of high quality. In short-essential reading for those engaged in, or reviewing, ITS research, an indispensable source-book for the history and practice of ITS.

SIMON ROSS, Department of Psychology,

Portsmouth Polytechnic & Department of Computer Science,

University College, London

instruction techniques, SCHOLAR, SOPHIE, STEAMER, are reviewed as example of dialogue styles and techniques and the rise of the ‘mental model’ approach. The author then moves onto BUGGY and the theory of ‘bugs’ to Sleeman’s malrules and student- modelling approach. The section then progresses onto the to work on environ- ments that aid programming skills and expert system contributions (Clancey’s GUIDON work). A quick aside here, William Clancey’s ‘Knowledge Based Tutoring: The GUIDON Program’ published by MIT, 1987, provides an excellent companion book to the material covered in this section.

The last section is where the author’s ‘voice’ is most audible. Using the previously reviewed work the following topics are covered;

‘The Computer’: both as a medium for communication and the way in which external representations (e.g. interfaces) and internal representations (models of process, educational models) map onto the real-world situation (the student learning). The Domain: completeness and relevance are discussed and the term articulation [of knowledge) is introduced, this crops up in a later chapter as well so you have to get to grips with it here first to fully benefit from the analysis. This is applied to the ‘content’ of a model (the extent to which knowledge is a set of interconnected beliefs) and the ‘organization’ of this knowledge. To cut a long story short, articulated knowledge - transparent knowledge that can be extended with additional beliefs-is used as the keystone for representing domain knowledge in contrast to compiled knowledge which is characterized specific and lacking in transparency and generality (of course this is not the whole story; this is just a review).

‘The Student’: reviews various ways of identifying/characterizing/stereotyping the user, from overlay models (which assume various levels of expertise, the students knowledge is a sub-set of the experts knowledge) to an extended look at theories of bugs.

66 Book Reviews

Artificial Intelligence Programming Languages

Title: Visual Modelling with LOGO: A Publisher/Date: MIT Press (Cambridge Structured Approach to Seeing. Mass.) 1988.

Author: James Clayson. Price: E13.95/$26.95.

This book has many facets. In general terms, what the book is all about is the use of LOGO to have fun by working in a creative fashion and to develop an eye for the subtle details which need to be attended to in developing a model of a real object. The book is of a highly practical nature and the investigations Clayson describes are inspired by the work of artists ranging from Van Gogh to Warhol, Escher to Hackney; the shapes of natural objects such as seeds or trees; the structure of religious and mathematical patterns.

As the book is published in the MIT series on AI the title may suggest that the programming language LOGO may be used to model the process of seeing in humans. This is not the author’s intention. What the book does do is illustrate how LOGO may be used as a tool for developing the capacity in humans of seeing and structurally analysing a variety of objects and forms. This is a skill highly prized among artists, architects and designers. Clayson shows how LOGO may be used for purposes analogous to the preliminary sketches of an artist or an architect. He focuses closely on the problem of how to make progress when attempting to model a situation which is less than perfectly understood and he demonstrates solutions to this problem using a number of case studies.

Seeing is a cognitive process which owes as much to recognizing previously learned situations and structures as it does to processing input via the visual system. Not for nothing is the phrase ‘I see’ often used in the sense of ‘I understand’. Clayson observes ‘Most of my students lacked visual vocabulary’. His book is the result of his efforts to enhance visual vocabulary by learning to analyse what we see and to use

LOGO as a way of expressing such analyses. In these terms, the book is highly successful and displays the considerable attention to detail which is one of the hallmarks of a gifted teacher.

Many of the projects described in the book have been tackled in other books on LOGO, but few others have displayed the subtlety, the attention to detail or the realism achieved by Clayson. LOGO turtle graphics offers a blend of the visual and the analytic which Clayson uses to great effect in modelling forms and structures. The use of the language is developed at a brisk pace, but the development is well explained. There is a good emphasis given to the importance of generalization in LOGO graphics and the uniqueness of the medium. Clayson makes a serious attempt to produce images which resemble the organic designs of flowers, seeds or trees. Mayan and Islamic motifs are modelled successfully. Various trompe l’oeil effects are investigated. However, only a partial view of human visual processing is given: Clayson only touches briefly on the role of colour in our seeing.

As usual with LOGO turtle graphics there are no large programs. Considerable emphasis is placed on the importance (and fun) of experimentation. Some of the more ascetic breed of software engineer may consider such an approach unsound, but on the whole Clayson’s approach to programming matches well with main- stream AI which often involves the production of a succession of approximations which model a real situation. The software becomes in a sense part of our understanding of a subject which cannot be described adequately in advance.

The book concerns human intelligence

Book Reviews 67

student designers, artists, architects and particularly to teachers who wish to encourage their students to use their computers as a medium for making explorations of visual forms. The text is intended for a general audience and is indeed very accessible and highly absorbing. It deserves to be widely read and used.

JOHN ROSBOTTOM, School of Information Science,

Portsmouth Polytechnic

rather than artificial intelligence. It provokes thinking about concepts such as ‘balance’ in a drawing and the aesthetics of computer generated material compared with human produced material. This book is excellent as an illustration of how software may be used as an aid to intelligent and effective performance by human beings, and although it sits uneasily in a series on AI, at least as generally conceived by the AI community, the book is nevertheless a first class piece of work to be recommended to

Title: An Introduction to Scheme. Publisher/Date: Prentice Hall, 1988. Author: Jerry D. Smith. Price: EE29.95.

The primary objective of the author in writing this book is to give a comprehensive introduction to the programming language Scheme, a lexically scoped dialect of LISP which supports functional programming. A secondary objective is to demonstrate procedure and data abstraction through Scheme. The perspective of the book is orthogonal to that of Abelson and Sussman’s Structure and Interpretation of Computer Programs [MIT Press, 1985) making the two books complementary to each other and comparison of the one with the other inevitable. Smith aims to teach Scheme with the side effect of teaching data and procedure abstraction, whilst Abelson and Sussman aim to teach essential programming concepts (data and procedure abstraction being fundamental concepts] with the side effect of teaching Scheme.

Smith’s central theme is that Scheme is a very versatile language whose utility is not limited to AI programming. This becomes the concluding remark of the book: ‘. . . Scheme is a very good language for programming of all types, not just AI programming.’ (p. 282). The central theme is reflected in the choice of examples, none of which has an AI-flavour (distinguishing it from Winston and Horn’s book Lisp, 3rd edn, Addison-Wesley, 1988). The example

on a Mini-Database System, however, does not convince that Scheme is a serious competitor to Cobol when it comes to data processing.

The file handling facilities of LISP are relatively primitive. As Input-Output is largely implementation dependent, in most LISP books the discussion is limited to the primitives READ and PRINT, and stream I/O is completely ignored. Although the language implementation manual is the ultimate source of such information, an introduction to I/O is useful and hence the inclusion of such a chapter in this book is commendable.

The organization of the book reflects the primary objective which is to each Scheme. Scheme constructs are introduced followed by illustrative examples using procedure and data abstraction. In the Abelson and Sussman book Scheme constructs are introduced in the context of programming concepts. Scheme is used as a tool for teaching programming, a role that Scheme is very amenable to, due to its trivially simple syntax, which enables the abstraction away from low level syntactical issues and thus the focusing on conceptual programming issues.

The coverage of the topics in the book is uniform. Advanced features of the language are treated fully and presented in a coherent

68 Book Reviews

way. Each chapter includes exercises, and answers to selected exercises are given at the end of the book. The book is well written and the example programs follow the principles of functional programming with recursion as the predominant control strategy. Procedure abstraction is clearly explained throughout the book whilst data abstraction (through access functions for list structures) is more apparent in the later chapters. The examples are well chosen, although the use of macros to generate new special forms is overlooked.

A notable omission from the book is a chapter on how Scheme can be used in an object-oriented fashion. Object-oriented programming concepts are mentioned in passing. The Abelson and Sussman book includes a section on object-oriented programming. Unlike many other LISP dialects Scheme does not implement property lists. Property lists facilitate object-oriented programming by enabling the attachment of procedures or methods to objects.

The book does provide a comprehensive introduction to Scheme which makes it a very suitable text book for an introductory course on the Scheme language per se. The author says in his preface ‘This book is not suitable as an introduction to programming. In particular, it assumes that the reader is experienced with at least one high-level programming language.’ However, I would think that the book could be understood by undergraduate Computer Science students with no previous knowledge of high-level programming languages. It would be especially useful to users of PC Scheme. Most of the matAria is implementation independent and non PC Scheme users can skip over the implementation notes which are clearly demarcated in the text.

ELPIDA KERAVNOU, Department of Computer Science,

University College, London

Title: Database Applications Using Prolog.

Author: Robert Lucas.

Publisher/Date: Ellis Horwood, 1988. Price: E19.95.

The author has implemented his own PROLOG interpreter with an interface to the Mimer database. The book gives an account of how this works and then presents three studies of uses of the system.

PROLOG maps very naturally onto the architecture of a relational database, a predicate consisting entirely of facts corresponding neatly with a table in the database. However, databases usually have sophisticated ways of looking up records from one or more indexes, whereas the first PROLOG systems simply looked through all the clauses until a match was found. As a result PROLOG’s performance in database applications was unacceptably slow.

An early enhancement, present for the first time, so far as this reviewer is aware, in

DEC-10 PROLOG was the indexing of clauses on the first argument. The index used is the argument itself or, if this is a compound term, its functor. Large predicates have a hash table constructed. The DEC-10 compiler produced very efficient code in such cases, provided the predicates could be arranged so that the search key was in the first argument. This was not very convenient if there was a chance that the predicate might be searched in different ways. For example, a dictionary of English nouns and their French translations

translate(bird,oiseau). translate(warren,garenne).

would work very fast when the English

Book Reviews 69

to this reviewer that the natural solution is to store a representation of the database cursor in a PROLOG variable and to implement the whole interface as an external code routine, thus leaving PROLOG to worry about cuts and the like. However, the solution proposed here, which involves a separate stack of Mimer cursors, seems to work too; it maybe that some feature of Mimer makes this the only possible approach.

The author has dug an unnecessary pit for himself by implementing the predicate call/l as though it were once/l; that is, the goal cannot be resatisfied. This is not the usual way PROLOG systems work. He then proposes special handling of both this and not/l, although in fact the work that went into getting cut right should make these come out right automatically.

A few very interesting points do not receive as much attention as they might because of the space given to the PROLOG implementation approach. For example, it is very inefficient to call

?- born(Person,Year),Year < 1656.

where born is stored in the internal database, because every record will be returned and compared in PROLOG; in fact the database can probably do this more efficiently, but the criterion Year < 1966 cannot be passed by pattern matching. The solution cryptically suggested here seems the same as the one adopted in the EDUCE PROLOG database system; more details would have been helpful.

The author lists a number of deficiencies in Quintus PROLOG (peculiarly attributed to AI Ltd rather than Quintus Corp.) that make implementation of an interface through an external interface difficult. They do not seem very serious, though failing to garbage collect atoms could be a problem. The code proposed on p. 85 for interfacing could be improved; it is the first predicate this reviewer has ever seen with a cut directly preceding a call to repeat.

The three examples follow. The first was a fault handler for a large network; the idea was to keep track of complaints and see

word was known and slowly when the French word was known.

DC-10 PROLOG also introduced an internal database in which terms could be stored under keys.

Several PROLOG implementations have tried to overcome the first clause limitation. In BIM PROLOG the programmer may specify different arguments for indexing, while the implementation of Prolog from Melbourne University, MU PROLOG appears to have an extremely complicated system.

An alternative to improving the features in PROLOG is to provide an interface to an external database. There are obvious advantages, the most significant being that implementing a good database is extremely difficult, so that once somebody has done this there is a good case for using their work rather than trying to do it yourself. A minor disadvantage is that most databases take offence at the suggestion that they should store arbitrary PROLOG terms in a field; things like PROLOG variables need special treatment.

Recently a number of commercial PROLOG systems have appeared with built-in interfaces to databases, though research in this area has been going on for many years.

For PROLOG implementers and users this is a very important issue, but this book is something of a disappointment, and a good general treatment of the question is still needed.

To begin with there are introductions to PROLOG and to relational databases. Both of these are thin, though this does not really matter as there are excellent books on both available. The most promising chapters are the two that describe the interface, 5 and 6. The author successfully built a PROLOG system with the interface available at the lowest level; the details of how this was done, and of the problems encountered, are very valuable. The most significant interfacing problem was how a number of different choice points in the external database could be co-ordinated with the movements of the PROLOG stack. It seems

70 Book Reviews

which ones were symptoms of known problems. The author rightly comments on the fact that use of PROLOG can make the difference between programming slower than the network changes and keeping up to date. The second example, which sounds fascinating but falls rather flat, is a system to detect burglars. It turns out that most people who get prosecuted for burglary confess to it or are caught red-handed. Of the remainder, some are ‘opportunistic criminals’ who don’t burgle very often or are inconsistent in their approach. However, there are a few burglars with known ‘modus operandi’ who can be detected by pattern matching. Unfortunately the author only implemented a prototype system, from which it emerged that there wasn’t any expertise to rely on. Presumably once the story gets around burglars will find ways of varying their patterns.

Finally there is a paint selection system; the idea is that the system decides which colour to spray on cars on a conveyor belt. Strong claims are made for the result, such as ability to reschedule in an emergency with only two minutes to go; it is a pity that the representative bits of code betray no hint of the planning approach used, being almost all similar to the following:

batch(Colno):- pointer(Pointer),

options(Pointer,,Carno,_,,_), checkpri(Carno,Colno), min-batch(Colno,Pointer), writeln(‘Coln0: ‘,Colno).

This shows that the discipline of structured programming has been well applied but, in the absence of head matches, built-in predicates and the like gives little evidence of use of PROLOG.

A general criticism that could be made is that there is too little awareness of other work in the same area; a chapter on previous attempts and how they differed from this system would have been very useful. It is very important to reduce the amount of time AI researchers spend rediscovering already known results through lack of information about what others are doing. At the same time one has to recognize that there is such a mountain of literature on AI, often gathered in ill-defined volumes of papers, that discovering what work exists can be more trouble than doing the work from scratch.

This book will be of interest to those setting out to implement systems similar to the author’s (and to burglars).

TONY DODD, Chemical Design Ltd,

oxford

Title: Prolog Through Examples: A Publisher/Date: Sigma Press, distributed Practical Programming Guide. by Wiley, 1988.

Authors: I. Kononenko &N. Lavrac. Price: E11.95.

The book introduces the reference version of Edinburgh PROLOG. The authors start by presenting a brief outline of the concepts behind the language. A sample program is shown and run, and then contrasted with other programming language styles. The rest of the book is structured in a bottom-up fashion.

The basic types of facts, rules, queries, and commands are introduced before the concepts of procedures and programs. From

these basic types the authors build up to more complex data objects such as terms, lists, variables and arithmetic manipulations.

Once these building blocks have been presented the readers are shown how PROLOG programs work by presenting matching, rules of execution and ways of obtaining alternative solutions.

In Chapter 5, having completed the presentation of the concepts behind the

language, the authors introduce advanced programming techniques. They present the concepts in a fairly detailed manner and even a low level topic like simulating global variables is explained as well as recursion and the use of lists. Also covered are further control structures such as backtracking with a good explanation of the ‘cut’ facility.

In Chapter 6 exploring the concepts further, the authors give tips on how to structure programs and improve readability. They also explain how the functions cut, assert, and retract could be used. At the end of the chapter debugging in PROLOG is presented with general design principles. The last chapter deals with circumstances where PROLOG could be applied. In each case a few examples are presented to highlight the concepts.

The book is structured around examples as its title indicates. Although this book like most introductory books does not deal with all the facets of the language, it does go

Book Reviews 71

further than an introductory text and present some advanced concepts. Its liberal usage of exercises is very useful for the novice who would like a ‘hands-on’ experience which is further enhanced by the exercises with solutions at the end of each chapter. The book does give an overall picture of PROLOG and how it could be used to solve problems. Overall the book is fairly well written and I would recommend it as an introductory text for teaching PROLOG. It complements some of the more complete books like Programming in Prolog by W. Clocksin and C. Mellish (Springer-Verlag, 1984) or The Art of Prolog by L. Sterling and E. Shapiro (MIT Press, 1986). However, one thing which is lacking is the provision of references for further reading.

MADJID MERABTI, Department of Computing,

University of Lancaster

Title: Turbo Prolog: An Introduction to Artificial Intelligence.

Author: P. Bihan.

Publisher/Date: John Wiley & Sons, 1987. Price: fZ12.95.

This text is about one of many PROLOG dialects, Turbo Prolog, which is very popular on microcomputers due to its cost and availability.

The book starts with an informal presentation of the concepts behind PROLOG, it then goes on to give some definitions of rules, arithmetic calculations, lists and recursion. This introduction, although brief, is fairly good. The rest of the book deals with ‘getting started with Turbo Prolog’ which is divided into three broad areas: Creating and interpreting a database, complex operations, and applications.

After an example on how to set up and start the system, the author presents ideas on how to create a database, enter data, and manipulate facts. This is yet again interspersed with an explanation of system dependent command such as using disk

drives, edit, loading a program, and using the printer. He then introduces rules and their definitions and facts as well as a very brief introduction to the concept of backtracking. In this section the trace facility, read, and write are also introduced.

In the section on Control resolution the author introduces Backtracking in more detail and fails to talk about any other form of control e.g., forward chaining. The section is finished with a brief introduction to Arithmetic operations.

Under the heading of ‘Complex operations’ the author commences with lists and their manipulations. This section does present the subject to a greater depth than the previous topics. In the rest of the chapter some of the DOS facilities which Turbo Prolog can access are presented. These include file management, dynamic

72 Book Reviews

databases, windows and graphics. The author finishes the section by explaining some of the concepts of software engineering such as modular programming.

The last chapter of the book the presents six small case studies which give an insight on how PROLOG can be used. These are exercises with their complete Turbo Prolog solutions and which remedy the lack of exercises throughout the book.

material but all of it superficially. At the end of the day, the book does not do justice to the PROLOG language neither does it present all of the Turbo Prolog facilities. This leaves the eventual user with the necessity of requiring another book about PROLOG as a reference if the person intends to do any serious work. Because of this the book will very quickly run out of its usefulness.

The book is fairly well written, the presentation is nice and clean. It introduces some of the Prolog concepts in an orderly fashion. I quite like the introduction which serves as an overview of the language. This leads to a presentation of the system capabilities which falls into two categories.

(1) Language dependent (2) and system dependent, that is dependent

upon DOS and windows.

Despite its title, the book is not about artificial intelligence but rather an introduction to Turbo Prolog. A comparison with other texts, such as the excellent Artificial Intelligence Through Prolog by N. Rowe (Prentice Hall, 19881, is inappropriate. Another failing of this book, especially as an introductory text, is that it lacks a complete set of references to guide the learner to investigate the subject further.

One of the problems that the book has, in MADJID MERABTI, common with many other introductory Department of Computing, books, is that it tries to cover a lot of University of Lancaster

Computational linguistics

Title: Prolog and Natural-Language fhllJd!3.

Authors: Fernando C. N. Pereira & Stuart M. Schieber.

Publisher/Date: CLSI, 1987. Price: E11.25.

This book is published by the Centre for the Study of Language and Information in their Lecture Notes series which are intended to report new developments in the study of language, information and computation. The book is composed of a series of lecture notes which are the final result of a course on Computational Linguistics given at Stanford University in late 1988. As the authors observe,

This book presupposes some acquaintance with elementary notions from logic, formal language theory, computer science and linguistics.

The book is aimed at an audience already involved in study, research or other professional involvement with computational linguistics. The text would be invaluable to any lecturer planning a course on this subject and progressively more exacting exercises accompanied by comprehensive Bibliographic Notes suggesting a range of related reading materials to accommodate most points of entry to the theme follow each chapter. The Bibliographic Notes also serve to place succinctly, in both historical and contemporary context, the material discussed. Research workers and

Book Reviews 73

of the working question-answering system which can be found in the final appendix.

Bits of code used for exercises and the illustration of themes throughout the book contribute to work in this section. A clear elegant programming style using concise mnemonic names is evident and much can be learned both from the TALK program and the DCG compiler offered there. The final stage of development shows how to implement logic programming language and logic grammar interpreters exhibiting different control strategies from that directly provided by PROLOG.

In well considered discussion on interpreters, the authors emphasise two important instances of ‘frailties’ in PROLOG and DCGs:

postgraduate students who are involved in or are starting out in computational linguistics will find the book a crisp, professional elucidation of practical and theoretical concerns in the field. A working acquaintance with PROLOG and some reading around key subjects would certainly enhance the value of this book for potential readers. This is not to suggest that such experience is essential however, but that the novice, in using the book is sure to be directed towards related areas worthy of investigation.

Designed to be an ‘introduction to elementary computational linguistics from the point of view of logic programming’ a two-pronged approach to the subject is taken which is defined by the authors as its ‘formal and utilitarian aspects’. Theoretical explanation is well balanced with practical illustrative programs which are an aid to hands-on programming experience. Clearly and competently presented, the text moves quickly through key concepts. The style throughout is informed and compact and dry laconic commentary accompanies observations, witness, ‘Despite statements to the contrary, no programming language is self documenting’. The well calculated progression which takes place throughout the book calls upon, consolidates and extends the application of concepts dealt with in earlier chapters. This step by step build-up of practical programming technique combined with theoretical explanation should ensure a comprehensive learning curve.

The Edinburgh PROLOG family is used as a basis and the cumulative exposition is split into three stages comprising: database PROLOG (‘a limited subset’); pure PROLOG (‘the largest subset which can be viewed as a logic programming language’); and full PROLOG.

Database PROLOG gives an introduction to the language, pure PROLOG is used for the presentation of definite clause grammar formalism leading to the creation of a DCG and finally, full PROLOG exploits the techniques discussed in the two previous stages and applies them to the development

Since Prolog programs with left-recursion have termination problems so will direct Prolog execution of DCGs with left recursive rules.

Arguments in DCG rules having a regular, predictable structure e.g., those which enforce filler-gap dependencies, build parse trees building, or construct logical forms tend to proliferate and complicate grammars.

Using these instances as examples a program is produced to indicate ways in which these problems can be approached and the authors observe:

Using techniques of this sort, one can imagine writing interpreters that trace the execution of a program, detect looping in a programs execution or allow interactive stepping of a program.

In short, the authors have given code and directions for the writing of something approaching operations carried out by the debugger supplied in most versions of PROLOG. The example given is written in PROLOG to act on PROLOG and thus qualifies for the term meta-circular interpreter. Exercises are suggested for the writing of an interpreter for the CUT (!),

74 Book Reviews

command and then proceed to the creation receiving a lot of attention by researchers of a DCG. An interesting observation here recently and this exposition will be of value concerning the DCG interpreter shows that to those who wish to become acquainted ‘The Interpreter could have been more with the conventions informing current succinctly stated by writing it in the DCG research on this theme. This book achieves itself!’ what it sets out to do:

Moving on from Interpreters which, observe the authors, ‘are of little use unless the language they interpret is an extension of Prolog’, partial execution and compilers are considered. An alternative to PROLOG’s default top down left-to-right backtrack parsing algorithm for DCGs is given in the form of bottom-up parsing as an attempt to overcome the problemof top-down looping on left-recursive rules. The left-corner method is outlined in one of its adaptations to DCGs. This in turn leads to a discussion of compiling DCGs into left-corner parsers. The theme of bottom-up parsing has been

The main goal of this book is to enable the reader to acquire as quickly as possible, a working understanding of basic computational linguistics and logic planning concepts.

Those already working in computational linguistics should find points of interest whilst others becoming involved will find an excellent grounding in the field.

G. BYRON, Exeter University

Title: Natural Language Understanding and Logic Programming, II.

Editors: Veronica Dahl & Patrick Saint-Dizier.

Publisher/Date: North-Holland, Amsterdam, 1988.

Price: $84.25.

The book deals with natural language processing using programming languages based on logic programming. The connection between logic programming and natural language processing has always been very strong, for analysis of natural language sentences was the main objective of works, which led to the origin of PROLOG. Metamorphic grammars constituting the basis of PROLOG, have inspired the formulation of many derived formalisms. The reason for construction of these formalisms was a desire to facilitate the notation of grammar rules or its adjustment to the emerging theories or linguistic postulates. For a long time, the main area of interest was sentence syntactic analysis. The objective of the research carried out was to enable notation of various syntactic forms with the help of the studied grammar rules and then their representation in the form of a programme in the PROLOG

language. For a number of years, an increasing interest in logical representation also of semantic and pragmatic information has been observed.

The discussed book includes 18 articles, presenting works concerning various aspects of natural language processing. Thus, such fields are represented as: morphologic, syntactic, and semantic analysis, generation of utterances, theoretical considerations on the form of language description, and construction of parsers. The common feature of the proposed solutions is the use of PROLOG as an instrument for notation of the presented proposals or as language of destination, into which rules noted in a different way are translated.

Proposals for a new method of formal description of natural language can be found in the article by P. Sint-Dizier ‘Contextual Discontinous Grammars’. It

Book Reviews 75

presents CDG grammar, facilitating convenient notation of rules concerning many elements of the analysed structure which do not appear next to each other. The proposed formalism is not connected with any linguistic theory, but it uses some of their elements. An algorithm translating CDG grammar rules into a program in PROLOG has been constructed.

A different proposal in the direction of improving the existing forms of description is included in the article by M. Boyer ‘Towards Functional Logic Grammars’. It postulates development and coordinating attribute values. The advantage of the proposed solution if automatic enclosure of adequate attribute descriptions to appropriate rules. Attribute values may then be agreed on, gradually, in the course of obtaining appropriate information. Some adjustments may be made at the compilation stage. The proposed solution allows for facilitation of grammar notation, automatizing the feature description of given elements of the analysed text.

In a few articles new methods and instruments for natural language processing, using logic programming, have been presented. In the article ‘Graphs in Logic Programming for Natural Language Analysis’ by Beringer, a language, which is an expansion of PROLOG among others, with mechanisms facilitating representation of complex sentences, is proposed. The article ‘Computational Logic0 Semantic Induction’ by Koch, presents a logic0 semantic induction method, used in automated generation of parsers.

Russo, in his paper ‘A Rule Based System for Morphologic Analysis of the Italian Language’ discusses problems connected with construction of an Italian language vocabulary, such as problems of morphologic analysis and their resolution. The structures applied in the vocabulary constructed by the author, where morphologic analysis is based on context-free grammar, have been described.

Few articles have been devoted to syntactic analysis of natural language sentences. The paper by Oskunishi presents

a comparison of three parsers formulated at the Tokyo University. The programmes analyse English sentences with the use of a grammar noted in DFG formalism. The comparison made, referred to simplicity of the system’s application and essential memory and time of action.

Another parser that has been presented is P-PATR (Hirsh, ‘P-PATR: A compiler for unification-based grammar’), which analyses sentences, using a complex version of unification grammar. During the process of compilation, the structures describing features are translated into the terms of PROLOG, with settled number and sequence of attribute appearance. In order to avoid the problems that a standard algorithm of top-down analysis has with left-corner recursion grammar, an algorithm known as left-corner parsing, is used.

The following article on parsers is a paper by Dowding and Hirschman ‘A Dynamic Translator for Rule Pruning in Restriction Grammar’. The implemented program is an intermediate resolution between a compiler and interpreter. Effectiveness of the proposed solution is based on decreasing the number of reviewed rules on the basis of already partly built syntactic tree. Presently, the possibility of limiting the choice concerns verb constructions. Thirty-four types of verb and object constructions have been distinguished. In the vocabulary, it has been noted which of the distinguished constructions is admissible for every verb. If a verb is recognized in an analysed sentence, the list of possible rules, according to which the analysis should be performed, is limited to rules describing situations foreseen in the vocabulary.

Some of the articles presented in the book deal with semantic issues. The article ‘Using Commonsense Knowledge to Disambiguate Word Senses’ by Dahlgren presents the results of research on an algorithm defining meanings of equivocal words. The algorithm uses set phrases, syntactic context and knowledge. Reasoning, being the most time-consuming method, is used only when simpler methods fail. Only in special cases the constructed

76 Book Reviews

algorithm refers to information from the surrounding sentences. The article also includes results of experiments carried out with the constructed algorithm (comparison of tenses and percentage of correctly recognized words). The article ‘Comparatives in Logic Grammar-Two Viewpoints’ by Banks and Bayner describes the SNACK-85 system, where two approaches to the problem of interpretation of constructions, including comparisons, have been implemented. The article includes a short introduction to the problem, a description of the system and of the two solutions, applied to it, one on the syntactic level and the other on the semantic level.

The following field of NLP is concerned with generation of sentences. In the book under review, this topic is represented by one article: ‘Theory of Natural Language Generation’ (Brown, Pattabhiraman & Massicotte). It presents an attempt to formalize the principles of communication between the grammar and environment, in which the sentence generation is taking place. This environment includes representation of semantics of the processed sentence, vocabulary, and all sources of information on syntactic and semantic limitations. The grammar, on the basis of which the synthesis of the sentence is taking place, is noted in the form of Static Discontinuous Grammar, the version of transformation grammar, more precisely the Government and Binding Theory formalism.

The presented book also deals with other problems connected with natural language processing such as question understanding,

giving fully informational answers to questions for data base.

Apart from the papers presented at the conference, this book includes a summary of two interesting discussions concerning views on usefulness of logic in natural language notation, the present trends of research and relation of logical grammars to linguistic theories.

This book constitutes an interesting presentation of current works connected with natural language description and processing, with the use of methods related to ‘programming in logic’. It seems that the formulated logic grammars and translation methods of other types of notation into programs in PROLOG, constitute a significant, worth of study possibility of NLP development. The proposed solutions aim at automation of possibly large part of works on grammar construction. The achievement of this objective will enable to concentrate the attention, in constructing a grammar, on the description of the most significant facts.

The selection of papers included in the book is interesting and permits to get acquainted with the multidirectional form of the research carried out.

I highly recommend the purchase of this valuable book to all those persons who are interested in developments in Computational Lingusitics, AI, Applied Linguistics, and Knowledge Engineering. This book should, first of all, be bought by every university library and also by libraries of Institutes of Computer Science.

LEONARD BOW=, Institute of Computer Science,

Polish Academy of Sciences

Title: Machine Translating Systems. Editor: Jonathan Slocum.

Publisher/Dote: Cambridge University Press, 1988.

Price: E27.5049.50.

This book, as the preface makes clear, is a Linguistics in 1985 (Vol. 11, nos 1-3) guest- re-publication of the special issues on edited by Slocum. These publications were Machine Translation run by Computational valuable publicity for the field at the time.

Book Reviews 77

space on the workings of the Japanese Government system, without attaining the level of explicitness of Biewer, Feneyrol and Ritzke. In contrast with this approach, Vasconcellos and Le6n spend six of their 48 pages on the (organizational) history of the SPANAM-ENGSPAN project, and no fewer than nine on the day-to-day operation of the system, down to the recruitment policy for post-editors.

The result of these attempts to sketch an entire system in one article is often that not much information is successfully conveyed. Most of the headings of each paper are too briefly treated to give the reader any very secure knowledge. This is particularly the case when one looks for supporting argumentation for a technical decision: Boitet and Vauquois can spare only three pages for their ‘Arguments (for and against) Chosen Techniques’, which they present without references; and the picture is much the same elsewhere in the volume. A noteworthy instance occurs when Boitet and Vauquois claim (pp. 104-105) that experimentation with a representation that was interlingual except that it used lexical units from a given natural language was a failure, while Isabelle and Bourbeau report (p. 241) that TAUM-AVIATION used such an idea, by implication successfully. The weakness is that the design of the volume allows no space for any kind of discussion that might illuminate the apparent contradiction.

Machine Translation Systems thus contrasts with Nirenburg (1987), which follows more closely the classic concept of a book of research readings and hence centres on MT ideas rather than MT systems. On the other hand, one chapter per system is too lengthy for a true historical survey, and Slocum’s scope is limited to second- generation systems, at or near the end of the development stage. So unless the reader is exclusively interested in this category of system the book cannot replace the full-blown history of Hutchins (1986).

According to the preface, this book was published in reaction to popular demand for the back issues of Computational

However, it is questionable whether there is a similar value in publication in volume form.

The first chapter, by Slocum himself, is intended as a very first reading in Machine Translation (MT), and it serves this purpose well. It encompasses a brief and necessarily selective sketch of the history of the field, and several different taxonomies of MT systems. Of these the most emphasized is the classification according to stage of fruition, into production, development and research systems. Besides such matters, it includes some basic observations on the nature and uses of translation that are vital to an understanding of the MT field and not often explicitly made. This type of common sense is reflected again in the paper by Slocum and Bennett, most particularly in the section on the evaluation of MT systems (pp. 126-128).

The book closes with a general-purpose MT bibliography (distinct from the bibliographies of the individual papers), expanded and updated since its appearance in Computational Linguistics 11 to embrace some 650 references up to the year 1986.

In between the reader is offered six readings, each of which is an attempt to characterize an entire MT system. Those covered are ASCOF, GETA, METAL, the Japanese Government system, SPANAM-ENGSPAN and TAUM- AVIATION. The sole casualty from Computational Linguistics 11 is the EUROTRA paper, absent from this volume owing to that paper’s rapid obsolescence in a young and fast-moving project. They follow a rough format beginning with the history of the project, covering topics like linguistic and computational techniques, and finishing with future prospects. However, within this framework there is sufficient flexibility. For example, Biewer, FBneyrol and Ritzke spend virtually all their space giving a systematic and thoroughly- exemplified account of the workings of the ASCOF system, and as a result their paper is likely to be of more lasting value than the others in the volume. Nagao, Tsujii and Nakamura likewise spend most of their

78 Book Reviews

Linguistics of which it is a re-publication. This begs the question of whether the populus was well-advised to demand such a book. There may be a reference function for such a volume, though the bibliography is the only part that seems to have been designed with this end in view. There may also be further opportunities to continue the publicity job mentioned above, and it may be true that a bound volume can exploit them. But considering Machine Translation Systems as a substantive academic work, the natural question to ask is this: having digested the first reading furnished by the first chapter, does the reader new to MT want his or her next six readings to be

summary overall sketches of individual systems?

References

Hutchins, W. 7. (1986) Machine Translation: Past, Present and Future. Ellis Horwood, Chichester.

Nirenburg, S. (1967) (ed.) Machine Translation: Theoretical and Methological Issues. CUP, Cambridge.

IAN CROOKSTON, Department of Language 81 Linguistics,

University of Essex