Distributed

Visual part makes the smalltalk easy and makes the life happy

I picked this up based on the reviews because they were all glowing. I would probably write a glowing review too, if I were a novice. There is a lot of opinion passed along in this book. Also, I am always leary of C++ programmers who write VB books (yet constantly remind you they are a C++ programmer). His information on ASP and Visual Interdev is a little whacked because he doesn't take into account scale adequately/correctly. He also says that a webclass scales up. To where? ASP scales to VB, but VB can only be rewritten in C++ to scale (and then the gains would be debatable). Any multi-server scaling can apply to ASP or VB equally. Visual Interdev is a fanatastic product saving hours of coding time but you won't get that here. The other red flag is when he sets up an ODBC driver to access his database, that is no longer necessary or even desirable. In fact he says you "must" set up a DSN, which is NOT true with ADO 2.1 and SQL Server 7. Use OLEDB whenever and whereever you can. I will work through the whole book for the learning experience but I will not treat this as "definitive." I would highly recommend looking around for some different perspectives before gold-plating my web development approach. The Microsoft MSDN site has a great example of a highly scalable VB web application that I would use as a free supplement to the information in this book.

When I started studying WebClasses (May 2001) I looked at a lot of different places, the web, training sites, magazines, and books. In my research, I read just about everyone of the reviews on this book and also on Wrox Press VB6 Web Programming. I bought both.

I don't need to repeat the drawbacks of this book that the other reviews already have mentioned. However, I do wish to emphasize one item that some one else brought out. This book is a mainly a teaching book. Not in the since of giving exact instructions (1. Do this. 2. Do that) as you would find in a high school/jr college class room (I've taught in both); however, it is useful if you need to teach yourself this technology and you don't have vast experience in the area.

I did experience problems because of some of the drawbacks misprints and such, but if I had looked at the author's web site, I would have found fixes for the ones I found and saved myself time and frustrastion.

Even with the drawbacks, my overall experience was positive. I now feel I understand what WebClasses are and how to use them. I'm no expert, of course. That only comes with practice.

If you are looking for a book to teach the information needed for WebClasses, this one is a good one. If you are looking for a more comprehensive approach that teaches you about all areas of VB on the web, look at Wrox Press's VB6 Web Programming.

I Found this book very easy to follow as Jesse explains webclasses by one big example. I miss some explaining about "extra special features", but this book is good if you want a quick start. Also look at the book "Visual Basic Developer's Guide to Asp and Iis" thoug.

For me to take the time to write a review, I must feel quite passionate (positively or negatively) about an issue. I'm trying to save you money and, even more so, your valuable time in not reading this weak book!

I SO DISLIKE THIS BOOK! I liken it to an HTML book that I bought in 1995 (that is now deep under some land fill). Like the HTML book, almost ALL of this EAI book's verbage is spent on extremely high level concepts and yields little in the way of concrete 'actionable information' that you can actually use. It spends time on the development of the author's own taxonomy of different types of EAI (data-level, app-level, UI-level... ad nauseum). If I saw any useful approaches or code in this book I certainly do not remember it.

IMO, if you want to architect, design, and !DO! EAI do not burn your time on this book. Find another source.

On the other hand, if you are of the type (prevalent in our industry today) who smile a lot, wear the right clothes, and speak with passion and authority on things you know nothing about, you will read this book, learn new buzz words, and write back with your own five-star review. Not me! I need to get things done without flapping my arms.

This book aims at a good target: explaining EAI to managers. To accomplish this task, the author needed full descriptions of the concepts and meaty examples to illustrate them. This book has neither.

For example, the author states several times that SAP needs a richer collection of APIs in order to connect to other application. Nowhere does he describe what is missing: what functionality is hard to access in SAP that should be easy?

Save your money.

Just getting going in this world and this book was my Bible. The book does a great job explaining this complex stuff from the very basics to the more sophisticated topics. I found the book to be exactly what I needed, albeit a bit pricy.

This book is more suitable for beginners that want an insight to the jargon-laden world of Java middleware.

CORBA is a powerful and complex method for distributed computing. This book does not go in depth into how to make use CORBA in practice. It gives a fairly shallow overview that frustratingly does not have much substance. It reminded me of an academic lecture I attended where I was positive that the lecturer did not have practical experience in the subject - and gave a theoretical discussion on the subject. This is fine as an introduction but frustrating if one wants to get over the theoretical summary of the concepts and work on what (and if) it works; and under what circumstances!

BUT this book is very useful to beginners that would like the 50K feet view first and then go elsewhere to drill for more information.

Another point to keep in mind is that this book was originally published in 1998 - some of the book's information is presently irrelevant. I am not sure if there was a reprint since 1998 but the information included is dated.

In conclusion, buy this book if you are a beginner and would like a reference guide.

Hope this is helpful!!

An exceptionally well-written book by best-selling authors. The book
is a great way to learn about Client/Server programming in general, and
CORBA in particular. This book is massive, totaling over 1000 pages
(a huge increase over the first edition). It includes a CDROM with all of the
code examples as well Borland's Vivibroker and others.

Note the book is not just about teaching CORBA programming using
the Java language. It also provides large amounts of material on Java Beans and

Enterprise Java Beans. This is a teaching book not a reference book.
While it does provide Java coding examples, developers will not use it
to write their code (at least I don't).

Book Sections:
1- CORBA Meets Java (3 chapters)
2- Core CORBA/Java (3 chapters)
3- The Dynamic CORBA (3 chapters)
4- CORBA and Its Competitors (7 chapters)
5- The Existential CORBA (6 chapters)
6- JDBC 2-Tier Versus 3-Tier (4 chapters)
7- From JavaBeans to EnterpriseJavaBeans (8 chapters)
8- Grand Finale: Club Med with CORBA/JavaBeans (4 chapters)

The CORBA coverage is extensive: BOA, POA, Interface Repository, Java-to-IDL and
IDL-to-Java mappings, and DII among others. However, no coverage of the CORBA Services,
besides the Naming Service.

Be prepared for their style of writing. As with their other best-selling books,
they have Zog the Martian (see the cover) and Soapboxes, which give their insightful opinions on
issues and problems with the subject. Personally, I enjoyed it as it makes the
book more interesting.

Some Negatives. This book has become somewhat outdated, written in 1998,
with an intro by Marc Andreesen and a CDROM containing JDK 1.1! There are better
books on Enterprise Java Beans. A new edition of this book could be thinner
by reducing the EJB material. Its missing coverage of the new CORBA Component Model
(of course, CCM was not out in 1998).

In summary, I highly recommend this book for readers wanting to learn Client/Server

programming and CORBA (using Java). I bought many copies of this book over the years
for training people at my company.

This is an excellent book for learning and applying CORBA from a Java environment. It is loaded with examples and is pretty well indexed. I have been able to find just about everything I wanted related to CORBA programming. It's focus is programming. In addition, it does an excellent job of comparing and contrasting alternative technologies (e.g., DCOM, HTTP/CGI, RMI, Sockets/RPC) and implementations (e.g., JavaIDL, VisiBroker, some Orbix, Applets). It has nice tables of capabilities and performance metrics to summarize the various comparison sections. It does not cover any details of the underlying protocol, etc. The last half of this 1000-page book is devoted to three-tier implementations, Java Beans, CORBA beans, and Enterprise Java Beans -- excellent coverage of an important topic, but better split into a second book if only to help make the index less cluttered.

This book lacks depth on the following Exam topics: RDO, IIS, DHTML and Active X Documents. It does a pretty good job on MTS. The labs are good. The sample test is not good. Use this book in conjunction with another study guide, such as the Exam Cram book.

The practice exam on the cd was terrible and some sections are a bit patchy. If you buy the equivalent book for 70-175 you'll find that about 60% of this book is duplicated in that book. However, this book was my only resource and I passed the exam with just over 780. I think I could have done much better had I bought transcender.

This book helps those who want to pass the exam and also makes you ready for real world programming. With clarity and brevity the book guides you through the complex concept of classes in visual basic. Equiped with the understanding of classes the book takes you further to activeX components and tells more information in the labs and examples. ADO and how it is used in connection with SQL server is well covered with the two chapters of Advanced Database Topics and Stored procedures. Best of all, the Microsoft Transaction server is demystified with a good explanations and an associated lab. If you are looking for a book that is readable, interactive and direct to what matters in the exam with an eye to real world scenarios then this book is for you.

I bought this book because of other customers' review. This book failed my expectation by two reasons. First, the book does not explain anything in detail such that you understand it. You just know only the existence of the technologies described in the book. But if you want to use them for your projects, you still need to find deeper information from somewhere else, or figure them out by yourself. I really hate this especially when the author said something like "you now have a solid understanding of...." after he explained about something in just only 1-2 pages. Second, the author makes half of this book like a misc java book. Instead of concentrating on the topic (distributed technologies), you will find so many chapters describing general concepts of java in this book, which are not related to what you really want to get from this book. Anyway, the author from place to place slips in his comments to convince you that what you are reading really relates to distributed technology somehow. I don't want to say much more than this. Seeing is believing!

I am still reading Java Distributed Objects as I write this note. I actually got it 3 days ago as I take a graduate course in Java for Distributed Programming and felt overwhelmed in this course.

I haven't left the book since I got it and it already cleared a lot of subjects that I am wrestling with for several months.

I love this book and appreciate immensely the authors' great contribution to me.

I never wrote an evaluation on a book, as one never has the time to use this form of saying thank you. Thanking that one made such effort to contribute to you, usually for a price of dinner or less. I decided to make an exception this time.

So why I am I throwing an exception now?

Before I bought the book I looked at it briefly at the bookstore and thought that it will be helpful. Than I got on line and read a very negative review by one reader. I almost didn't buy the book as it was so negative and that would have been a huge loss for me as the book really pooled up from a very frustrating sense of being completely overwhelmed by the subject. I am not sure what motivated the other reader to be so negative. I usually feel a lot of respect to an author who goes through the immense birthing pains to produce a book that intends to contribute to others. Yeah he gets paid some but I can hardly envision anybody retiring from one of these tech books.

So for what ever it worth. I thank these authors for producing this book. It helps me a lot and I appreciate it!

Ted I Weitz MD Cambridge MA (No, I do not work for SAMS do not know the authors or even knows where they are.)

Dazling ! Very good in explaining advanced topics. Although a thick book, the writing style makes the reading of this book a very pleasant and interesting journey from begin to end. It describes in enough detail distributed architectures, from low level sockets to servlets, RMI, CORBA. I read it with great pleasure and I'd recommend it to anyone interested in distributed computing.

This book claims to cover the complex process of component based distributed computing with Enterprise JavaBeans.I started off with it,thinking that it would provide me with the substance I need to for beginning with my professional level applications using EJB.However,I was greatly disappointed as the book never provided me with any details of what goes into building enterprise level applications using EJB.All the stuff was too elementary and seemed to be a rehash of the EJB specifications.The examples are rare and it seems the author himself is confused about a few things.I would suggest to anybody serious about development with EJB,read the book by Ed Roman.

This is a delightfully lucid introduction to Enterprise Java Beans. Unfortunately, it was published in 1999 and is a lucid introduction to EJB version 1.1, not the more current 2.0. Let's hope Mr. Valesky has a new edition in the works! Also, it is a relatively brief introduction, not a comprehensive how-to manual, so many of the necessary but mind-numbing details are left out. Nevertheless, the book would be useful as a conceptual introduction, perhaps to be followed by something meatier.

This book is the first devoted exclusively to helping front-line developers implement application components with Enterprise JavaBeans technology. In it, you'll find guidelines on many of the issues that developers face in getting started in developing EJB components. It's a simple, step by step introduction to using the Enterprise JavaBeans technology, explaining both its background and how to use it develop real-world applications. This book presents a sequence of easy to follow discussions, with complete code examples, troubleshooting techniques, and even application design guidelines. All of these are written from the point of view of a hands-on developer with years of experience in writing and deploying enterprise applications.

A very frustrating book, because I actually want to like it, but can't. In many ways, it's actually quite a good introductory text, the explanations are mostly clear, and it's fairly well paced.

BUT
The editorial staff as SAMS need a good spanking!
-------------------------------------------------

The book is strewn with errors and typos, and I'm not just talking about spelling errors here (although there are many)

A few examples:

1.; The class diagrams in chapter 5 are simply empty boxes with lines connecting them, somewhere along the way, the text in the boxes got lost. It's impossible to follow the example without the diagrams.

2. Each chapter has Quiz questions, and answers are found in an appendix. Problem is, some of the answers are to different questions! It appears that at some stage the questions got changed, and the answers weren't updated.

3. In the discussion of strings, the sample code that purports to show how to declare a fixed-length string, actually declares an array of variable length strings.

In spite of my annoyance at this kind of error, I've given the book 2 stars, because there's a lot to like about other aspects of the book. If they come out with a second edition which fixes the errors, it would be well worth buying.

This is actually not a bad introductory text. The author has put in quite a reasonable effort to explain CORBA but unfortunately I don't think anybody can do it in 14 days. A lot of the details as to how CORBA actually works and a lot of its components are missing but I guess you could always use this book as a starting point and get the details from more advanced texts.

Also the bank example is really (IMO) unnecessarily complicated. It would have been better just to use simple examples where the focus would have been more on CORBA rather than getting some huge system to function. Also, I actually found a bug or two in the code when trying to compile it. Speaking of compiling it, the author made no attempt to explain how to do compile it. I had to do my own research as to how to build the whole thing using MSVC++. Now I don't mind doing research and debugging code but if I was a novice programmer, I would probably have given up on the book by the first example. And lastly, because the example was unnecessarily complicated as I mentioned, a lot of the book was filled with unending source code listings.

In summary, a good introductory books as I said but with some definite shortcomings.

I had high hopes for this book. It's very readable and pitches at a good level, somewhere between impatient pro and interested amateur. It's taken a lot more than 14 days though, with chapter 6 requiring you to type in and debug c. 1200 lines of C++ code.

Also, although the text claims to be compatible with Visibroker, it isn't directly compatible with version 4.0, which uses POA instead of BOA. You can get backward compatibility with a combination of IDL compiler switches and options passed to the ORB on start up, but expect significant digging in the Visibroker manuals to get to this point.

To use one of the other ORBs listed in the book, which the author achnowledges will need hacks to the code, would be difficult, unless you were already CORBA literate. But then, why are you here?

There are also significant annoying typos. The book needs a new edition (IMHO), with POA, and distribution with a CD containing the examples and an open source ORB like TAO.

I learned a lot from this book, but with a significant amount of frustration at trying to get the examples to work.

I bought this book for its coverage on RMI. When comparing similar books at the bookstore I simply bought the book with the most pages of coverage for RMI. Well, I made a terrible choice. I've read and reread the coverage of RMI in this book. It IS frought with errors and the coverage of the topic is shallow. Examples are presented without sufficient explanation (besides containing errors). If you want to learn RMI, PLEASE STAY AWAY FROM THIS BOOK!

I bought two books at the same time when I start to learn rmi. One is this book, another one is "java.rmi Guide".
Before I start, the second one seems more attractive as its name implies,so I decided to use "java.rmi Guide" as the main book, use the Distributed programming with Java only as a reference, but when I start learning, I read the "java.rmi Guide", I was totally lost, the book full of concepts with few examples.
So finally, I spent most of my time on "Distributed programming in Java" because this book not only explains the concepts very clearly, but also gives out many good examples. At least, when I read it and run the codes in this book, I know what I am doing and why.
As some readers suggested: maybe the java.rmi Guide is good for experienced, but not for beginners.
For beginners who want to learn RMI and CORBA, "Distributed Programming with Java" is the most appropiate book for them.

I have been looking for a good book to learn sockets programming. I saw this book @ BN and I liked the stuff on sockets. I bought it and I have enjoyed the chapters on sockets programming -- cool stuff with lots of sample examples. There are some minor errors here and there but it was worth the money.

In an effort to be on the market early with information about MTS 2.0, the team that produced this book did so apparently without checking whether or not the cd-rom support files and directories referenced in the text are actually contained on the cd-rom. If that were the only problem, that would be a mere annoyance, but they also provide innaccurate information about the product's capabilities (e.g., page 12: "MTS does not currently support object pooling...").
Information changes rapidly in the world of programming. That would be no problem if there were actually some source for missing files and/or errata on the internet. There aren't. Go to the website mentioned in the book - it throws you onto MacMillan's site, which tells you nothing about this book but Title, Author(s), and Price. Call the tech support number listed in the book? Try it: no one will answer. Good luck!
It is hard to understand how someone could be intelligent enough to figure out Microsoft Transaction Server, business objects, and SQL server, and not be able to use the search and replace capabilities supplied with almost all word processors and text editors to check their references to names of files and directories.

A good overview and introduction to MTS 2.0 The sample application provides some 'practical' content, to augment the general discussion of MTS. This book provides a good foundation, and better introduction, to understanding the official documentation.

I don't know how this book got only a rating of 2.5. This is one of the best book on the market on MTS/n-tier app development. I don't thing anyone else could write a better book on this subject. Eventhough it is little outdated with the arrival of Win2K and COM EXPLORER you could still get a wealth of information.