BN.com Gift Guide

Advanced CORBA Programming with C++ / Edition 1

Paperback (Print)
Buy Used
Buy Used from BN.com
$49.19
(Save 38%)
Item is in good condition but packaging may have signs of shelf wear/aging or torn packaging.
Condition: Used – Good details
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 97%)
Other sellers (Paperback)
  • All (36) from $1.99   
  • New (8) from $39.00   
  • Used (28) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$39.00
Seller since 2014

Feedback rating:

(3)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
Paperback New New. Unused. Good condition. Bottom has black remind marker and minor shelf wear. Cover at binding place seems not glue well to the book. All pages combine ... together well. Read more Show Less

Ships from: Scarborough, Canada

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$62.30
Seller since 2008

Feedback rating:

(17783)

Condition: New
Brand New, Perfect Condition, Please allow 4-14 business days for delivery. 100% Money Back Guarantee, Over 1,000,000 customers served.

Ships from: Westminster, MD

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$62.31
Seller since 2007

Feedback rating:

(23530)

Condition: New
BRAND NEW

Ships from: Avenel, NJ

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
$67.27
Seller since 2014

Feedback rating:

(0)

Condition: New
0201379279 Premium Publisher Direct Books are Like New or Brand New books direct from the publisher sometimes at a discount. Multiple copies are usually available. These books ... are not available for expedited shipping and may take up to 14 business days to receive. Read more Show Less

Ships from: Agoura Hills, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Express, 48 States
$70.63
Seller since 2014

Feedback rating:

(31)

Condition: New
PAPERBACK New 0201379279 Premium Publisher Direct Books are Like New or Brand New books direct from the publisher sometimes at a discount. Multiple copies are usually ... available. These books are not available for expedited shipping and may take up to 14 business days to receive. Read more Show Less

Ships from: Tarzana, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$85.16
Seller since 2009

Feedback rating:

(10545)

Condition: New
New Book. Shipped from US within 4 to 14 business days. Established seller since 2000

Ships from: Secaucus, NJ

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$98.14
Seller since 2014

Feedback rating:

(6)

Condition: New
New

Ships from: Idyllwild, CA

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$104.07
Seller since 2014

Feedback rating:

(0)

Condition: New

Ships from: Malaga, Spain

Usually ships in 1-2 business days

  • Standard, 48 States
Page 1 of 1
Showing All
Close
Sort by

Overview

Here is the CORBA book that every C++ software engineer has been waiting for. Advanced CORBA® Programming with C++ provides designers and developers with the tools required to understand CORBA technology at the architectural, design, and source code levels. This book offers hands-on explanations for building efficient applications, as well as lucid examples that provide practical advice on avoiding costly mistakes. With this book as a guide, programmers will find the support they need to successfully undertake industrial-strength CORBA development projects.

The content is systematically arranged and presented so the book may be used as both a tutorial and a reference. The rich example programs in this definitive text show CORBA developers how to write clearer code that is more maintainable, portable, and efficient. The authors' detailed coverage of the IDL-to-C++ mapping moves beyond the mechanics of the APIs to discuss topics such as potential pitfalls and efficiency. An in-depth presentation of the new Portable Object Adapter (POA) explains how to take advantage of its numerous features to create scalable and high-performance servers. In addition, detailed discussion of advanced topics, such as garbage collection and multithreading, provides developers with the knowledge they need to write commercial applications.

Other highlights

  • In-depth coverage of IDL, including common idioms and design trade-offs
  • Complete and detailed explanations of the Life Cycle, Naming, Trading, and Event Services
  • Discussion of IIOP and implementation repositories
  • Insight into the dynamic aspects of CORBA, such as dynamic typing and the new DynAny interfaces
  • Advice on selecting appropriate application architectures and designs
  • Detailed, portable, and vendor-independent source code

0201379279B04062001


Designed for software engineers and programmers, this excellent tutorial and reference helps you code in C++ for CORBA applications and interoperability. Authors Michi Henning and Steve Vinoski based this programming guide on advanced courses for C++ programmers, therefore familiarity with basic CORBA concepts, ORBs and the CORBA framework is assumed - as is familiarity with C++ at an intermediate to advanced level. This publication is based on CORBA 2.3.

Read More Show Less

Editorial Reviews

Booknews
Explains CORBA technology at the architectural, design and source code levels of commercial application construction, and offers examples that provide practical advice on avoiding costly mistakes. The guide features discussion of IDL-to-C++ mapping, the new portable object adapter (POA), garbage collection, multithreading, and the naming, trading and event services. For C++ engineers familiar with CORBA, inheritance, virtual functions, operator overloading, templates, and threaded code. Annotation c. by Book News, Inc., Portland, Or.
Read More Show Less

Product Details

  • ISBN-13: 9780201379273
  • Publisher: Addison-Wesley
  • Publication date: 2/12/1999
  • Series: Addison-Wesley Professional Computing Series
  • Edition description: New Edition
  • Edition number: 1
  • Pages: 1120
  • Product dimensions: 7.37 (w) x 9.10 (h) x 1.81 (d)

Meet the Author

Michi Henning is Chief Scientist of ZeroC, Inc, where he is responsible for research and development of next-generation middleware technologies. Michi has spent many years on CORBA-related research, as well as CORBA consulting and training for international customers. He has contributed to numerous OMG specifications, was a member of the OMG Architecture Board, and was chair of the OMG's C++ Revision Task Force.

Steve Vinoski is Chief Engineer of Product Innovation for IONA Technologies, PLC. He has coauthored several important OMG specifications, including the OMG IDL C++ Language Mapping specification, and he previously served as the chair of the OMG C++ Revision Task Force. Steve is also the author of the "Toward Integration" middleware column in IEEE Internet Computing, and coauthor of the "Object Interconnections" column in the C/C++ Users Journal. He frequently presents at middleware conferences around the globe.

0201379279AB11072003

Read More Show Less

Read an Excerpt

Preface

For years, both of us have been (and still are) teaching CORBA
programming with C++ to software engineers all over the world. One of
the most frequently asked questions in our courses is, "Where can I find
a book that covers all this?" Although many books have been written
about CORBA, most of them focus on high-level concepts and do not
address the needs of software engineers. Even though CORBA is
conceptually simple, the devil lies in the detail. Or, more bluntly, books
focusing on high-level concepts are of little use when you must find out
why your program is dumping core.

To be sure, there are resources available about CORBA, such as
newsgroups, Web pages, and the Object Management Group (OMG)
specifications. However, none of them really meets the needs of a
programmer who must get the code to work (and preferably by
yesterday). We wrote this book so that there would finally be a tutorial
and reference that covers CORBA programming with C++ at the level
of detail required for real-life software development. (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. Explaining the CORBA specification
and APIs is one thing, and it's a necessary part of the book. However,
knowing the various APIs will not, by itself, make you a competent
programmer (only a knowledgeable one). 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.

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). Second, we go beyond the
APIs by explaining some of CORBA's internal mechanisms. 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: if you agree, you can stick to the
advice we give; if you disagree, the discussion will have at least
encouraged you to think about the topic and form your own opinion.
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 specification
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). Instead, we assume that you want to know
how to write real CORBA applications with C++. 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.

Much of this book consists of source code, so we expect you to be
literate in C++. However, you do not need to be a C++ guru to follow the
code. We have avoided obscure or little-understood features of C++,
preferring clarity to cleverness. If you understand inheritance, virtual
functions, operator overloading, and templates (not necessarily in intricate
detail), you will have no problems. Some of the source code uses the
Standard Template Library (STL), which is now part of the ISO/IEC
C++ Standard. 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 straight-line 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.)

Scope of this Book

OMG members are continually improving CORBA and adding new
features. As a result, available ORB implementations conform to
different revision levels of the specification. This book covers CORBA
2.3. (At the time of writing, CORBA 2.3 is being finalized by the OMG.)
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.
Ever-increasing page counts and ever-closer deadlines forced us to drop
chapters on the Dynamic Invocation Interface (DII), the Dynamic
Skeleton Interface (DSI), and the Interface Repository (IFR).
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.

Another feature notable by its absence is Objects-By-Value (OBV). 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.

Size and time limitations also meant that we could not cover every
possible CORBA service. 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: the
Naming, Trading, and Event Services. We cover those services in more
detail than any other publication we are aware of.

An important part of this book is the presentation of the Portable Object
Adapter (POA), which was added in CORBA 2.2. 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.

Overall, we believe this book offers the most comprehensive coverage to
date of CORBA programming with C++. 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.

Particular thanks go to Colm Bergin, Jonathan Biggar, Bart Hanlon,
Jishnu Mukerji, and Doug Schmidt, our expert reviewers. They read the
entire manuscript and spotted many problems that would have otherwise
gone unnoticed. 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.

Todd Goldman and Tim Gill from Hewlett-Packard gave us permission to
draw on earlier ORB training material written by Michi. John Vinoski and
Dan Rabideau of Green Bay Engraving take credit for designing the
Möbius strip on the cover.

We are grateful to Steve's employer, IONA Technologies, for allowing
us to use the next generation of their Orbix product (called "ART") to
develop and test our code examples. Their generosity provided us with
the opportunity to make sure that our examples were correct and
functional. The fact that ART conforms to CORBA 2.3 allowed us to
target the most recent version of the CORBA specification available as
of this writing.

We also would like to thank the many contributors to comp.object.corba
and the corba-dev mailing list. The discussions there have influenced
much of the content of this book.

Michi's Acknowledgments

I would like to thank my former employer, DSTC Pty Ltd, for providing
me with an environment that was conducive to writing. Joachim
Achtzehnter, Martin Chilvers, Wil Evers, Ted McFadden, and Michael
Neville reviewed parts of the manuscript and made valuable suggestions
for improvement. 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.

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. I would also like to thank my C++ Report
co-columnist, Doug Schmidt, a true technical visionary whose work in
object-oriented network programming, C++ frameworks, and CORBA
has paved the way for books such as this one. 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.

Michi Henning and Steve Vinoski
October 1998

Read More Show Less

Table of Contents

Preface.

1. Introduction.

Introduction.

Organization of the Book.

CORBA Version.

Typographical Conventions.

Source Code Examples.

Vendor Dependencies.

Contacting the Authors.

I. INTRODUCTION TO CORBA.

2. An Overview of CORBA.

Introduction.

The Object Management Group.

Concepts and Terminology.

CORBA Features.

Request Invocation.

General CORBA Application Development.

Summary.

3. A Minimal CORBA Application.

Chapter Overview.

Writing and Compiling an IDL Definition.

Writing and Compiling a Server.

Writing and Compiling a Client.

Running Client and Server.

Summary.

II. CORE CORBA.

4. The OMG Interface Definition Language.

Chapter Overview.

Introduction.

Compilation.

Source Files.

Lexical Rules.

Basic IDL Types.

User-Defined Types.

Interfaces and Operations.

User Exceptions.

System Exceptions.

System Exceptions or User Exceptions?

Oneway Operations.

Contexts.

Attributes.

Modules.

Forward Declarations.

Inheritance.

Names and Scoping.

Repository Identifiers and pragma Directives.

Standard Include Files.

Recent IDL Extensions.

Summary.

5. IDL for a Climate Control System.

Chapter Overview.

The Climate Control System.

IDL for the Climate Control System.

The Complete Specification.

6. Basic IDL-to-C++ Mapping.

Chapter Overview.

Introduction.

Mapping for Identifiers.

Mapping for Modules.

The CORBA Module.

Mapping for Basic Types.

Mapping for Constants.

Mapping for Enumerated Types.

Variable-Length Types and _var Types.

The String_var Wrapper Class.

Mapping for Wide Strings.

Mapping for Fixed-Point Types.

Mapping for Structures.

Mapping for Sequences.

Mapping for Arrays.

Mapping for Unions.

Mapping for Recursive Structures and Unions.

Mapping for Type Definitions.

User-Defined Types and _var Classes.

Summary.

7. Client-Side C++ Mapping.

Chapter Overview.

Introduction.

Mapping for Interfaces.

Object Reference Types.

Life Cycle of Object References.

Semantics of _ptr References.

Pseudo-Objects.

ORB Initialization.

Initial References.

Stringified References.

The Object Pseudo-Interface.

_var References.

Mapping for Operations and Attributes.

Parameter Passing Rules.

Mapping for Exceptions.

Mapping for Contexts.

Summary.

8.Developing a Client for the Climate Control System.

Chapter Overview.

Introduction.

Overall Client Structure.

Included Files.

Helper Functions.

The main Program.

The Complete Client Code.

Summary.

9. Server-Side C++ Mapping.

Chapter Overview.

Introduction.

Mapping for Interfaces.

Servant Classes.

Object Incarnation.

Server main.

Parameter Passing Rules.

Raising Exceptions.

Tie Classes.

Summary.

10. Developing a Server for the Climate Control System.

Chapter Overview.

Introduction.

The Instrument Control Protocol API.

Designing the Thermometer Servant Class.

Implementing the Thermometer Servant Class.

Designing the Thermostat Servant Class.

Implementing the Thermostat Servant Class.

Designing the Controller Servant Class.

Implementing the Controller Servant Class.

Implementing the Server Main Function.

The Complete Server Code.

Summary.

11. The Portable Object Adapter.

Chapter Overview.

Introduction.

POA Fundamentals.

POA Policies.

POA Creation.

Servant IDL Type.

Object Creation and Activation.

Reference, ObjectId, and Servant.

Object Deactivation.

Request Flow Control.

ORB Event Handling.

POA Activation.

POA Destruction.

Applying POA Policies.

Summary.

12. Object Life Cycle.

Chapter Overview.

Introduction.

Object Factories.

Destroying, Copying, and Moving Objects.

A Critique of the Life Cycle Service.

The Evictor Pattern.

Garbage Collection of Servants.

Garbage Collection of CORBA Objects.

Summary.

III. CORBA MECHANISMS.

13. GIOP, IIOP, and IORs.

Chapter Overview.

An Overview of GIOP.

Common Data Representation.

GIOP Message Formats.

GIOP Connection Management.

Detecting Disorderly Shutdown.

An Overview of IIOP.

Structure of an IOR.

Bidirectional IIOP.

Summary.

14. Implementation Repositories and Binding.

Chapter Overview.

Binding Modes.

Direct Binding.

Indirect Binding via an Implementation Repository.

Migration, Reliability, Performance, and Scalability.

Activation Modes.

Race Conditions.

Security Considerations.

Summary.

IV. DYNAMIC CORBA.

15. C++ Mapping for Type Any.

Chapter Overview.

Introduction.

Type Any C++ Mapping.

Pitfalls in Type Definitions.

Summary.

16. Type Codes.

Chapter Overview.

Introduction.

The TypeCode Pseudo-Object.

C++ Mapping for the TypeCode Pseudo-Object.

Type Code Comparisons.

Type Code Constants.

Type Code Comparison for Type Any.

Creating Type Codes Dynamically.

Summary.

17. Type DynAny.

Chapter Overview.

Introduction.

The DynAny Interface.

C++ Mapping for the DynAny Pseudo-Object.

Using DynAny for Generic Display.

Obtaining Type Information.

Summary.

V. CORBASERVICES.

18. The OMG Naming Service.

Chapter Overview.

Introduction.

Basic Concepts.

Structure of the Naming Service IDL.

Semantics of Names.

Naming Context IDL.

Iterators.

Pitfalls in the Naming Service.

The Names Library.

Naming Service Tools.

What to Advertise.

When to Advertise.

Federated Naming.

Adding Naming to the Climate Control System.

Summary.

19. The OMG Trading Service.

Chapter Overview.

Introduction.

Trading Concepts and Terminology.

IDL Overview.

The Service Type Repository.

The Trader Interfaces.

Exporting Service Offers.

Withdrawing Service Offers.

Modifying Service Offers.

The Trader Constraint Language.

Importing Service Offers.

Bulk Withdrawal.

The Admin Interface.

Inspecting Service Offers.

Exporting Dynamic Properties.

Trader Federation.

Trader Tools.

Architectural Considerations.

What to Advertise.

Avoiding Duplicate Service Offers.

Adding Trading to the Climate Control System.

Summary.

20. The OMG Event Service.

Chapter Overview.

Introduction.

Distributed Callbacks.

Event Service Basics.

Event Service Interfaces.

Implementing Consumers and Suppliers.

Choosing an Event Model.

Event Service Limitations.

Summary.

VI. POWER CORBA.

21. Multithreaded Applications.

Chapter Overview.

Introduction.

Motivation for Multithreaded Programs.

Fundamentals of Multithreaded Servers.

Multithreading Strategies.

Implementing a Multithreaded Server.

Servant Activators and the Evictor Pattern.

Summary.

22. Performance, Scalability, and Maintainability.

Chapter Overview.

Introduction.

Reducing Messaging Overhead.

Optimizing Server Implementations.

Federating Services.

Improving Physical Design.

Summary.

Appendix A: Source Code for the ICP Simulator.

Overview.

Transient Simulator Code.

Persistent Simulator Code.

Appendix B: CORBA Resources.

World Wide Web.

Newsgroups.

Mailing Lists.

Magazines.

Bibliography.

Index. 0201379279T10252001

Read More Show Less

Preface

For years, both of us have been (and still are) teaching CORBA programming with C++ to software engineers all over the world. One of the most frequently asked questions in our courses is, ''Where can I find a book that covers all this?'' Although many books have been written about CORBA, most of them focus on high-level concepts and do not address the needs of software engineers. Even though CORBA is conceptually simple, the devil lies in the detail. Or, more bluntly, books focusing on high-level concepts are of little use when you must find out why your program is dumping core.

To be sure, there are resources available about CORBA, such as newsgroups, Web pages, and the Object Management Group (OMG) specifications. However, none of them really meets the needs of a programmer who must get the code to work (and preferably by yesterday). We wrote this book so that there would finally be a tutorial and reference that covers CORBA programming with C++ at the level of detail required for real-life software development. (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. Explaining the CORBA specification and APIs is one thing, and it's a necessary part of the book. However, knowing the various APIs will not, by itself, make you a competent programmer (only a knowledgeable one). 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.

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). Second, we go beyond the APIs by explaining some of CORBA's internal mechanisms. 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: if you agree, you can stick to the advice we give; if you disagree, the discussion will have at least encouraged you to think about the topic and form your own opinion. 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). Instead, we assume that you want to know how to write real CORBA applications with C++. 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.

Much of this book consists of source code, so we expect you to be literate in C++. However, you do not need to be a C++ guru to follow the code. We have avoided obscure or little-understood features of C++, preferring clarity to cleverness. If you understand inheritance, virtual functions, operator overloading, and templates (not necessarily in intricate detail), you will have no problems. Some of the source code uses the Standard Template Library (STL), which is now part of the ISO/IEC C++ Standard. 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.)

Scope of this Book


OMG members are continually improving CORBA and adding new features. As a result, available ORB implementations conform to different revision levels of the specification. This book covers CORBA 2.3. (At the time of writing, CORBA 2.3 is being finalized by the OMG.) 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. Ever-increasing page counts and ever-closer deadlines forced us to drop chapters on the Dynamic Invocation Interface (DII), the Dynamic Skeleton Interface (DSI), and the Interface Repository (IFR). 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. Another feature notable by its absence is Objects-By-Value (OBV). 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.

Size and time limitations also meant that we could not cover every possible CORBA service. 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: the Naming, Trading, and Event Services. We cover those services in more detail than any other publication we are aware of.

An important part of this book is the presentation of the Portable Object Adapter (POA), which was added in CORBA 2.2. 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.

Overall, we believe this book offers the most comprehensive coverage to date of CORBA programming with C++. 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.

Particular thanks go to Colm Bergin, Jonathan Biggar, Bart Hanlon, Jishnu Mukerji, and Doug Schmidt, our expert reviewers. They read the entire manu script and spotted many problems that would have otherwise gone unnoticed. 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.

Todd Goldman and Tim Gill from Hewlett-Packard gave us permission to draw on earlier ORB training material written by Michi. John Vinoski and Dan Rabideau of Green Bay Engraving take credit for designing the Mabius strip on the cover.

We are grateful to Steve's employer, IONA Technologies, for allowing us to use the next generation of their Orbix product (called ''ART'') to develop and test our code examples. Their generosity provided us with the opportunity to make sure that our examples were correct and functional. The fact that ART conforms to CORBA 2.3 allowed us to target the most recent version of the CORBA specification available as of this writing.

We also would like to thank the many contributors to comp.object.corba and the corba-dev mailing list. 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://www.triodia.com/staff/michi/advanced_corba/acknowledgments.html. Our thanks go to all these people for helping to make this a better book.

Michi's Acknowledgments


I would like to thank my former employer, DSTC Pty Ltd, for providing me with an environment that was conducive to writing. Joachim Achtzehnter, Martin Chilvers, Wil Evers, Ted McFadden, and Michael Neville reviewed parts of the manuscript and made valuable suggestions for improvement. 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.

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. I would also like to thank my C++ Report co-columnist, Doug Schmidt, a true technical visionary whose work in object-oriented network programming, C++ frameworks, and CORBA has paved the way for books such as this one. 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.

Michi Henning and Steve Vinoski
October 1998

0201379279P04062001

Read More Show Less

Customer Reviews

Average Rating 3.5
( 2 )
Rating Distribution

5 Star

(0)

4 Star

(1)

3 Star

(1)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing all of 2 Customer Reviews
  • Anonymous

    Posted March 3, 2000

    Moving to CORBA, if you all ready know C++.

    This book contains everything you need to use C++ to implement clients and servers on 'The ACE ORB'. Considering that you can obtain all of the tools (GNU C++, Postgres, ACE and TAO, Perl ... all of the usual suspects) from the Net, this book is the only thing you need to purchase, to begin working with CORBA. I found it to be the most valuable CORBA resource available to me in my first two CORBA projects.

    Was this review helpful? Yes  No   Report this review
  • Anonymous

    Posted April 28, 2010

    No text was provided for this review.

Sort by: Showing all of 2 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)