- Email: [email protected]
Program design for knowledge-based systems
books Program design for knowledge-based systems Graham Winstanley Sigma Press, UK (1987) £12.95, ISBN 1 85058 066 9, 230pp From the contents table it is clear that this book attempts to cover a large area. Such a task needs a very coherent presentation of ideas and facts. Unfortunately, such a consistent approach is sadly missing in this text. Instead, it jumps from example to example. Almost every new chapter introduces a whole new set of examples rather than attempts to build on those introduced earlier. The only exception to this is chapters four to six, where the same example is linked through. The treatment of Lisp also suffers from a number of weaknesses. There is a wide variety of programming methods used, and Lisp is not sufficiently well explained. Indeed, some Lisp functions are used before they are fully explained, and some are not explained at all, e.g. Lisp PROG function is not explained satisfactorily, and it is not even mentioned on the page where, according to the index, it should be; any notes on PROG first appear a little later. Also, if you look for an explanation of single quote character you find it five pages after the first use. The subset of Lisp used is not very carefully chosen. There is a tendency to concentrate on a very specific implementation and its details rather than on the broad development of the language. Surely an appendix is the best place for such details? There ought to be an appendix with the Lisp subset used surveyed, but this is missing as well. An overview of Lisp systems on the market is provided, but it is quite simple; only two implementations are mentioned. I like Lisp - - it was my first programming love, and everyone enjoys remembering a first love. Much as I like Lisp, I cannot agree with the premise that Lisp is an ideal language for knowledge representation and for Knowledge-based Systems (KBS). If you compare Lisp 310
with Basic, as is done in the text, then it is clear that Lisp is a much better language for AI applications. Lisp is a simple language to describe, and so is very suitable as an illustration language in any AI book with program examples; this is perhaps the extent of its usefulness. The question as to which language is the best one for KBSs is not answered satisfactorily in this book, because no such discussion is provided, except for a comparison between Lisp and Basic or Pascal. As a point of comparison, it is only fair to note that it is possible to implement many Lisp-like features (linked lists, recursion, etc.) in Pascal - - this fact is omitted from the book. Nowhere in the text are references made to any other books on Lisp. Yet at the end a list of references is gien. Where are they used? It is certainly difficult to determine any influence that those well respected books quoted there had on the text under review. The book sets out to show that Pascal-like languages are unsuitable for KBS design. It does this by describing several very promising knowledge-based system features which would be difficult for any reader implementation in such a language (e.g. simulation of human driven solutions). Naturally, one is led to expect that the examples in the text represent those desirable features. However, this expectation is not lived up to. Only very basic and incomplete parts of the KBS are shown. Not including the way in which to represent an independent program, or a large independent part of such a program, in runnable state, is a sad omission. The reader of any program/computer system designing book should expect that any techniques mentioned and explained would be shown in full 'real' system. One misconception which per-
meates the whole designing part of the book is a belief that a KBS can be designed in an incremental fashion - - that is a system based on a few rules can be implemented and tested. This system can then be expanded by the addition of extra rules without recourse to the initial design stage. Such an approach is misguided, and can easily lead to an inconsistent system being developed. The incremental approach should probably only be used for knowledge base improvement. Overall, I found this book quite difficult to read. Some parts are very easy to follow while some are very difficult; chapters one and eight are straightforward, and could be followed without any knowledge of Lisp or any preceeding chapters. On the other hand, the explanation of linked list is very complicated, and would be improved by the inclusion of simple diagrams. The interweaving of a Lisp tutorial with detailed implementation comments I found confusing, and am sure that Lisp novices would find it even more so. The comments on programs provide some of the book's good points, because they are often a source of entertainment. The chapter on hardware, however, is confusing as it mixes descriptions of past and future with current technologies. The book fails to explain the following points: •
• • •
the Lisp version described is very limited, perhaps too limited to effectively solve some design problems; the importance of Lisp property list as a concept for KBS implementation; the strong relation between KBSs and object-oriented programming; and the limitation of increment approach to program design, and in particular, the need for a careful design of any KBS from the very beginning.
The book could be useful to a keen amateur with some basic programming experience who is going to build their own KBS.
Jiri Polak Loughborough University of Technology, UK Knowledge-Based Systems
with Basic, as is done in the text, then it is clear that Lisp is a much better language for AI applications. Lisp is a simple language to describe, and so is very suitable as an illustration language in any AI book with program examples; this is perhaps the extent of its usefulness. The question as to which language is the best one for KBSs is not answered satisfactorily in this book, because no such discussion is provided, except for a comparison between Lisp and Basic or Pascal. As a point of comparison, it is only fair to note that it is possible to implement many Lisp-like features (linked lists, recursion, etc.) in Pascal - - this fact is omitted from the book. Nowhere in the text are references made to any other books on Lisp. Yet at the end a list of references is gien. Where are they used? It is certainly difficult to determine any influence that those well respected books quoted there had on the text under review. The book sets out to show that Pascal-like languages are unsuitable for KBS design. It does this by describing several very promising knowledge-based system features which would be difficult for any reader implementation in such a language (e.g. simulation of human driven solutions). Naturally, one is led to expect that the examples in the text represent those desirable features. However, this expectation is not lived up to. Only very basic and incomplete parts of the KBS are shown. Not including the way in which to represent an independent program, or a large independent part of such a program, in runnable state, is a sad omission. The reader of any program/computer system designing book should expect that any techniques mentioned and explained would be shown in full 'real' system. One misconception which per-
meates the whole designing part of the book is a belief that a KBS can be designed in an incremental fashion - - that is a system based on a few rules can be implemented and tested. This system can then be expanded by the addition of extra rules without recourse to the initial design stage. Such an approach is misguided, and can easily lead to an inconsistent system being developed. The incremental approach should probably only be used for knowledge base improvement. Overall, I found this book quite difficult to read. Some parts are very easy to follow while some are very difficult; chapters one and eight are straightforward, and could be followed without any knowledge of Lisp or any preceeding chapters. On the other hand, the explanation of linked list is very complicated, and would be improved by the inclusion of simple diagrams. The interweaving of a Lisp tutorial with detailed implementation comments I found confusing, and am sure that Lisp novices would find it even more so. The comments on programs provide some of the book's good points, because they are often a source of entertainment. The chapter on hardware, however, is confusing as it mixes descriptions of past and future with current technologies. The book fails to explain the following points: •
• • •
the Lisp version described is very limited, perhaps too limited to effectively solve some design problems; the importance of Lisp property list as a concept for KBS implementation; the strong relation between KBSs and object-oriented programming; and the limitation of increment approach to program design, and in particular, the need for a careful design of any KBS from the very beginning.
The book could be useful to a keen amateur with some basic programming experience who is going to build their own KBS.
Jiri Polak Loughborough University of Technology, UK Knowledge-Based Systems