Product Description
A presentation of the central and basic concepts, techniques, and tools of computer science, with the emphasis on presenting a problem-solving approach and on providing a survey of all of the most important topics covered in degree programmes. Scheme is used throughout as the programming language and the author stresses a functional programming approach to create simple functions so as to obtain the desired programming goal. Such simple functions are easily tested individually, which greatly helps in producing programs that work correctly first time. Throughout, the author aids to writing programs, and makes liberal use of boxes with "Mistakes to Avoid." Programming examples include: * abstracting a problem; * creating pseudo code as an intermediate solution; * top-down and bottom-up design; * building procedural and data abstractions; * writing progams in modules which are easily testable. Numerous exercises help readers test their understanding of the material and develop ideas in greater depth, making this an ideal first course for all students coming to computer science for the first time. ... Read more

Customer Reviews (2)

Great intro to Computer Science, not just to programming
The first part of this book will give the basic programming `how to' knowledge: Common abstractions and basic program design.

The second part introduces Computer Science and will show you what others have been doing with the techniques explained in the first part. It will give a panoramic view of modern CS: databases, operating systems, artificial intelligence, compilers, `soft-computing', etc...

Only the chapter on compilers seems a bit confusing, everything else is clearly explained.

You won't need a good background in maths to follow it.

excellent university teaching tool
I was a former teaching assistant this past summer for a lower divisioncomputer science course at UC Berkeley. We used this book as our primarytext. From several semesters of teaching introductory computer sciencecourses I can say that this book has proven to be an indispensible item forme. Ranging from concise writing to thought provoking questions, it is anexcellent introduction to future computer scientists. I recommend this toanyone. ... Read more

Product Description
Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, are enough to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today. This book contains the three parts comprising 'R6RS', the sixth revision of a series of reports describing the programming language Scheme. The book is divided into parts: a description of the language itself, a description of the standard libraries and non-normative appendices. Early chapters introduce Scheme and later chapters act as a reference manual. This is an important report for programmers that work with or want to learn about the Scheme language. ... Read more

Product Description
Buck Graham's authoritative work-still the only book devoted entirely to TCP/IP addressing-will now be available in a second edition, revised and updated to reflect the latest changes in networking technology.
This book will cover all the fundamentals presented in the first edition, including the ABCs of routing and addressing, optimization, and special routing techniques for Internet-connected networks, as well as the new advances affecting TCP/IP addressing, including the rise of ATM, the emergence of address management tools, and changes to relevant protocols.


* A comprehensive, nuts-and-bolts resource for networking professionals and students alike.
* Presents information essential to any network-intensive organization.
* Fully updated to answer pressing questions about recent advances affecting TCP/IP addressing, including the rise of ATM, the emergence of address management tools, and changes to relevant protocols.
* Offers detailed coverage of techniques relating to Internet connectivity and intranet implementations.
... Read more

Customer Reviews (5)

Exceptional book for TCP/IP novices
I highly recommend this book if you work in I.S., support servers or database systems, and want to know about TCP/IP subnetworking.

My situation three years ago:

I was an OpenVMS M/SQL systems manager put inan awkward position of constantly having my projects delayed and abortedbecause the network engineers I worked with did not understand IP wellenough to support my organizations' network.It was a Friday, and I wasworking on an important project that needed to be done by Monday.Thenetwork engineers had completely let me down -- they boggled a routerconfiguration and addressesing scheme and blamed it on the me and the phonecompany!I went to the local bookstore, picked this book up, and (withthis book) I was able to fumble my way through a the design of a smallsubnetwork and router configuration by Monday.Within a few months, I tookover their responsibilities.

Since then, I've become CCNA-certified, afull-fledged network engineer, and have seen incredible career-growth. None of this would have been possible if not for this most excellentintroductory book.It was very easy to read, even for asubnetworking-ignorant fool (at the time) like myself.

Excellent!!!
This is a must read for anyone putting together anIP network

Deffinitly a selection for beginners
The author positions the book as a IP numbering system for enterprize networks and it is not.Graham spends half of the book explaining what an IP datagram is and what it is used for and the other half of the book isvery basic IP numbering theory. Basically if your in charge of the ipnumbering of an "Enterprize Network" and anything in this book isnew to you then your in over your head.

Excellent, useful resource, thoroughly covers its subject.
If you want to learn or review IP Addressing I can think of no better book on the market-highly recommended!While all of this information is available elsewhere in piecemeal fashion, this book puts it all together, including critical design issues, all with very clear, practical examples based on the author's extensive experience. If your work calls for a solid understanding of the intracacies of IP Addressing, implementation, this book is for you.

An excellent 'how-to' tome on a very difficult subject
The book provides confidence and integrity in an enlightening array of subjective entries. The author leads an impressive set of credentials to the reader with first person comfort. The format allows entry-level students of the subject matter enough leeway to follow a suggested path to better design of networks by first considering the 'Addressing' issues. ... Read more

Product Description
drawings by Duane Bibby

foreword by Gerald J. Sussman

"I learned more about LISP from this book than I have from any of theother LISP books I've read over the years. . . . While other books willtell you the mechanics of LISP, they can leave you largely uninformed onthe style of problem-solving for which LISP is optimized. The LittleLISPer teaches you how to think in the LISP language. . . aninexpensive, enjoyable introduction." -- Gregg Williams, Byte

The notion that "thinking about computing is one of the most excitingthings the human mind can do" sets both The Little Schemer(formerly known as The Little LISPer) and its new companionvolume, The Seasoned Schemer, apart from other books on LISP. Theauthors' enthusiasm for their subject is compelling as they presentabstract concepts in a humorous and easy-to-grasp fashion. Together,these books will open new doors of thought to anyone who wants to findout what computing is really about. The Little Schemer introducescomputing as an extension of arithmetic and algebra -- things thateveryone studies in grade school and high school. It introduces programsas recursive functions and briefly discusses the limits of whatcomputers can do. The authors use the programming language Scheme, andinteresting foods to illustrate these abstract ideas. The SeasonedSchemer informs the reader about additional dimensions of computing:functions as values, change of state, and exceptional cases. TheLittle LISPer has been a popular introduction to LISP for manyyears. It had appeared in French and Japanese. The Little Schemerand The Seasoned Schemer are worthy successors and will proveequally popular as textbooks for Scheme courses as well as companiontexts for any complete introductory course in Computer Science. DownloadDrScheme - a graphical environment for developing Scheme programsAmazon.com Review
This delightful book leads you through the basic elements of programming in Scheme (a Lisp dialect) via a series of dialogues with well-chosen questions and exercises. Besides teaching Scheme, The Little Schemer teaches the reader how to think about computation. The authors focus on ten essential concepts of thinking about how to compute and demonstrate how to apply these concepts in inventive ways. The Little Schemer is an excellent book both for the beginner and for the seasoned programmer. ... Read more

Customer Reviews (41)

TERRIBLE!
This was, without a doubt, the worst book on learning a programming language that I have ever had the misfortune of encountering.

It proceeded along tossing out tiny pieces of knowledge that were presented in an incredibly unhelpful way.

Maybe some people think like this and "Programmed Learning" pedagogic theory (google it for more info) would work well for them, but it sure doesn't for me.

The general experience of this book in the class I had it for was that it was fairly polarizing.Some really liked it, most cracked the cover only a few times and then looked for online resources, and some really hated it (like me).

Cute, Intelligent Introduction to Computing
If you're an intelligent programmer who wants to know what all the fuss is about with regards to Lisp/Scheme, pick up this book. In a cute question and answer format, you'll jump from finding out if two sets intersect to dealing with the Y combinator rather quickly. If you "get" recursion already, there are still some things to learn here.

Side note: the books recommended in the "Intermission" section are all very good. (-:

The greatest book on programming that I have ever read.
Explains ONLY what is needed, like flash cards. The PERFECT way to teach.

I have made more progress from this one book then any other book by far and have had the most fun doing it.

This book answers the HOW and WHY to your WHAT?

I'm about 1/3 through and already feel much stronger with Python.

(Personally, I read the e-book and resize the window so that I can only see one question at a time. I answer the question then scroll over to the answer.)

Good luck and happy cramming!

A Great Little Introduction to Computation
This is a delightful little book that talks about recursive functions
and computation, and almost accidentally introduces the reader a few
important bits of the Scheme programming language. The format is a
question and answer dialog in two columns, and the reader is expected
to try and answer questions for themselves before looking at them.
Experienced programmers reading this book will find reminders about
why programming is a joyful activity. Novices will be rewarded if they
actually try to work out the answers for themselves: the answers cover
some of most beautiful and meaningful concepts in computer science.

The book covers a lot of ground. It starts by drilling the reader on
how to understand recursive structures (lists and numbers) and develop
functions to operate on them. People familiar with recursion will
probably breeze through this, but for everyone else it is worth
sweating through the details. The last 70 pages move fast: a
functional approach to programming, programming with continuations,
unsolvable problems, recursion as function application (the
Y-Combinator!), and a simple Scheme interpreter, are all introduced
with a sequence of probing questions, perceptive answers, a few cute
cartoons, and many references to foods. All the code examples can be
run in nearly any recent Scheme implementation, and doing so would go
a long way towards enjoying the material.

If one had to criticise this book it would probably be for covering
too much too quickly! The concepts covered here often take months (or
years) to understand, leave alone master. It would be easy for a
novice to miss the point here: the book is a taste of why computation
is a subject of great elegance and beauty, and is meant to make the
reader want to go out and study the subject in great detail. It is
really hinting at the great ideas out there awaiting the reader. Next
time you try Schönfinkelisation you will always be glad you read a
books like this!

Well, Do I have to really have a review?
Look for the "expert answers" in the book.What the experts know, how they know it.Make sure you know them and can apply them.I wish the exercises were still in this book. ... Read more

Product Description
This book, based on the author's Ph.D. thesis, was selected during the 1995 GI Doctoral Dissertation Competition as the winning thesis in the foundations-of-informatics track. Securing integrity for digital communications in the age of global electronic information exchange and electronic commerce is vital to democratic societies and a central technical challenge for cryptologists. As core contribution to advancing the state of the art, the author develops the new class of digital fail-stop signatures. This monograph is self-contained regarding the historical background and cryptographic primitives used. For the first time, a general and sophisticated framework is introduced in which innovative fail-stop signatures are systematically presented and evaluated, from theoretical foundations to engineering aspects. ... Read more

Product Description
Computer processing of natural language is a burgeoning field, but until now there has been no agreement on a standardized classification of the diverse structural elements that occur in real-life language material.This book attempts to define a "Linnaean taxonomy" for the English language: an annotation scheme, the SUSANNE scheme, which yields a labelled constituency structure for any string of English, comprehensively identifying all of its surface and logical structural properties.The structure is specified with sufficient rigor that analysts working independently must produce identical annotations for a given example.The scheme is based on large sample of real-life use of British and American written and spoken English. The book also describes the SUSANNE electronic corpus of English which is annotated in accordance with the scheme.It is freely available as a research resource to anyone working at a computer connected to Internet, and since 1992 has come into widespread use in academic and commercial research environments on four continents. ... Read more

Product Description
This book remains the only in the field of optimizationthat presents basic ideas underlying optimization methods from allclasses of such methods applicable to solving both strategic andoperations management problems that firms and corporations face intheir business activity. Although, in discussing applications of thesemethods in the book, the author refers to transportation systems-whichare the most diversified ones in the sense of classes of optimizationproblems emerging in analyzing the systems and in their management,including transportation-oriented ones-this book is, nevertheless, anintroductory guide to general optimization methods themselves. Thisguide allows one to comprehend ideas of a variety of optimizationmethods and substantially simplifies possible further work withoriginal books and scientific articles in which these methods werefirst presented or are explained in details. A special chapter of thebook is dedicated to mathematical concepts and facts helpful forunderstanding the substance of the methods while information presentedthere formally allows the readers, especially those who do not haveany mathematical background to start studying widely used fundamentalsof applied mathematics from the very beginning. ... Read more

Product Description
The VLISP project undertook to provide a rigorous verificationof a programming language. The project began at the MITRE Corporationin late 1989 under the company's Technology Program. The work wassupervised by the Rome Laboratory of the U.S. Air Force. NortheasternUniversity became involved a year later. The aim was to show realism and comprehensiveness. Realism is revealedin the choice of a widely used programming language, Scheme, and thechoice of a flexible and reasonably efficient implementation strategy.Comprehensiveness is revealed in the broad range of steps undertakenin verification, leading from the abstract syntax of a high levelprogramming language, equipped with a continuation style, denotationalsemantics, down to an abstract assembly language equipped with aconcrete operational semantics. The editors of VLISP have extracted re-usable conclusions fromthe work at two, quite different levels. First general approaches tothe organization of the work have been found which are beneficial andwhich can be recommended. They help to make formal methods morepragmatically effective. Second, there are four main verificationtechniques that are applied in the proof process. This relativelysmall collection of techniques, none of them particularly arcane,allow a large verification to be undertaken. The identification ofsuch re-usable parts bodes well for the increased use of formalmethods in compiler construction. ... Read more

Product Description
Large web applications are usually developed by using a conceptual modeling language, where a scheme representing the web application is stepwise extended and refined. Thereby, modelers repeatedly perform modeling tasks like "after having defined an entity type, add a page class for displaying the entity type's content". Since such tasks are performed again and again in a similar manner, it would be convenient to have scheme transformers that perform such tasks. This book introduces TBE (Transformers-By-Example), which is a language for defining and applying scheme transformers. TBE follows a by-example approach, where a modeler defines a transformer by giving a generic example of a scheme before and after transformation instead of specifying operations that perform the transformation. These operations are derived by TBE based on the provided generic examples. Transformers are thereby defined graphically and in a notation that is similar to one with which modelers are familiar. ... Read more

Product Description
An end-to-end guide to the technologies that will enable high-speed networks of the future

Increasingly, end users are demanding that the enterprise network--including LANs, WANs, intranet, VPNs, and the Internet-- functions seamlessly to provide critical business applications and services. Today's networks must be able to accommodate applications that require enormous processing speed and low latency. To ensure your network keeps pace with requirements, you must make it more reliable and predictable, and you must be able to provide more capacity. Paul Izzo puts gigabit standards and technologies in perspective to help you upgrade or build a network capable of handling high-bandwidth needs. Covering technologies from Ethernet to cable modems and DSL, Gigabit Networks will prepare you for enterprise networking in the Internet age.

Increasingly, end users are demanding that the enterprise network--including LANs, WANs, intranet, VPNs, and the Internet-- functions seamlessly to provide critical business applications and services. Today's networks must be able to accommodate applications that require enormous processing speed and low latency. To ensure your network keeps pace with requirements, you must make it more reliable and predictable, and you must be able to provide more capacity. Paul Izzo puts gigabit standards and technologies in perspective to help you upgrade or build a network capable of handling high-bandwidth needs. Covering technologies from Ethernet to cable modems and DSL, Gigabit Networks will prepare you for enterprise networking in the Internet age. ... Read more

Customer Reviews (1)

Gigabit Networks: Standards and Schemes for Next-Generation
One of the best books, I have seen on the emerging networking technologies and evolution. The book presents a systematic approach on the technologies which lead way to the hot technologies popular presently, like MPLS etc. For those who are still new to this area, other books are confusing and farily detailed because they assume that the reader has a good knowledge and concepts of the inter-related technologies like ATM, and target very mature audience. My hats off to Paul for his wonderful creation!

Sanjay ... Read more

Product Description

While conceptually elegant, the generic formulations of nonlinear model predictive control are not ready to use for the stabilization of relatively fast systems. Doctor Alamir presents a successful approach to this problem based on a co-operation between structural considerations and on-line optimization. The balance between structural and optimization aspects of the method is dependent on the system being considered so the many examples developed here aim to transmit a mode of thought rather than a ready-to-use recipe. Among the systems given detailed treatment are:

• double inverted pendulum;
• non-holonomic systems in chained form;
• snake board;
• missile in intercept mission;
• polymerization reactor;
• walking robot;
• under-actuated satellite in failure mode.

In addition, the basic stability results under receding horizon control schemes are revisited using a sampled-time, low-dimensional control parameterization that is mandatory for fast computation and some novel formulations are proposed which offer promising directions for future research.

Product Description
The goal of The Reasoned Schemer is to help the functional programmer think logically and the logic programmer think functionally. The authors of The Reasoned Schemer believe that logic programming is a natural extension of functional programming, and they demonstrate this by extending the functional language Scheme with logical constructs—thereby combining the benefits of both styles. The extension encapsulates most of the ideas in the logic programming language Prolog.

The pedagogical method of The Reasoned Schemer is a series of questions and answers, which proceed with the characteristic humor that marked The Little Schemer and The Seasoned Schmer. Familiarity with a functional language or with the first eight chapters of The Little Schemer is assumed. Adding logic capabilities required the introduction of new forms. The authors' goal is to show to what extent writing logic programs is the same as writing functional programs using these forms. In this way, the reader of The Reasoned Schemer will come to understand how simple logic programming is and how easy it is to define functions that behave like relations. ... Read more

Customer Reviews (7)

The idea is there, but the implementation is poor
First a word about The Reasoned Schemers soul-brother "The Little Schemer":
I read the Little Schemer from one end to the other, and I simply adored it. It taught me so much that I hadn't really grasped before, and it taught me how to program. I can't recommend The Little Schemer hight enough for persons who wants to know what programming is really about.

The Reasoned Schemer builds on the same idea, and I was therefor very eager to get started with it. Unfortunately, even though this book follows the same recipe as The Little Schemer, the actual implementation of this recipe is very poorly conducted. Where The Little Schemer was careful in its stepwise built-up of knowledge, making certain no assumptions were left unexplained, this book seems to have been written more hurriedly - the author seems to have forgotten to clear his mind for all the stuff that he finds obvious, but which the intended group of readers is in fact only just beginning to learn. I think the basic idea behind these books really has something going for it. Reading this book, I realize a good recipe also need a good cook and good preparation. The author of this book certainly is a good cook, but, it seems he badly neglected taking the time it takes, to think this book through.

Conclusively, I can in no way recommend this book. It is simply too poorly implemented.

Good introduction if you like the style
Fans of the "Little Books" (The Little Schemer - 4th Edition, The Seasoned Schemer) will find an interesting introduction to logic programming here. I found "The Reasoned Schemer" unique in that it has no preconceptions of logic programming being "special." It dives right into the subject! If you know some rudimentary Scheme or Lisp you will start "thinking logically" without even being introduced to old fashioned terms like "backtracking" or "cuts" (or, for over a hundred pages, even "unification").

Some readers might object to the books use of a coding style that is not executable Scheme. To my surprise I found the source format a great help to readability. Translating the text into executable Scheme code was effortless even though the book assumes that you will figure how to run the code for yourself (search engines and a little experimentation should quickly lead you to miniKanren). Probably the weakest part of the book is an overly long and tedious development of a system of arithmetic, but that example does demonstrate how far logic programs can go. I was somewhat alarmed by the incredibly terse implementation note at the end of the book. I'd be surprised if most readers would just "get" the implementation strategy.

While I enjoyed working through this book I had the nagging suspicion that it might not be the introduction to logic programming I would personally recommend. To check for an example I reopened my (unfortunately long neglected) copy ofParadigms of Artificial Intelligence Programming: Case Studies in Common Lisp. I have to conclude that Norvig's 18 year old chapter on Prolog still seems a more succinct and complete introduction. But then I'm tainted by having programmed in Prolog before, and I also have to consider that "AI" is so unhip today that few newly minted programmers would go pick up that old classic. So go ahead, get yourself a copy of The Reasoned Schemer.It is a book that no truly curious programmer will regret reading. Not even those that unify every day.

Interesthing ideas weird presentation
I must say that I was expecting lesson on building logical system that this book completely lacks fallowed with examples of using it. But this book is only about using the Kanren logical system that authors designed. There is no ebook version that's completely inconvenient I was so frustrated with holding the dead tree and typing that I finally scanned the whole thing to keep my hands on the keyboard. The code in the book can't be just typed and tried but you have to apply substitution rules of the author weird symbols in your head. For example succeed is written as #s in the book but you should type succeed. Or run must actually take another argument like (run #f (q)while the author insists on writing (run (q). Neither pseudo code neither working scheme.
Nowhere in the preface does authors mentions that I should download the source code [...] , BTW the implementation code is excellent, and some supported implementation in order to actually run the programs.
When you add everything I wouldn't buy this book if I knew all this but on the other hand I'm not inclined to ask for a refund.

Better go to the Source
I guess this book is OK, but it could really be written in all of about 5 to 10 pages of text with half a page of implementation code - in Haskell.

Main idea: use (potentially) infinite lists to represent (potentially) infinite streams of solutions to a problem. Have "goals" as procedures that work on (partial) solutions, producing new lists (empty/singleton/plural) of (more complete) solutions for each solution processed. Have a mechanism of combining these solutions streams. Now AND is just a sequential combinator and goal applicator; OR is a sequential combinator for parallel application; OR/i (for interleaving) combines its result streams in an interleaving fashion.

It suffices to have these combinators binary, because any type of COND is anyhow broken down to these binary combinations, as in a typical COND rewrite with IFs - and that's what the book itself does too, in a somewhat complex Scheme macro syntax. Expressed in Haskell, the intent is clear and the meaning is immediately obvious:

Sequential stream combination ("mplus" of the book):
(1) []++: ys= ys
(2)(x:xs) ++: ys= x:(xs ++: ys)

Alternating stream combination ("mplus/i"):
(3) []++/ ys= ys
(4)(x:xs) ++/ ys= x:(ys ++/ xs)

Sequential feed ("bind"):
(5) []>>: g= []
(6)(x:xs) >>: g= g x ++: (xs >>: g)

Alternating feed ("bind/i"):
(7) []>>/ g= []
(8)(x:xs) >>/ g= g x ++/ (xs >>/ g)

"OR" goal combination ("cond/e"):
(9)(f ||: g) x= f x ++: g x

"Alternating OR" goal combination ("cond/i"):
(10) (f ||/ g) x= f x ++/ g x

"AND" goal combination ("all"):
(11) (f &&: g) x= f x >>: g

"Alternating AND" goal combination ("all/i" of the book):
(12) (f &&/ g) x= f x >>/ g

That's about all there is to it. If you're unfamiliar with Haskell, it's a type-inferencing, auto-currying LISP with unparenthesised syntax where "f x" stands for functional application, "[]" stands for empty list, "x:xs" for cons cell (x . xs), and parentheses are used for grouping of expressions. It is non-strict, so lazy lists are used throughout, and _everything_ is a delayed lambda, calculated on "as-needed" basis. Having finally produced a stream of solutions, we rely on Haskell to only calculate as much of it as is actually requested by a user (usually one by one, as in Prolog), thus in effect performing depth-first search of a problem space.

It should be clear now that the actual nature of our solutions should be regarded quite apart from the mechanism of producing, combining and managing these infinite streams. Unification can then be viewed as just another "knowledge-enhancing" goal capable of rejecting the solution it's supplied with, by producing an empty list, or updating it, by producing a new list containing an updated solution(s). These solutions can be of any type, whether built-in or user-defined native Haskell type, and not just general symbolic structure capable of representing a kind of symbolic terms Prolog has, which is what's done in the book - where everything is represented through this symbolic structure, even numbers.

Implementing arithmetical relations on top of that is a standard exercise in hopeless inefficiency. The book wants to add logic programming capabilities to the existing Scheme system. Surely we don't have to reinvent numbers for this, and in such an incredibly inefficient way at that!

Instead of reusing blind structural unification of Prolog, the authors could discuss how it can be seen as creating equality constraints, then proceed to implement _them_ thus having truly added the relational capabilities ON TOP of the existing Scheme system, with its numeric functions working for us directly, hopefully.

If this book had THAT, THEN it would have been a great book.

Alas, no. The authors decided instead to stay at a fairly rudimental level, and be very verbose and inexplicit at the same time. And here I come to a point about their whole methodology in this as in their other books of this series, of presenting their material by examples only, making it unnecessarily obscure for a reader. It seems to me they've gone to the other extreme here from the pseudo-scientific type of dry presentation full of abstruse terminology. The golden path, as always, may lie somewhere in the middle - first presenting the material through examples and just playing with it (like they do here), but then proceeding to more precise formulation and discussion of the issues.

This book is long on promise, but short on clarity and depth.

fascinating and challenging
As the saying goes, if you like this sort of thing, this is the sort of thing you'll like.The authors have extended the approach of their classic book _The Little Schemer_ to encompass what is usually called logic programming, but which they refer to as "relational programming" (a much better name, in my opinion).They extend the Scheme language with relational analogues of many constructs, notably lambda and cond (in many, many variations), and also provide extended versions of standard Scheme operations like cons, car, and cdr.Basically, the relational approach involves taking the result of a function call and making it just another argument, but a special argument that can get assigned to as the result of the computation.Big deal, so what? you ask.The important thing is that _all_ of the function arguments behave this way, so that you can specify the result of a function (relation) and ask the system to generate the arguments.For instance, instead of saying 2 + 2 = X and figuring out what X is, you can say X + 2 = 4 and the system will figure out what X has to be (in this case... ummm... oh yeah, 2).To do this, the system uses a mechanism called "backtracking" which systematically tries alternatives until it either finds the answer, gives up, or (if you didn't program the search right) goes on forever.If you haven't seen this style of programming before, this book will definitely open your eyes.

The relational/logic programming style is usually learned by studying the Prolog language, which is how I learned it (though I'm no expert).Having a knowledge of Prolog will definitely make this book easier to understand, although the approach given here is more modern than Prolog in several ways.For one thing, the named relations of Prolog are replaced here by anonymous relations (analogous to lambda expressions being anonymous functions), and for another, the (somewhat brutal) "cut" operator of Prolog, which is used to control backtracking, is ignored in favor of more subtle approaches involving interleaving solutions and giving up after single results are found.

I think the approach of learning-by-pattern-recognition that all the "Little X" books use is fairly effective here, though I think a lot of readers (meaning me) wouldn't mind a more extended discussion of the mechanics of the system.

All in all, if you liked _The Little Schemer_ and are curious about new ways of programming, you should definitely pick up a copy of this book.It will stretch your mind like a Slinky, and when you're done you'll have learned a new way of looking at programming. ... Read more

Product Description

A most critical and important issue surrounding the design of automatic control systems with the successively increasing complexity is guaranteeing a high system performance over a wide operating range and meeting the requirements on system reliability and dependability. As one of the key technologies for the problem solutions, advanced fault detection and identification (FDI) technology is receiving considerable attention.

The objective of this book is to introduce basic model-based FDI schemes, advanced analysis and design algorithms and the needed mathematical and control theory tools at a level for graduate students and researchers as well as for engineers.