Fundamental-Information

I have gone through this book and I did not like it. Look's
like Michi's book is the best so far.

This book is clearly a reference, and research material rather than a hands-on programming guide. While there are many code fragments to support the authors' explanation of concepts, and the largest single chapter is on CORBA programming there is no single project built throughout the book as is often the case in programming guides. I much prefer this approach of being a reference rather than building a project. For example, code or diagrams illustrate things such as SII, DII, DSI, IFR, Exceptions and Any, which gives a competent programmer enough to experiment with the various bits of CORBA. For implementation using BOA, some good diagrams show implementation option using the TIE approach, handy for Java, which has single inheritance. It would be useful though to have some code fragments of a POA implementation in this section.

The book has three parts. The first part covers the basic foundation concepts of distributed computing showing how different distributed technologies (eg RMI, DCOM, RPC) need to find solutions to the same issues.

Parts 2 and 3 give an in-depth look at distributed systems and CORBA with much to study. The role of object adaptors is explained and the POA architecture is compared to the better-known BOA. This is well diagrammed, again some POA code would help. This is where the book becomes more than a programming book and a serious study of CORBA features, such as Naming Service, Trading Service, Event Service and Query Service. Additionally there is a detailed discussion of performance and consistency issues with a CORBA Caching implementation. This for me was the most interesting part of the book. Object caching in a distributed environment gives you much to think about, and clearly much thought has been put into the issues, such as scalability, cache consistency, object eviction etc. Other issues such as distributed transaction services including 2PC and 3PC are well covered.

Detailed discussion of CORBA services and distributed systems is not trivial reading, but rather for serious study. I notice that Douglas Schmidt has written the foreword. His name is well known to anyone that reads CORBA research material, which gives confidence to the quality of material.

In Summary, this is not a simple programming book. There is no downloadable code or CD and apart from some early OrbixWeb examples is not specific to any ORB implementation. It is a serious look at issues of distributed object systems with a heavy emphasis on CORBA and would be recommended for anyone interested in further study of distributed object systems. There are exercises at the end of each chapter, but there are no answers found in the book, it would be helpful to have them available in a later version of the book or on a web site.

I am pleased to find a book on distributed objects systems. this book has given me the needed information that i have been looking for in the field of transaction processing systems. it does cover CORBA to a great level given the reader the chance to see some solutions and the independency of programming languages. i believe it can be used as a text book in the field of Object-Oriented Design or programming where students can aplly either JAVA or C++.

This "textbook" has very few and skimpy examples of
how to work problems.
It also has a solution book which is not available to
students!!!
Therefore, the student cannot check his/her answers to
the review exercises at the end of the chapters!! Huh???
I can't believe that any school or instructor would choose this
this as a textbook or even as an additional reference!!!

I'm currently using this book for a Digital Design class and I have yet to be impressed. Though this book has lots of useful information it phrases it in such a way that you have to be a rocket scientist to understand it. As for the VHDL you're supposed to be learning from this book it stinks. I work the problems at the end of the chapters for practice and constantly have problems finding the answers in the text or finding example VHDL code that is relavent to the problem I'm trying to answer. In short I do not recommend this book.

This book does an excellent job of covering the basics of digital logic circuits and chips, and a solid job of covering VHDL design. While some "newer" topics are not covered, that does not hinder this book, as it aims provide a fundamental understanding of Digital components and circuits, and VHDL.

I've struggled to read this text, since it contains many very recent results distilled into intelligently organized chapters. Unfortunately, even though this book is intended for a savvy audience, the text is often too detailed and technical, while important "big picture" intuition is never relayed. Frequent errors in the algorithms and proofs, ranging from simple subscript swaps to more subtle errors in logic to the (rarer) complete lack of logic make this a difficult book to recommend. In addition, the exercises are frequently too vague (sometimes meaningless) -- this book is definitely not recommended for class work.

I used this book for teaching an under-graduate primer course in distributed computing. The book is readable, coherent, well-structured and very efficient as a textbook. It strikes a good balance between the sea of details and the basic principles. I am familiar with the core of this book since it was a collection of lecture notes (alas, no longer available). It's a pity that some important topics have been omitted from the book version (e.g., Gallager, Humblett, Spira alg). There are some minor errors and imperfections in pseudocodes and exercise definitions which are a little bit annoying. That's why I'm giving this book four points and not five. Bottom line: I would recommend this book as a course textbook.

This book has an amazing amount of content. Very few data structures books contain quite as many structures as this one; In addition to containing all the common data structures one usually studies, people can also study Splay Trees, Compressed Tries, Patricia, Fibonacci Heaps...really the list keeps going. The only things that it seems to be missing are skip lists and multidimensional range trees...

Most data structures have rigorous (college-level-worthy) proofs for complexity and performance. These proofs are typically required of a student in a graduate level course, and thus, this book could be used for a graduate-level text. Because of this however, some may find this book a little daunting, especially if you just need an introduction to the topic.

The C++ code samples use templates so that the data structures can be generalized and used for any type. Therefore, the C++ code is very reusable. However, the code can sometimes be a bit hard to understand, mostly due to short variable names, and poor in-code comments. This is one of the reasons I didn't give this book 5 stars. Overall though, this book stands out in the crowd.

An excellent book for a student who has a fundamental knowledge of programming in C/C++ and Mathematics as well. The font of printing needs to be enlarged a little bit.

You need some programming experience or basic knowledge on data structures before come to this book. If you do have, you will find it is a very good book: very concise, clearly illustrating,and covering many topics you would really like to know. Don't be too picky if you really want to learn something. Try to understand what the author wants to talk about, think about what he was thinking while writing here. It is the way to get thru some language problem.

Don't waste your money (and time) on that ancient book.

It's shame to offer a 70's book for regular sale! Although it reprinted again in 94, its content remain.

It is a very usefull book for an computer engineer.If you are in a first class of computer engineer you can have some difficulties about using the mathematical formulas in computer.This book makes you learn yery easy.It is for a starter.

The level of the language in this book makes it hard to follow and understand. It covers too many topics in AI, and has few useful examples. The subjects covered are mainly Reasoning wiht Logic, Natural Language Processing, and Solving Problems by Search Ttrees/State Space. The interesting parts seem too short and are not detailed enough, the less interesting parts seem too long and difficult to understand.

My advice is buy a book that covers the area of AI you're interrested in. This one looks more like a PhD thesis. I think the only reason our AI teacher made us buy this book is because he is the author.

This book should really be called "Automating Windows Media Applications using Visual Basic", because this topic forms the majority of the content. Unfortunately, automation isn't really what most serious Windows Media developers, myself included, are interested in or need information on.

The core technology behind all Windows Media programming is called the Windows Media Format SDK: it is this library that powers all encoding applications including the Windows Media Encoder, Windows Media Services, Windows Media Player, parts of DirectShow, and manipulation of Windows media files themselves. Getting to grips with this vast library and its complexities is the real task facing professional developers on this platform. Unfortunately this doesn't get much more than cursory mention in the first chapter.

The bulk of the book concentrates primarily on automating Windows Media Encoder (using the Encoder SDK), a small, higher-level subset of Windows Media functionality. I can't honestly see why you'd want to write a Visual Basic application that uses the Encoder SDK as the Windows Media Encoder application itself is already up to the job. There is also a section on Windows Media Player, but again this focusses on higher-level automation and "skinning" of the player rather than looking at how you might receive Windows Media streams directly into your own application.

In addtion to all this, the author's decision to concentrate solely on Visual Basic, even though most "automation" developers have switched to .NET by now, and more serious Windows Media developers are confined to C++, diminishes the usefulness of this book even further. The book feels more like an extended magazine article rather than a serious reference book, and I could only really recommend it to Visual Basic hobbyists who are fiddling with Windows Media technology for fun.

Receiving this was such a shame, especially as the publication that accompainied it in my order was the excellent "Windows Media Resource Kit", which is an essential for any Windows Media professional, developer and administrator alike.