Customer Reviews

Client/Server Programming with Java and CORBA, 2nd Edition

5 star:		(23)
4 star:		(12)
3 star:		(8)
2 star:		(6)
1 star:		(7)

 

 

This book is a huge book, but CORBA is not the main theme of this book: it is Client Server with Java. It covers rich themes from socket, servlet, RMI, JavaBeans, Enterprise JavaBeans, and DCOM.

If you look for an introductory book on CORBA programming, this book is not the one. You will be confused by its coverage on non-CORBA technologies. If you look for an advanced CORBA book (like Michi Henning's in C++), surely this is not the one either.Because IDL-Java mapping,Implementation Repository, Object Adapter (BOA or POA), CORBA services is not covered very well. The only CORBA service that is covered well is Naming Service(of course). Trading Service is covered, however no sufficient code examples. However if you would like to have a roadmap where CORBA is, how it relates to EJB, COM/DCOM, socket, RMI, this might be your book.

I am still keeping this book on my shelf though because of its very good coverage on JavaBeans, not because of its CORBA coverage.

I am still searching CORBA-Java book with the same quality as Michi Henning's book on Corba-C++.

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!!

I found this book to be a very helpful tutorial-style book on CORBA for beginners. Although some may argue about the wide scope of this staggeringly huge and complete volume, I thought that the chapters are justified and very helpful. For example, the book includes in-depth chapters on how CORBA compares to servlets, CGI, sockets, RMI, and DCOM. The chapters are very thorough and the same program is rewritten for each technology to allow you a clear perspective upon which to compare. In addition, the chapters on JavaBeans and JDBC are also top notch, written in a very personable tone that makes it enjoyable to read.

I have gotten a great deal of valuable CORBA knowlege from this book and I would highly recommend it to any intermediate Java programmer who is looking to learn CORBA and willing to put some serious time into doing it.

This great book has a misleading title - don't buy it if you just want to write Java/Corba C/S application, it'll confuse you ! Like most readers I will agree that the authors have done a *great* job in comparing and contrasting in huge depth all the modern distributed computing related platforms and technologies. I wont disagree or repeat other people's opinions about the merits of this book, so I' ll jump to what I did not like (and gave it 3 stars):

- The organisation of the book is not very consistent. At times the book goes into great detail explaining a particular aspect (which is good) and then you find the same material mixed in other chapters explained in the same depth again ! Clearly when this is many pages long is wasting not only paper but your time reading through as well, it could simply be referenced, and the book could be at least 200 pages less. I found the book very interesting but also hard to read and follow.

- The book is a perhaps too theoretical at times. Perhaps this is of interest of ORB developers but not ORB users (application programmers). For instance the book is diving into ORB & POA policies details, explaining exactly what is happening behind the scenes. This might be of interest to very experienced programmers or ORB implementers, but not people who just want some subtle methods of writing C/S programs with CORBA/Java.

- I am sure the in-depth comparison of the technologies a) Has made Micro$oft sad of DCOM (cruel people) and Sun shine drinking coffee. b) Will be THE reference book for managers who make serious decisions about multi-million project investments & perhaps Academics who all wish to compare, compare and compare....

...but is this your interest ? Or do you just simply want to understand CORBA working 2gether with Java in the context of 3-tier Client server apps and start programming ?

If the title of the book was something like "ADVANCED Client/Server TECHNIQUES & ISSUES of Java & CORBA, with an in depth comparison of other existing & emerging modern distributed architectures.", I would have rate it differently.

I bought this book because believing it is in the same way and style as the client/server book. And I found what I expected: organized information, many examples, comparison of every technology with the other, and good humour.

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 definitely the best stuff around for all CORBA lovers.The book is detailed and goes step by step.A reader who is already well aquainted with OO techniques,RMI,Java and C++ will find a few chapters a bit boring.This is one piece of work which gives self-starters a chance to start programming using the CORBA architecture.The comparisions between different clients & servers breaks quite a few notions about C++ clients and Java Servers.The undermined Java Application receives a boost with such a comparision. Further on, The different approaches to using CORBA and explaining them in depth is one of the achievements of this book.A good round up of various ORBs, Transcation Monitors is also well appreciated.

I used this book primarily to investigate how to use Corba, independent of whether I wanted to use Java. I ended up using Java, but I never got around to using Corba. This book was very helpful in weighing the different technology options available to me. I used it to learn Java RMI, which is related to Corba. I use that as an illustration to show how this book covered competing technologies well, so you can pick which technology is best for you. This most helpful. When learning and picking technologies I come in with a whatever-works approach. This book is aligned with that philosophy. If you are thinking about using Corba or something similar, esp. with Java, I would buy this book in a heartbeat. It comes in handy as good reference.

You may think because of the book's title, that this will teach you programming client/server.It won't.If they would call it 'proof and compare client/server programming and architectures' I would give it 5 stars. It also might be confusing if you aren't familier with this things, because there is now explanetion about the code ,so you must have written some client/server if you going to buy this book.

I'm half way through the book, and I feel like shoving knitting needles in my eyes.

1) The examples are riddled with errors. For example, page 180 defines SVCnameroot to be CorbaJava on one line, and JavaCorba 3 lines later. Since the purpose of this setting hasn't really been defined yet, I blindly typed away, and wasted time until I noticed the difference. This occurs other places as well. On the same page, CountMultiClient is started without any settings. In the same chapter example code is repeated with improper headings. And although idl format has barely been described, two sections of idl are given pages apart, with no mention that it should go in the same source file.

2) The intergallactic web theme is getting really annoying.

3) It should be mentioned that no one in their right mind would use java, with its huge start up overhead, to write CGI code. This should be mentioned, and perhaps the stats for the same program in Perl should be given.

4) A little more information on what the command line settings mean should be given earlier in the text.