Customer Reviews

Sams Teach Yourself CORBA in 14 Days

5 star:		(5)
4 star:		(8)
3 star:		(6)
2 star:		(3)
1 star:		(3)

 

 

A simple fact about something as complex as CORBA - no one book can satisfy every kind of roles or levels. Most books try to cover from bottom to top and become too complicated and too expensive for beginner or, too simple and general for advanced user.

This book has achieved its purpose very well ie for an absolute beginner to CORBA but experienced in application development. The price is great too as it is not a reference that we want to keep when we become familiar with CORBA. The presentation is very good, simple and organised, no showing off of big words.

I find it useful for both developers and architects. However, as most of its examples require code reading to understanding, it is more suitable for a competent DEVELOPER (ie not just programmer) of either Java/C++. A sound OO background will definite help.

The 14 days schedule is suitable for IT professionals that read it in their own time. For full time study, 7 days is more than enough.

The Q/A and Quiz at the end of each chapter. provide a good structured revision for someone like me who lack of discipline to revise after reading.

As a beginner CORBA programmer I found this book to be written in a very easy-to-follow manner. There are a lot of clear and concise explanations of topics that most other CORBA books assume you already know.

What's Good: Clear examples and some excellent background on the CORBA architecture. Starts at a comfortable beginner level, unlike many other CORBA books.

What's Not So Good: The book was written with too broad of a programming audience in mind. There are a great many paragraphs that run on and on going something like this: "if you are a C programmer then this is like Such and Such; if you are a PASCAL programmer then this is like This and That..." and so on. This proves very tedious for programmers without a wide programming background. Also, the Introduction to the book was what played a large part in my purchasing the title as it claims that the book was for people with some programming experience, namely Java or C++. Further along it states that a lot of the code in the text is C++ but contains "a healthy dose of Java for good measure". In reality the entire middle third of the book's lessons are illustrated with examples written entirely in C++, which didn't do me a lot of good, being a straight Java programmer. Because of this I missed out on a lot of important lesson points and hands-on coding.

Bottom line: If you have C++ and Java experience then I think this is one of the first CORBA books you should buy. If your focus is Java, I would highly recommend "Client/Server Programming with Java and CORBA 2nd edition" by Orfali and Harkey; and "Programming With Visibroker : A Developer's Guide to Visibroker for Java" by Doug Pedrick (Editor), Jonathan Weedon, Jon Goldberg, Erik Bleifield, Eric Bleifield.

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.

If you are proficient C++/Java programer and have delved into the world of distributed computing in its many various forms (COM+/CORBA/EJB) and are familiar with UML, then this book will be easy to follow. As a technical architect I covered most of the material in three days and found it to be excellent as a refresher course on CORBA. The author does a good job on class design and laying out the code but getting the examples to work can prove quite daunting if this all new to you. For one Rosenberg should have used the freely available OmniORB instead of using Visigenic which you have to pay for (this would be an advisable approach for a later edition and for students if they ever use this book for a class). Another criticism i had was his use of Visual Cafe to design the GUI for Chapter 14. Please always take the least common denominator .. simply use the JDK and Swing to do all this stuff .. developers can always learn IDEs in their own spare time. Apart from that his Banking Application is an excellent realworld example of how you can put CORBA to work behind the scenes and chapter 14 is by far the best when you webify the entire application with a simple java GUI applet and all the CORBA business objects working together under the hood.

Beginners to CORBA should read the examples throughly and understand the code fully before delving into the examples. Then you can use the OmniORB to do all the CORBA plumbing - stick with it and when you get it all working it will be rewarding. I can sympathise somewhat with some of the previous comments on the examples in the book. And where is the CD? I never got one with my edition.

COM & CORBA - Side by Side is also an excellent resource to use as a supplement to this book.

BTW -> OmniOrb is available at: http://www.uk.research.att.com/omniORB

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.

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 isn't a bad introduction to CORBA, but it could be much better. To start with, having examples in both Java and C++ makes understanding difficult if you only know one of these langauages. Secondly, as other reviewers have commented, day 6 is very hard to understand (whereas some other days, e.g. 1, 5 and 7) are really easy reads.)

There are still many good things about this book. IDL is very well covered, and the format of each "day" (intro/ text body / summmary / Q & A / exccercises) is excellent for self-teaching.

I'm reasonably experienced in C++ and Java and just recently started to learn the CORBA and DCOM technologies. Most books I found so far on either topics lack the capability to communicate the fundamentals quickly and clearly to get the poor reader started running codes early without being overwhelmed by all the architectural wonder. This book is a surprizing exception. It touches on the basics concisely, explains the IDL building blocks, and immediately shows the reader simple but working examples to see what exactly is going on ! It is also quite nice to include both C++ and Java examples, which are fully implemented and very well self-documented. For someone who really needs to learn CORBA in the shortest amount of time, this book is a great help. After finishing it, you probably only need one CORBA reference or some particular ORB vendor's manuals to start your real work in CORBA. I only wish that someone could write a similarly clear, short and useful book on DCOM...

Like George Reese's jdbc book, better for impressing than conveying. Endless pages of code and very little expanation. To be avoided.

I like many other reviewers had trouble getting the examples to work. I'm just glad I found the book for free online and didn't waste any money on it. I'm going to try Pure Corba next, wish me luck.