Advanced CORBA® Programming with C++ (Addison-Wesley Professional Computing Series)

Editorial Reviews. leondumoulin.nl Review. Written for the experienced C++ developer facing leondumoulin.nl: Advanced CORBA Programming with C++: Adv Corba Prog w/C++_p (Addison-Wesley Professional Computing Series) eBook: Michi.
Table of contents

Click below for Sample Chapter s related to this title: One of the most frequently asked questions in our courses is, ''Where can I find a book that covers all this? Or, more bluntly, books focusing on high-level concepts are of little use when you must find out why your program is dumping core. However, none of them really meets the needs of a programmer who must get the code to work and preferably by yesterday. And, of course, we wrote it so that we would have a good answer for our students.

Writing such a book is a tall order. However, knowing the various APIs will not, by itself, make you a competent programmer only a knowledgeable one.

CORBA

To be competent, you need not only knowledge of the mechanics of the platform but also an understanding of how the different features interact. You must combine them effectively to end up with an application that performs and scales well and is maintainable, extensible, portable, and deployable.

Advanced CORBA® Programming with C++

To help you become competent as opposed to merely knowledgeable , we go beyond the basics in a number of ways. For one thing, we provide advice as to what we consider good and bad design, and we make no attempt to hide problems with CORBA which, like any other complex software system, has its share of wrinkles.

Even though you can use an ORB without knowing what goes on under the hood, it is useful to understand these mechanisms because they have a profound influence on how well or how poorly an application will perform. Third, we devote considerable space to a discussion of the merits of various design decisions; typically, when a design provides a gain in one area it also involves a loss in another.

Understanding these trade-offs is crucial to building successful applications. And fourth, where appropriate, we make recommendations so that you are not left without guidance. Inevitably, our approach required us to make value judgments, and, just as inevitably, a number of people will disagree with at least some of the recommendations we make. Whether you agree or disagree with us, you should still profit from our approach: Either way, you are better off than you would be with a book that just dumps the facts on you without providing the deeper insight required to use them.

Prerequisites This book is not a beginner's book, in the sense that we do not devote much space to explaining the structure of the OMG or the pecification adoption process. We also do not provide a high-level overview of the architectural goals of CORBA or all its services and facilities see 31 for a high-level overview.

Despite the lack of overview material, you should be able to follow the material even if you have never seen CORBA before. If you have experience in network programming or have used another RPC platform, you will find it easy to pick things up as you go. If you understand inheritance, virtual functions, operator overloading, and templates not necessarily in intricate detail , you will have no problems.

We have limited ourselves to very simple uses of this library, so you should be able to understand the source code even if you have never seen STL code before. If you have never written threaded code, you will find the chapter on writing threaded servers tough going. Unfortunately, there was not enough room to provide an introduction to programming with threads. However, the Bibliography lists a number of excellent books on the topic. Despite our best efforts to show realistic and working source code, we had to make a number of compromises to keep code examples understandable and of manageable size.

When we demonstrate a particular feature, we often use straightline code, whereas in a realistic application the code would better be encapsulated in a class or helper function. We have also minimized error handling to avoid obscuring the flow of control with lots of exception handlers.

We chose this approach for didactic purposes; it does not imply that the code pretends to reflect best possible engineering practice. The Bibliography lists a number of excellent books that cover source code design in great detail. As a result, available ORB implementations conform to different revision levels of the specification.

Throughout the text, we indicate new features that may not yet be available in your ORB implementation; this allows you to restrict yourself to an earlier feature set for maximum portability. Despite its size, our main regret is that this book is too short. Fortunately, the vast majority of applications do not need those features, so dropping these chapters is not much of a loss. If your application happens to require the dynamic interfaces, the background we provide here will enable you to easily pick up what you need from the CORBA specification.

We chose not to cover OBV because it is too new for anyone to have any substantial engineering experience with it. In addition, at the time of writing, there are still a number of technical wrinkles to be ironed out and we expect the OBV specification to undergo further changes before it settles down. For example, we did not cover the Transaction Service or Security Service because each of them would require a book of its own.

Rather than being complete, we have restricted ourselves to those services that are most essential for building applications: We cover those services in more detail than any other publication we are aware of. The POA provides the server-side source code portability that was missing from the now deprecated Basic Object Adapter. The POA also provides a number of features that are essential for building high-performance and scalable applications. We have therefore paid particular attention to showing you how to use the POA effectively in your designs.

We have arranged the material so that you can use the book both as a tutorial and as a reference. Our hope is that after the first reading, you will have this book open at your side when you are sitting at your terminal. If so, we will have achieved our goal of creating a book that is used by real engineers to build real applications.

Acknowledgments As with any book, the authors are only part of the story, and this is the place to thank the large number of people who have contributed to making this book possible. At Addison Wesley Longman, Mike Hendrickson and our editor, Deborah Lafferty, believed us when we told them that this book needed to be written. Without their faith in us, you would not be reading this. Brian Kernighan reviewed several drafts and made us redo the job where necessary. His clarity of thought and critical eye have greatly improved this book.

John Fuller and Genevieve Rajewski, our production editors, put up with all our naive questions and enabled two amateurs to take a book to camera-ready stage. Our copy editor, Betsy Hardinger, edited every page in this book with meticulous attention to detail. Her efforts taught us more about clarity of style than we thought possible. They read the entire manu script and spotted many problems that would have otherwise gone unnoticed.

Best Value Purchase

Their comments kept us honest throughout. Alan Shalloway reviewed the book from the perspective of a newcomer and made valuable suggestions on how to improve the presentation of some of the more difficult topics. Their generosity provided us with the opportunity to make sure that our examples were correct and functional. We also would like to thank the many contributors to comp. The discussions there have influenced much of the content of this book. A number of people have provided feedback, corrections, and constructive criticism since the first printing of this book.

Rather than list them all here and have to keep updating this Preface for each new printing , we have placed a list of everyone who contributed at http: Our thanks go to all these people for helping to make this a better book.

Particular thanks go to David Jackson, who read all my drafts and made sure that loose ends were not allowed to remain hanging. Finally, I would like to thank my wife, Jocelyn, and our son, Tyson, for their love and encouragement. Without their support and patience, this book would have never been written.


  • If You're a Student.
  • The Wombles to the Rescue.
  • Henning & Vinoski, Advanced CORBA® Programming with C++ | Pearson.

Steve's Acknowledgments I would like to thank my employer, IONA Technologies, for supporting my efforts to write this book, which occasionally kept me away from the office. In particular, I would like to thank Barry Morris for his support and encouragement, Stephen Keating for taking up the slack when I had to miss work because of all-night writing sessions, and the whole IONA Boston product development team for their patience and support. I would also like to thank Bart Hanlon, who not only reviewed this book but also was my manager at my former employer, for continually encouraging me for several years to tackle this project and for teaching me a lot about tackling projects in general.

In the technical realm, I have learned from many people over the course of my career, but I owe much to John Morris, Craig Bardenheuer, Denis deRuijter, Dale LaBossiere, Tom Moreau, and Bob Kukura, who at one time or another greatly influenced my education in the realms of distributed systems and engineering in general. He not only helped review this book, but also agreed to let me use material from our columns in writing it.

Finally, without the support of my family, I would have never been able to even consider writing this book. I'd like to thank my wife, Cindy, and our children, Ryan and Erin, for putting up with my extremely long hours and days of writing and working. Thanks also to my parents, Ed and Dooley, who have always supported me with their seemingly limitless patience and love. I also owe my brother, John, a special thanks for his wonderful artwork on our book cover.

Click below for Errata related to this title: Customer reviews There are no customer reviews yet. Share your thoughts with other customers.


  • My Lords Secrets Revealed;
  • Der Mond ist unsere Sonne: Roman (German Edition).
  • Monstrous Kink.

Write a product review. Most helpful customer reviews on Amazon. Excellent service and product; will buy again! It handles all the tough topics and describes them in a clear, understandable way. It is the only text that is mostly current with the spec, and it provides real insights into many frequently asked CORBA questions, such as object reference identity and persistence, memory management, and the POA. It was an important and correct decision by the authors to include it instead of the BOA, most of the details of which are vendor-specific anyway that's why the POA exists.

Note to BOA lovers: ORB vendors are free to keep it around, and many do, but it's only because they're nice. The POA is so vastly superior that the only reason you would use the BOA is if you have an existing code base to maintain. This is not a book for beginners, grazers, or wanna-bes; it is a book for serious, working practitioners, and it works best as a reference although you can read it cover to cover. Your alternative is to read the CORBA spec a horrifying prospect for most people , or your ORB vendor's documentation sometimes adequate, sometimes not.

The book is composed from two books: CORBA reference and tutorial. You have two books in one what can be great, however, the book is definitely not easy to read. Reference and tutorial parts are not separated clearly in very helpful way but they are mixed together. After the first introductory part of the book, the authors focus our attention on developing quite comprehesive, CORBA based, distributed Climate Control System.

To follow you must read "actively", ie. This may be not an easy task and can be a little bit frustrating. The book, after the first part, is not devided into levels of difficulty or everything is equally difficult? The book is definitely worth reading, especially if you want to really feel and touch the CORBA technology. And one more thing. It has helped me debug code and fix some really knotty problems. I found the exposition clear and easy to follow, and the index a useful tool. I don't think the authors intended it to be read cover-to-cover.

Your recently viewed items and featured recommendations. View or edit your browsing history. Get to Know Us. Delivery and Returns see our delivery rates and policies thinking of returning an item? See our Returns Policy.

Advanced CORBA Programming with C++ - Michi Henning, Steve Vinoski - Google Книги

Visit our Help Pages. Audible Download Audio Books. Shopbop Designer Fashion Brands. Amazon Prime Music Stream millions of songs, ad-free.