Product Description
The third edition of this guide to Prolog and Artificial Intelligence has been updated to include key developments in the field. Divided into two parts, the first part of the book introduces the programming language Prolog, while the second part teaches Artificial Intelligence using Prolog as a tool for the implementation of AI techniques. ... Read more

Customer Reviews (9)

especially good for A.I.
A new edition will be out soon, in 2010.This is an excellent book on Prolog *and* on AI.

For example, chapter 19 is an introduction to inductive learning in first-order logic, an advanced topic rarely found in introductory books.The example program HYPER is a very powerful learner as compared to other "propositional" machine learning methods such as decision trees, neural networks, or support vector machines.I have ported HYPER to Lisp and am still exploring it.

Prolog is not a very popular language nowadays, but basic knowledge of it is still essential to learning logic-based AI.

Why is this the the best textbook on prolog?
Although this text is always mentioned in the same breath as other introductory textbooks on prolog, I don't think I've ever seen it described as "the best."
The book which usually takes the palm in such comparisons is"Art of Prolog."While "Art of Prolog" is an outstanding book, I think that now, in 2006, it has been eclipsed by the 3rd edition Bratko's book.Why?

Simply this: Bratko's textbook is (as far as I'm aware) the _only_ textbook on prolog which treats the language as a living, developing language!Other textbooks are great for their time, but they are unfortunately stuck in their time.Its as if nothing has happend to the prolog language since February 16, 1987.But this isn't true at all!

The biggest case in point: constraint logic programming!Bratko's text is the only introductory prolog textbook to even acknowledge the existance of CLP.And Bratko gives very lucid descriptions of it, along with very helpful examples and challenging exercises.

Another case in point: inductive logic programming!An entire new branch of machine learning theory has risen, based on logic programming, and NONE of the other introductory prolog textbooks cover it?Come on guys!

I would love to see a 4th edition of this book, because since this one has been published, logic programming has moved even further ahead.Constraint handling rules (CHR), logical functional languages (like Curry), using prolog for the semantic web, etc etc etc.It might be the best kept secret in computer science, but logic programming is really still one of the most exciting areas of programming, and Bratko's book does the best job of staying abreast of, and conveying the excitment of, this living and dynamic field.

Great book for learning AI with Prolog, but....
... a horrible Prolog tutorial.

This is not a good first book on Prolog. If you are new to Prolog and Logic Programming, you should read 'Art of Prolog' first.

Prolog is quite different from other languages, and you'll need some time to get it. This book doesn't give you that time: after briefly introducing the basic concepts, Bratko dives at breakneck speed into recursion and list processing.

Don't get me wrong, this is a magnificent book on how to do AI with Prolog, but it shouldn't be your first Prolog book. It's an excellent second book.

An excellent introduction to Prolog and concepts in AI
Professor Bratko has done a tremendous job of putting all the fundamental concepts of Prolog and its applications in various areas of AI. Although this book is focused on Prolog, the concepts that he has discussed are so fundamental that they can be implemented in other languages like Java as well.

I recommend this book to everyone who wants to learn Prolog. I would also recommend the readers to use a Prolog system to work out the examples and exercises as s/he goes through every chapter. A DEC10 Prolog system (like SICStus Prolog) would probably be the best companion for this book.

I thought the book could be better
I find the book does not adequetly explain the more complex code examples.First of all the code is not adequetly commented.Secondly, it does not explain the code well for programmers.First when introducing a program like in the expert systems shell chapter it should first define an interface for the program, and explain each goal listed.It should adequetly explain what each goal and clause should hope to achieve.Also, for the more complicated programs it should draw some type of diagram, maybe a flow chart or something that explains the concepts involved.It leaves too much figuring out and guessing for the reader.It is not very user-friendly!
On the positive side, it does an adequate job of explaining concepts when complex code is not involved.I found that I could follow along on even the more advanced chapters mostly everything at least until code was suddenly introduced.Then it became a guessing game as to what it was trying to do.
The author does not seem to realize that it is more difficult to try to understand somebody else's program than it is to write your own program from scratch.As a consequence the reader wastes a lot of time trying to guess what his program is doing.
Note: this review is of the 2nd edition and does not necessarily reflect the 3rd.But, then again, every other review on this page prior to mine is about the 2nd edition as well! ... Read more

Product Description
Originally published in 1981, this was the first textbook on programming in the Prolog language and is still the definitive introductory text on Prolog. Though many Prolog textbooks have been published since, this one has withstood the test of time because of its comprehensiveness, tutorial approach, and emphasis on general programming applications. Prolog has continued to attract a great deal of interest in the computer science community, and has turned out to be a basis for an important new generation of programming languages and systems for Artificial Intelligence. Since the previous edition of Programming in Prolog, the language has been standardised by the International Organization for Standardization (ISO) and this book has been updated accordingly. The authors have also introduced some new material, clarified some explanations, corrected a number of minor errors, and removed appendices about Prolog systems that are now obsolete. ... Read more

Customer Reviews (8)

Dissatisfied
Pros:
- Even someone with no programming or math knowledge could pick up the book, read it, and learn Prolog
- Uses ISO-Prolog
- Large section of helpful example programs

Big Cons:
(I'll give citations, only from the first 100 pages to keep things short, lest anyone think I am lying about the problems with the book)
- Frequent syntax errors *in program statements* - in Prolog, every comma and period is absolutely essential, when they are missing it entirely changes the meaning of the statement - the book misses them pretty routinely (p 81, twice)
- Frequent logic errors - in Prolog, the order of facts and rules is extremely important.The book commonly mixes things up, presenting you with programs that will not work (p 56 - note here that they are trying to give an example of what will/won't work, and they get it backwards)
- Frequent editing/formatting errors - charts, diagrams etc are fairly often on the wrong page or in the wrong location, etc.(p 48)
- Poor organization - looking through the table of contents, you would think the book is extremely well organized, but as you read it, you'll find new and important ideas thrown into random sections - if you forget something, and need to find it later, you'll probably need to re-skim the entire book.Things are almost never presented in convenient bullets/numbering, almost always in paragraph form, again, making essential ideas tedious to find.
- Confusing - I have degrees in math and computer science, and have been programming for 15 years, and I still found parts of the book hard to follow - note that it had nothing to do with Prolog itself, which is actually very straightforward, but rather with the explanations given, which sometimes seem meandering and poorly worded.
- A really short and crummy index makes things hard to find.For example, look up "atoms", a concept first mentioned on page 26, and routinely mentioned afterwards, a concept absolutely essential to understanding Prolog - the index shows that the first (and only) time it appears is on page 123.

Average Cons:
- Authors use an "arrow system" to trace Prolog decision making, I think a table system (which could easily show previous, current, and future steps, and details of each iteration) would have been better while presenting more information in a clearer fashion.
- Code re-use - normally a good thing, frustrating in this book.You might have a rule (like a function) called "mother(X)..." early on in the book, not use it for 100 pages, and then it appears again.If you want to try the program out yourself, you'll need to know the exact definition of "mother(X)...".There's no way to find what page the function was on in the index or TOC, so you find yourself spending 30 minutes leafing through the book to find it.99% of these are a single line of code, so there's really no need to reuse them, it's hardly saving any space.
- Overly complex examples - sometimes the authors illustrate an idea with 20 lines of code, when 4 would have been sufficient.It makes for a lot of extra reading and deciphering.

Small Cons:
- (This could be a pro or con - since I don't know too many people who *start* their programming experience with Prolog, I assume the reader has some experience with programming, and so list this as a con) Book is far too detailed for someone with moderate programming or math experience.This helps some people, but makes it a tedious read for others.Every concept is thoroughly explained.If you're a programmer, this gets a little old during things like variables and recursion.If you know any math, verbose explanations of predicate logic will become tiresome.In fairness, it was no doubt the authors' intention to make a "complete" introduction to Prolog, and so it is hard to criticize this.
- (Another pro/con, depending on the reader) British examples - the authors are British (or at least one of them is), and use British references in their code all the time (9th century princes of Wales, p 34; horses who won races in Britain in 1927, p 53) - if you're British this might break up the monotony and make things a little more interesting, if you're not, it just gets a little old, I'd rather see every example just use "cat","dog","mouse".

Other:
- NOT a good reference book (and it wasn't meant to be), if you know Prolog already and need a reference book, look elsewhere.This is for people who do not know Prolog.

Conclusion:
- I wish I bought a different book.BUT despite everything, I did adequately learn Prolog from this book, so will reluctantly give it 3 stars.

Highly Recommended
Programming in Prolog is a clear, precise introduction to Prolog from the ground up.

While is does start with the basics, it is an incredibly thorough text, covering all minutia of the language. The text is clear, easy to understand, and to the point, moving quickly through topics without sacrificing understanding.

I used this book as a supplementary text in an upper-division college course. After reading only the first four chapters, I knew things about the language that the instructor did not.
I highly recommend this book to any programmer of any skill level that is interested in learning the Prolog programming language.


Additionally,
The following two books were recommended in the preface of Programming in Prolog. The first as a quicker (though not as complete) overview for the experienced programmer, and the second as a language reference.
Clause and Effect: Prolog Programming for the Working Programmer
Prolog: The Standard: Reference Manual

A well done beginning prolog book
This book is a great introduction to learning prolog.I was learning prolog for neurolinguistics and AI applications.I have some facility with programming, python and C++, but am not a pro and it is not my day job by any means.I found this to be a very good basic introduction to prolog.There are a few typos, and a part on data structures where the commentary and the code it's on are switched.The book also loses pace and points and has to be plowed through.But on the whole, an excellent solid book to learn prolog a little.

The Best Book on Prolog
As good in 2007 as it was when published first time. There is no better introduction to Prolog

Excellent resource on the Prolog programming language
This is an extreme valuable book on the Prolog programming language that every computer science person should own.Prolog itself is actually a fairly simple language to learn, albeit slightly obscure.It's reputation for complexity comes from its non-standard implementation, but if you don't enter into it expecting it to look and behave like other languages then you should be all right.Once you get past the mathematics and logic, you should be able to get your mind working in that particular direction.This book is a very handy guide for getting the programmer into the Prolog mindset as well as bringing one up to speed on all the (sometimes very confused) syntax.

This book, like Prolog itself, is not for the beginning programmer.If you have a good background in logic or mathematics, then you should find this book to be very rewarding. ... Read more

Product Description
This new edition of The Art of Prolog contains a number of importantchanges. Most background sections at the end of each chapter have beenupdated to take account of important recent research results, thereferences have been greatly expanded, and more advanced exercises havebeen added which have been used successfully in teaching the course.Part II, The Prolog Language, has been modified to be compatible withthe new Prolog standard, and the chapter on program development has beensignificantly altered: the predicates defined have been moved to moreappropriate chapters, the section on efficiency has been moved to theconsiderably expanded chapter on cuts and negation, and a new sectionhas been added on stepwise enhancement -- a systematic way ofconstructing Prolog programs developed by Leon Sterling. All but one ofthe chapters in Part III, Advanced Prolog Programming Techniques, havebeen substantially changed, with some major rearrangements. A newchapter on interpreters describes a rule language and interpreter forexpert systems, which better illustrates how Prolog should be used toconstruct expert systems. The chapter on program transformation iscompletely new and the chapter on logic grammars adds new material forrecognizing simple languages, showing how grammars apply to morecomputer science examples. ... Read more

Customer Reviews (9)

Logic Programming, Edinburgh Prolog, and Solutions - many gems - of AI and CS Problems
"The Art of Prolog" tries to be top notch: Beautifully crafted book, clear partition in four parts (Logic Programs, The Prolog Language, Advanced Prolog Programming Techniques, Applications), and most programs are very beautiful.

Anyhow the authors often try to explain the trivial sometimes even the shallow, then they often do not spent much effort in explaining the difficult. There is an unusual large amount of references to other parts of this book: backward and worse forward. The choice to explain first logic programming and then Edinburgh Prolog as an approximate implementation is especially unfortunate in this respect: A high level of redundancy separated by an entire book part with references to each other.

Most of the small programs are very beautiful and true gems. Though the reader should not foul herself, the development of most programs did last many years of brilliant people. I did not get a feel for the difficulty of developing a reasonable prolog program on my own.

I really liked the Background section at the end of each chapter: A very sound view to the world around the book.

If you are somewhat knowledgeable of the usual AI and CS problems, you will have a lot of pleasure to the elegant approach a prolog program can have to tackle many of them.

Best book on Prolog
Prolog remains academic but still of great educational value. But to get to that value, you need to get past using prolog like a smart procedural language. This book and especially its last few chapters achieve this goal. For this reason I recommend it as a must read for any decent computer scientist.

Pricey but a must have
Admittedly, this one tends to be a bit pricey.But, the content is pure gold for any programmer. Nowhere is the Prolog paradigm better conveyed than here.And, it is of little value to you if you attempt to learn prolog with a mindset of some other language. Prolog is unique and demands a unique way of looking at computer programming in general. It is dated a bit in that it does not cover all the latest developments in Prolog/AI research but no other Prolog books provide the foundational understanding that it does. Get this one for a solid foundation and then build on it with others. See my listmania list of AI Language books for suggestions of followup titles.

Great new programming paradigm.
I am currently working as a computer hardware design engineer. I have always been looking for new software methodology to improve my hardware design flow. Prolog, and especially its presentation in this book, shows me an interesting and powerful view of how computer programming should be.

Overall, I am a true believer in Prolog and logic programming after reading this book.

One of the 4 best books on computer programming
This, to me, is one of the 4 best books on computer programming. Unfortunately, it is hard. Not because the book is poorly written - it is like a wonderful story, but because understanding how to think declaratively after being taught something like C or Java is like someone giving you a pair of wings when you're a mudfish.

Thinking declaratively changes how you think about problems and how you write code. It's a career changing experience. This book leads the way.

Top 4:
* Structure and Interpretation of Computer Programs (Sussman, Abelson)
* The Art of Prolog by Sterling/Shapiro
* Introduction to Algorithms by Cormen, etc.
* Concepts, Techniques, and Models of Computer Programming by Van Roy and Haridi ... Read more

Product Description
Hacking your program is no substitute for understanding your problem. Prolog is different, but not that different. Elegance is not optional. These are the themes that unify Richard O'Keefe's very personal statement on how Prolog programs should be written. The emphasis in The Craft of Prolog is on using Prolog effectively. It presents a loose collection of topics that build on and elaborate concepts learned in a first course. These may be read in any order following the first chapter, "Basic Topics in Prolog," which provides a basis for the rest of the material in the book.

Contents: Basic Topics in Prolog. Searching. Where Does the Space Go? Methods of Programming. Data Structure Design. Sequences. Writing Interpreters. Some Notes on Grammar Rules. Prolog Macros. Writing Tokenisers in Prolog. All Solutions. ... Read more

Customer Reviews (6)

Ancient wisdom
While the language, numbers, and examples in this book are rather dated, the wisdom it contains is timeless.There is experience you can get from this book that you can't get from any other source.

a definitive resource
A common opinion nowadays, I suspect, is that Prolog is a neat hack that ran wildly out of control.And it is an opinion that is easy defend, and one with which I even have a lot of sympathy: not only does Prolog have substantial and not-really fixable problems as a 'serious' programming language, but it was also, in the aftermath of the 5th-generation hype, the inspiration for a lot of embarrassingly bad theoretical and quasi-theoretical research on 'logic' programming in the late 1980's and early 1990s.On the other hand, Prolog is also distinguished by some of the best books on progamming I have ever read: not just O'Keefe's 'The Craft of Prolog', but also, e.g., Sterling and Shapiro's 'Art of Prolog' crowd into the (depressingly small) queue formed behind the likes of 'Structure and Interpretation', 'the Science of Programming' and 'Programming Tools'. The existence of such books means that Prolog must have gotten _something_ substantial right.

Further, while in theory I divide the the set of all programming languages into clean Lisp dialects (i.e. scheme, ml, haskell) on the one hand, and other programming languages that are inadequate to the extent that they diverge from the Scheme/ML model on the other, I find that a lot of the time it is actually Prolog that provides the best tool for modelling the transaction-handling systems that I have to deal with in the course of earning my bread.

Whether you use Prolog or not, if you are serious about programming then you want to have a copy of this, simply because it shows how a world class programmer negotiates an unusual, but interesting, programming paradigm.And, as O'Keefe himself is, or at least used to be, fond of pointing out, your skill as a programmer is substantially correlated with the number of different such paradigms that you understand properly, and not very much with anything else.

Highly recommended if you are really interested in advanced programming.

Definitely a good book
I read this book in the library of my University. This book is *not* for beginners. Definitely. But in my opinion this is a *good* thing. This is a 5 star book: those who are not able to understand it, should study a bit more rather than lamenting about the book being too difficult.

"Where to go next" in your quest for prolog mastery
The spirit of this book is exemplified by this quote: "If your Prolog code is ugly, the chances are that you either don't understand your problem or you don't understand your programming language, and in neither case does your code stand much chance of being efficient."

This book is O'Keefe's attempt to wipe out both root and branch of bad prolog code.A close reading of this book will not only give you a deep understanding of prolog and logic programming, but it will put you into mental contact with O'Keefe's profound insights into the kind of thinking necessary for being a topflight progammer.

I should mention that this book is not just for prolog programmers.It contains mindbending observations on programming available absolutly nowhere else.Unfortunately, like the scholar of the middle ages who had to master Latin and greek, you'll have to learn prolog before this book will yield up its treasures.

As O'Keefe unambiguously states in the opening paragraphs, this book should NOT be your first, or even your second, book on Prolog.There's no royal road to knowledge; you'll have to pay your dues.But after you've achieved a good foundation, this is the way forwared to enlightenment.

Indispensable Classic
This book, although not an introductory text, is widely considered the indespensable classic in writing good Prolog code. Try searching for it in the newsgroup comp.lang.prolog some time on DejaNews.

Prolog does awonderful job of hiding what is really going on. This book reveals thewonderous truth. ... Read more

Product Description

This book teaches the techniques of Logic Programming through the Prolog language. The name stands for Programming in Logic. Prolog has been used for a wide variety of applications, including as the basis for a standard ‘knowledge representation language’ for the Semantic Web – the next generation of internet technology; it is one of the principal languages used by researchers in Artificial Intelligence.

Logic Programming with Prolog does not assume that the reader is an experienced programmer with a strong background in Mathematics, Logic or Artificial Intelligence. It starts from scratch and aims to take the reader to a point where they can soon write powerful programs in the language. Suitable both as an introductory textbook and for independent study, the programs in this book are written using the standard ‘ Edinburgh syntax’ and should run unchanged in virtually any version of Prolog. A full glossary of the technical terms used is included and each chapter has self-assessment exercises.

Customer Reviews (1)

different style of programming
Prolog is one of these languages that has struggled for decades to achieve wide usage. As Bramer explains, it is a logic language, as opposed to procedural languages like C, Java or C#. In its space, it competes mostly with Lisp, which also has failed to garner broad acceptance.

Anyhow, Bramer's book is a little different from most other texts on Prolog. No prior programming expertise in any language is needed. Alternative books often assume an already sophisticated background in computer science.

Certainly, if you have programmed in something like Fortran or C, you'll find the mindset and syntax here to be very different. Which may well be one advantage to learning Prolog, even if you plan not to take it very far. It exposes you to a different mode of programming logic. That might even help you in your "regular" coding.

Now if you have coded in SQL, then there are conceptual similarities with Prolog. Both are declarative languages, and SQL is essentially an instantiation of set theory. Turns out in Prolog, much of it also amounts to set manipulation. ... Read more

Product Description
Addressed to readers at different levels of programming expertise, The Practice of Prolog offers a departure from current books that focus on small programming examples requiring additional instruction in order to extend them to full programming projects. It shows how to design and organize moderate to large Prolog programs, providing a collection of eight programming projects, each with a particular application, and illustrating how a Prolog program was written to solve the application. These range from a simple learning program to designing a database for molecular biology to natural language generation from plans and stream data analysis. ... Read more

Customer Reviews (1)

Knowledge Systems and Prolog by Sowa et al.
The Sowa work is important for anyone who designs a knowledge based system with a fairly complex rule structure. The mechanics of programming design of a knowledge system involve metalevel programming. The systems designer writes rules and rules on how to use the
rules. A rule has a head, a body (goal). A goal is either a
single or conjunction. A single goal always succeeds. A
conjunctive goal succeeds if both parts succeed. A single goal
succeeds if there is a rule whose head matches the goal and whose
body succeeds.

The programming mechanics of artificial intelligence must be
presented in an easy-to-follow format; otherwise the technical
programming theory and implementation will be more difficult
for a novice to grasp. This work is perfect as a supplemental
text in an introductory or intermediate-level course in
artificial intelligence in a computer science or engineering
program. A strength of the work is that the author provides a good explanation of the basic theory of AI programming
with accompanying examples depicting implementation.

The work is a solid value for the price charged. This presentation would be very helpful in a formal research project
of Artificial Intelligence. ... Read more

Product Description
This book covers the Prolog programming language thoroughly with an emphasis on building practical application software, not just theory. Working through this book, readers build several types of expert systems, as well as natural language processing software and utilities to read foreign file formats. This is the first book to cover ISO Standard Prolog, but the programs arecompatible with earlier dialects of the language. Program files are available by FTP from The University of Georgia. ... Read more

Customer Reviews (5)

Pragmatic Introduction to Prolog and Logic Programming
I have been in the field of software development and architecture for quite a while now. While I value the rigor and comprehensive nature of academic texts on specific topics in this field, I frequently find them to be overly abstract to easily apply to a particular problem domain. This text provides an excellent, pragmatic, and easy to apply introduction to both the Prolog semantic model and language structure, as well as its differences from traditional procedural or assignment-based programming languages and metaphors. I also have "The Art of Prolog" and several other books on the topic, but this is the book that I find myself repeatedly using as a reference on how to most clearly and easily represent and solve a particular problem using this extremely flexible and expressive language. Kudos to the authors for an excellent presentation on the subject!

An unexpected gem
One of the most underrated schools of thought in AI and NLP is the the school which was lead by Michael Covington and Donald Nute at University of Georgia.It is the opinion of this reviewer that this school produced, in its papers, thesis of grad students, and books, the most impressive results in discourse representation theory produced in the western hemisphere, and are comparable with those produced anywhere else in the world.

This book--a product of that school--is such an unexpected little gem of a prolog book.I wish I would have stumbled across it much earlier in my quest for prolog mastery, because it would have saved me at least 18 months of struggling to learn prolog tools and techniques--techniques which were not only scattered among dozens of books, but were not nearly as clearly described.

One area which this book covers which virtually no other prolog book covers is nondefault reasoning.Really a remarkable discussion.Unfortunately, I think that the techniques of nondefault reasoning which are covered in this book have been superceeded by newer techniques, such as probabilistic horn abduction and Baysian methods.But just because these techniques are of historical interest doesn't mean they are of no interest, and the treatment they get here is clear, honest, and more complete than anywhere else I've looked.

A useful book for those who study logic programming and AI
The book is well organized with fluent exposition especially, in comparing the traditional and logic programming. The efford spend to create a bridgebetween these programming paradigmas is interesting and remarkable. Itcontains the examples that were prepared intelligently about how to thinkwriting a program and AI examples. It also contains some hints aboutelegant programming techniques in prolog and for those who want to write aprolog interpreter. Moreover, how a programmer makes mistakes inprogramming were determined. In this mean, it has a spectrum from novice toexpert. Reader can find differencies between different prologimplementation and prolog standards and can find good explanation aboutsome special topics such as cut operator, recursive definition, file usage,reading data in foreign formats, tree structures and operator definitionsspecial to user.

It would have been better to write a whole chapterwhich includes how to write a prolog interpreter. There is no knowledgeabout prolog can interact with what languages and how it is done this. Forexample, how we can use C in prolog and vice versa.

Mehmet Fatih Hocaoglu

Great starter book
Lots of practical tips early in the book, particularly on I/O, get the reader off to a fast start in Prolog. This reviewerfelt lost in Prolog until he read this text.The breadth of examples is impressive.

The only flaw on this book is the author's tendency to fight some ideological battlesthat the reader does not care about.Their tone is unnecessarily hostile, particularly in the introduction to Chapter 4.But that's only one paragraph in an otherwise wonderful book.

It is a great book for getting started, and getting a feel for Prolog, but it is no substitute for a thorough text that includes some theory.

Theory is not a bad word.A working understanding of how the logic interpreter works is important for debugging.

In my opinion, Chapter 3 is denser than it appears, and should be studied carefully.cf. the discussion of append.This reviewer has done the exercises using SWI prolog with only minor adaptations.

All told, a solid introduction.A good book to read before (but not instead of) a more theoretical introduction such as The Art of Prolog.

Even though freeware prologs exist on the internet, the appeal of this "practical" book would be greatly increased if the authors arranged to have a CD of some freeware prologs included with the text.

A very good reference for developers
This book has been an excellent material for me todevelop my Logic Programming skills. That is because it provides not only theory of Prolog programming but also very useful artificial intelligence applications and expert system shells even with uncertainty. Another useful feature I liked much is; the book makes comparisons (where needed) between how to do the same thing in Prolog and in a conventional programming language, Pascal. ... Read more

Product Description
This workbook is for programmers who are new to Prolog and who wish to write useful Prolog programs. The emphasis is on a simplified and disciplined methodology for discerning the mathematical structures related to a problem, and then turning these structures into Prolog programs. A relatively pure subset of Prolog is used and the focus is not on particular features of the language. The presentation is novel. An outline of basic concepts is interleaved with worksheets, which are graduated in scope and give guidance for practising new ideas. Extended examples in the form of case studies then apply the ideas. The book can be a useful companion to two other Springer books, as a sequel to the author's introductory text "Programming in Prolog" and alongside the reference manual "Prolog: The Standard". ... Read more

Customer Reviews (4)

The Little Prologer
I really like this book.It serves roughly the same purpose for the Prolog language that "The Little Schemer" serves for Scheme.It presents the Prolog language through a series of examples (called "worksheets" here), each about a page long.In each example the author walks through the solution of some problem, discussing the issues that come up.Later in the book, the examples give way to larger "case studies" of five or ten pages each, in which a more substantial problem is tackled.In my opinion, this is a very effective way to teach a language like Prolog, and I now understand a lot about the language I didn't understand before.Prolog is one of those languages that can't be learned simply by memorizing new syntax and referring to what you already know, because its execution model (logic programming using unification and backtracking) is so drastically different from that of most other languages.Therefore, one needs to walk through a lot of examples slowly, and this is where "Clause and Effect" really shines.I was particularly impressed at how trivially easy it is to do symbolic algebra in Prolog; I've written programs of this type in Scheme, but the Prolog versions are much shorter and easier to understand.

This book is not perfect, however, and I can't in good faith give it five stars (though I really want to).There are a fair number of typos scattered through the text (the author has an errata sheet on his website).Most of these are obvious, but on occasion I had to spend a lot of time puzzling over whether some bit of code had a typo or not (most of the time, there was no typo; it was just my understanding that was deficient).When in doubt, entering the code into a Prolog interpreter works wonders; I really wish the author would make a zip file of all the code examples available for download.A more significant problem than the typos is that the author writes in a very condensed style and either doesn't explain the meaning of some critical terms at all (like tail recursion) or doesn't explain them well enough (like backtracking).Coming from a functional programming background, and having already read a book on Prolog, I could fill in the gaps without much trouble, but many readers will have a harder time than I did.For these readers, I recommend that they use this book as a complement to a book with a more extended discussion of the language; the author's book "Programming in Prolog" is a fine choice for this.

I think that all serious programmers owe it to themselves to learn about logic programming just to see how easy it makes some problems which are quite difficult to solve in more conventional languages (try writing a symbolic differentiation program in a single page of C++, for instance).I heartily recommend this book for this purpose; it will stretch your mind and make you a better programmer.

Ambivalent review
I am of two minds about this book.On the one hand, it suggests surprisingly diverse applications of the language, some of which I never would have imagined, taking advantage of the language's unusual features.My main complaint is with the explicit source code, which is supplied without comments and where variables are often represented by obscure single letters rather than descriptive names, as would normally be the case with textbook examples.If you don't mind this shortcoming, I would recommend this book to anybody interested in Prolog.

Serves its purpose well
For those who have experience in logic programming, either with Prolog or some other language, such as Lisp, or even a high-level symbolic programming language like Mathematica or Maple, this book could serve as a first course or a summary of Prolog programming. Research in logic programming is still an active area, and the approach taken in logic programming languages seems more natural from the standpoint of mathematical (predicate) logic. The author, in this short book, gives the reader an appreciation of Prolog and the philosophy and constructions behind logic programming. Many examples are employed that illustrate how to code in Prolog and how useful it can be in real-world applications.

In the first chapter, the author gives some justification for programming in Prolog, such as its symbol manipulation capability, automatic backtracking, the view that data structures and programs are of the same form, and the relational form of clauses. The syntax of Prolog is then discussed, and examples given of the three kinds of terms in Prolog. Readers with some background in category theory will appreciate the discussion more, as the author does employ some of this in the discussion, for example the view of addition as being a functor of a term. Terms are drawn in tree form in this chapter and throughout the book. The author then characterizes a Prolog program as a set of procedures, with each defining a predicate, and consisting of one or more (Horn) clauses. Unification of terms is discussed as a basic operation that determines when two clauses can be made equivalent by a substitution of variables. The execution of a program is viewed as a querying of the clauses, and the goal or e nd of the program is a proof that the goal is true.

Data structures in Prolog are discussed in chapter 2 as generalizations of programs using compound terms instead of just constants and variables. Lists are defined and their syntax discussed, along with dot and bracket notation. The implementation of simple arithmetic in Prolog is discussed. Several effective examples are given to illustrate arithmetic and list manipulation in Prolog.

Mappings, which are relations between two data structures, are the topic of chapter 3, and the author gives many examples illustrating how it is used to compose Prolog programs and how they act an both lists and more general trees.

The built-in predicate "cut" is discussed in the next chapter as a predicate to allow backtracking control of the program. The author gives many examples illustrating the problems involved with the use of "cut".

Difference structures are discussed in chapter 5 as a tool to simplify and increase program efficiency. A generalization of the idea of an accumulator, they allow one to work with "holes" in data structures during actual program execution. A list for example, can be viewed as "open" with its elements known only up to a point. It can then be filled in with an empty or a proper list. A difference list, discussed in the chapter, is then a list represented as a pair of "front" and "back", with the back being variable.

Applications of term rewriting are given in chapter 6, with symbolic differentiation launching the discussion. This is the more popular example of what Prolog-type languages can do, and is usually the reason given for beginning the use of symbolic programming languages. The author also discussed matrix multiplication in this chapter.

The next two chapters discuss the representation and manipulation of logical circuits using Prolog, including shift registers and coding circuits. This is followed in chapter 9 by an interesting discussion on how to write a compiler in Prolog, with the author discussing compilation for a single-accumulator computer, a RISC machine, and a stack machine. This is followed in chapter 10 by an even more interesting discussion on how to write a Fast Fourier transform in Prolog.

The last chapter of the book discusses how to use higher-order functional programming techniques in Prolog. For individuals, like myself, who are convinced that functional and logic programming are the most effective programming paradigms, this chapter is very interesting reading. The author defines an evaluator written in Prolog for these higher-order functional programs. Functional programming views computation as a collection of function applications on an expression representing a particular problem, and these functions can then be viewed as arguments to other functions. The lambda calculus from mathematical logic serves as the foundation for functional programming, and the author reviews this quickly, along with the technique of currying, in order to obtain facilities for functional programming in Prolog. Although short, this chapter introduces the reader to a fascinating area, and helpful references are given at the end of the chapter.

Ideal for a short course on Prolog
For years I've tried to find a short Prolog text for my Computer languages course.I cover Prolog in 4 weeks and so didn't want a huge 400+ page text.Clause and Effect comes in at about 1/2 inch thick.I've come to love this one for what it does.It introduces some basic topics, then includes a number of "worksheets" at the end of each chapter.It offers a "learning by doing" approach (the worksheets are short "lab exercises").A word of warning - don't expect to learn everything about Prolog from this text.It does not go into the philosophy and theory of Prolog and logic programming.But for my needs it's perfect. ... Read more

Product Description

Product Description
The first book on Prolog ++, an important new language combining object-orientation with logic programming. Includes tutorial style with worked examples, exercises, summaries, etc., significant applications coverage, state-of-the-art coverage of other approaches including parallel language, and distributed databases. ... Read more

Product Description
Approaches the subject by applying the format used in successful language courses. Offers a comprehensive exhibition of Prolog programming techniques in four stages--declarative, procedural, advanced and meta-programming. Presents simple and efficient implementation of logical negation and quantified goals which are necessary in expert systems. The dynamics of these new features are shown in the construction of a multilingual expert system shell that supports negative and quantified queries as well as subtypes. The easy-to-follow tutorial style and numerous fully-solved exercises facilitate understanding. Comes with 3.5 inch disk containing all programs in the book. ... Read more

Product Description
The authors present a systematic development of the concurrent object-oriented agent programming language Guarded Definite Clauses (GDC). In contrast to other languages used in agent programming, like Java, Telescript, and Agent-TCL, this language is derived from the artificial intelligence programming tradition and emphasizes AI applications. The first part of the book is devoted to the principled evolution of the paradigm GDC; during the course of this evolution, the reader can also learn a lot about the history and the dramatically changing fortune, booms, and busts, of AI. In the second part, the paradigm is evaluated for application in various fields including parallel distributed search, distributed constraint solving, meta-interpretation, partial evaluation, and robotics and multi-agent systems. The book is written for students and professionals in agent programming or in AI programming in general. ... Read more

Customer Reviews (1)

A Classic 'Logic-based' AI programming book!
Ringwood and Huntbach were my professors in graduate school. They taught us a course titled Multi Agent Systems. Much of the areas covered in those lectures find their way in this superb account on AI programming.

The first few chapters are accessible to readers without a strong AI background. The material gets more involving as we go through the book.

Interestingly, the book develops the idea of 'agent-oriented' programming chronologically from the the days preceeding the Fifth generation project to present day multi-agent technologies.

I would highly recommend the book to all AI students, researchers and practitioners. ... Read more

Product Description
This book covers all that is needed by students on a one-year introductory Prolog course at first or second year degree level. It introduces Prolog to students as simply and painlessly as possible. Where Artificial Intelligence (AI) topics are introduced, they are easier ones and are treated simply. This book is Prolog for Students, with examples from AI, not a book on AI using Prolog.The text assumes access to a suitable, good, Prolog interpreter, such as LPA Prolog. It also assumes that students with an aptitude for research will follow it up with more advanced study, perhaps a third or fourth year option, and further reading suggestions are included.The book is organised with the basics of the subject introduced first, and covered gradually, so they can be fully understood before moving on to harder topics. The topics that students find more difficult, such as recursion and lists, are not covered until about half way through the book. There are many in-text questions, student self-testing questions and programming practice exercises throughout the book. If used to accompany a taught course, the material of one chapter can be covered in each week. ... Read more

Product Description
An examination of natural language processing in Prolog for those who know Prolog but not linguistics, this book enables students to move quickly into writing and working in useful software. It features many working computer programs that implement subsystems of a natural language processor. These programs are designed to be understood in isolation from one another and are compatible with an Edinburgh-compatible Prolog implementation, such as Quintus, ESL, Arity and ALS. ... Read more

Customer Reviews (1)

One of the best intros to NLP
This book, while a bit dated, is still the best discussion of a wide variety of (nonstatistical) parsing methods in print.The best part of this book is the table on p. 191, where the author compares the runtimes of the various parsing algorithms, and shows that the one with the scariest "big O" complexity is actually the fastest in practice.This is a very important lesson to impart to budding computer scientists: use "big O" analysis wisely, not as the voice of God, as to which algorithm is the best practical algorithm.

I've given this book 4 stars instead of 5 stars because it is a little out of date: look elsewhere for the best discussions of quantifier scope handling and discourse.Also, it doesn't contain any discussions on the what is today the more fashionable statistical-based approaches, but the jury is still out, IMHO, on whether this is a drawback or not. ... Read more

Product Description
What sets this book apart from others on logic programming is the breadth of its coverage. The authors have achieved a fine balance between a clear and authoritative treatment of the theory and a practical, problem-solving approach to its applications. This edition introduces major new developments in a continually evolving field and includes such topics as concurrency and equational and constraint logic programming. ... Read more

Customer Reviews (1)

A good overview with many applications discussed
In this book the authors attempt to give a background into the foundations of logic programming and to develop programming expertise in the programming language Prolog. They do a good job, and considering the importance of logic programming in both research and industry, a perusal of this book will give the reader a good background to enter fields such as constraint logic programming or artificial intelligence.

Chapter 1 is an introduction to what logic programming is all about, with its declarative nature emphasized right away. The syntax of predicate logic is introduced as a formalization of a collection of declarative statements of natural language. The semantics of the formulas in predicate logic is discussed in terms of a relation between its language and a particular (algebraic) structure. The meaning of terms including both constants and variables is done using a 'valuation'. Some elementay model theory is developed here also.

In chapter 2, the authors take up logic programming by introducing the notion of 'definite clauses'. A 'definite program' is then a finite set of definite clauses. Logic programming is explained as writing down a collection of logic formulas, with the programmer attempting to describe an intended model via the use of definite clauses, or "facts" and "rules". The program can have many models, with a program being "incorrect" if and only if the intended model is not a model of the program. The authors show clearly the role of queries in establishing the truth of the intended model.They also show the existence of a model that reflects all of the information expressed in model but not any more, the famous 'Herbrand model'.

Logic programs are essentially reasoning systems, and so a notion of proof is needed. This is done in chapter 3, which discusses inference rules in the guise of "SLD-resolution", which is a model-theoretic notion of proof. The soundness and completeness of SLD-resolution is proven in detail. Readers familiar with resolution from earlier courses in logic will appreciate the discussion of 'proof trees" in this chapter.

Chapter 4 takes up the very controversial notion of negation in logic programming, and its connection with the 'closed world assumption', the latter of which allows one to derive negative conclusions based on the absence of positive information. The authors discuss various approaches to the justification of negative conclusions from general programs, and they explain the role of 'program completion" in capturing the notion of negation as finite failure.

Those readers who already have exposure will appreciate more the discussion in chapter 5, which deals with the 'cut' pruning strategy for traversing of SLD-trees, along with 'built-in arithmetic'. The effects of the cut operation are explained in detail, including its ability to destroy completeness of definite programs and soundness of general programs, and if negation is involved, give incorrect answers. The authors also show how the cut operation may be used to implement negation in Prolog. The discussion on built-in arithmetic in Prolog alleviates any concerns that one is departing from the declarative paradigm by its incorporation. Since only relations can be expressed in logic programs, readers need to know how to express arithmetic operations in such programs.

Chapter 6 is more practical, as it discusses the connection between logic programs and relational databases. The authors show how logic can both 'explicit' and 'implicit' data, the latter corresponding to 'views' in relational database theory. The authors show in detail how logic programs can implement the operations of 'relational algebra', and how they can be used as query languages. They also show how to construct compound terms in order represent more complicated constructions, like families and their members.

In chapter 7, the authors introduce tools for dealing with data objects that are variable in size or possibly infinite. These objects can be represented by 'recursive data structures' and which can contain (via recursion) subclasses of the same type. Readers familiar with the programming language LISP will appreciate the discussion, since the 'list' data structure is used throughout the chapter.

Chapter 8 is more esoteric, as it shows how to use logic programs as a "metalanguage" to describe logic programming, with emphasis on constructing 'interpreters', the latter being used to describe the operational semantics of a programming language. The authors show how to construct interpreters for Prolog without built-in predicates, these being called 'self-interpreters'. The discuss in detail the advantages of using self-interpreters. They discuss also however the built-in predicates in Prolog, and their advantages in metaprogramming.

The use of logic programming to build expert systems is discussed in chapter 9. The knowledge base of an expert system is a collection of definite or general clauses, but this base is usually incomplete in a logic program. This knowledge is added while using the program. The authors show how to construct an inference tool for the expert system based on the notion of a self-interpreter.

The connection of logic with computational linguistics and formal language theory is the topic of chapter 10. Parsers for context-free and context-dependent languages are constructed. Prolog programs are interpreted as 'definite clause grammars' in this chapter also.

Chapter 11 addresses algorithms for searching state spaces, with the famous "water-jug" and "blocks world" problems are discussed as examples.

The remaining chapters of the book discusses alternative approaches to logic programming, such as using parallelism to solve subgoals simultaneously and its connection with "concurrent logic programming". Also discussed is how to associate functions with functors, in order to incorporate a notion of equality into logic programming. The most important discussion is chapter 14, which treats constraint logic programming. This area has become extremely important in business and industry and several multi-million dollar companies have appeared in the last decade that specialize in constraint logic programming packages. The authors describe in detail how to give declarative meaning to constraint logic programming languages. ... Read more

Product Description
PROLOG represents a new approach to computer programming, being a high-level language which takes much of the drudgery out of programming by reducing the time and effort required to solve problems. This text introduces the reader to PROLOG and explains how to read and write programs. ... Read more