|
 |
All orders
shipped by
airmail!
Click here for our
Shipping Policies!
| |
 | | |
"A threat is basically a means for establishing a bargaining position by inducing fear in the subject. When a threat is used, it should always be implied that the subject himself is to blame by using words such as 'You leave me no other choice but to...'"
- CIA Manual
| | | |
|
| | COM and CORBA, Side by Side:
Architectures, Strategies, and Implementations
| |
| | by Jason Pritchard
|
|
|
ZIN Product Number: 10043238
| eBay (last 12 months) | | Auctions: | | 46 | | Price Range: | | $0.04 - 0.07 | | | | Craigslist (last 12 months) | | Classifieds: | | 26 | | Price Range: | | $0.09 - 0.05 | | | | Amazon Used (last 12 months) | | Auctions: | | 72 | | Price Range: | | $0.07 - 0.04 | | | | ZooScape (last 12 months) | | Auctions: | | 0 | | Price Range: | | N/A | | | | | | Google listings (non-affiliate) | | 100 | | MSN listings (non-affiliate) | | 30 | | Yahoo listings (non-affiliate) | | 45 | | |
| | 
| | | |  | | | Product Details
 Format: Paperback, 1st ed., 464 pages
Publisher: Addison-Wesley
ISBN: 0201379457
Release Date: Jan 6, 1999
Average Reader Review:   (Based on 2 reviews.)
| |  | | | From The Publisher
The COM and CORBA technologies are often pitted against each other, viewed simply as competing architectures for creating distributed solutions. While the most significant difference between COM and CORBA is their support for different operating system platforms, software developers must realize that each technology has its own strengths that clearly differentiate it from the other. In COM and CORBA(r) Side by Side, Jason Pritchard objectively describes when and how developers should use both technologies--together or separately--to maximize the success of their designs.
This book helps software practitioners analyze and transcend their personal biases toward COM or CORBA so that they may objectively seek the best implementation strategy. The author helps you cut through vendor marketing hype by presenting a clear, logical formula to help you choose between the two technologies. In short,COM and CORBA(r) Side by Side is an invaluable resource for making informed, critical decisions about using one or both of these technologies in your next project.
Other highlights of this book.
- Explains why COM and CORBA currently hold dominant positions in the marketplace
- Describes an objective strategy for assessing the use of the two architectures on the server
- Examines client approaches for each technology, including design issues related to remoting and security
- Illustrates how COM and CORBA can be used together, with details on both custom and commercial bridging approaches
| | | | Foreword
Preface
Topics Covered in the Preface
What Is This Book About?
Who Should Read This Book?
What Specific Areas Are Covered in This Book?
What Are the Prerequisites for This Book?
Where Are the On-line Resources?
COM and CORBA are all too often viewed as strictly competing technologies. In many areas, the competitive nature of these two technologies cannot be denied; however, each technology has its own strengths that differentiate it from the other. The most significant difference is the support for various operating system platforms. COM is oriented toward the Windows platform, while CORBA is inherently multiplatform. The operating system platform is an important consideration when determining where each technology should be deployed, but many other variables that factor into a decision regarding the use of COM and/or CORBA.
Determining where to use COM, CORBA, or both is a decision that is often based on emotional rather than on logical reasoning. Due to vendor marketing and the fervor of various technology proponents, emotion often ends up being one of the biggest factors in the selection of a distributed object architecture. I have seen several cases where the correct choice for using COM or CORBA was quite obvious, but where a different choice was made for emotional rather than for logical reasons. An objective strategy for choosing where to use COM and CORBA is badly needed.
The influence of emotion on the decision-making process is not too surprising in any part of the software industry. Software developers tend to be artisans and not engineers. Artisans rely on their instincts and rules of thumb when making critical decisions. Engineers rely on well-defined processes and formulae. While all of us should strive to evolve software development into an engineering discipline, we just aren't there yet. The processes and formulae usually do not exist for making definitive decisions with regard to software.
Perhaps the greatest difficulty with understanding software technologies, especially technologies like COM and CORBA, is the ever-expanding functionality provided by such technologies. None of us can hope to understand every nuance of COM or CORBA. We must therefore become specialized and focus on very specific areas that meet our current needs. As we become more specialized, we lose sight of the big picture. This has a negative effect on our ability to make rational decisions. To escape specialization, we must rely on other people to make us aware of the key factors that need to be considered when deciding where complex technologies like COM and CORBA should be used.
What Is This Book About?
This book provides a comprehensive comparison of COM and CORBA. It brings together the critical elements that must be considered when deciding where COM and CORBA should be used. This book also discusses various approaches for using COM and CORBA together in situations where the use of both is desired.
Throughout this book, COM and CORBA are compared in a side-by-side manner so that the similarities and differences between COM and CORBA are accentuated. The best way to understand what is meant by the phrase side-by-side is to examine the book's table of contents and note that the focus constantly shifts between discussions of COM, CORBA, or both. Within individual sections, comparisons are made between COM and CORBA whenever possible.
While writing this book, I have made every effort to avoid any bias toward either COM or CORBA. This book is definitely not about promoting one technology over the other. I have been fortunate enough to work with COM and CORBA on a multitude of projects, and I very much enjoy using both of them. In this book, I have done my best to objectively present useful information that will be helpful when choosing COM and/or CORBA.
Who Should Read This Book?
Software products based on COM and CORBA will undoubtedly provide the distributed object infrastructures for many future software systems. This book is designed for technical managers and strategists who need to determine where COM and CORBA should be used in their particular organizations. This book will also benefit developers who want to have an impact on such decisions.
This book also allows developers who have a working knowledge of either COM or CORBA to leverage their existing knowledge to better understand both technologies. The side-by-side nature of this book allows developers who are familiar with one approach to easily identify parallels with the other approach. The identification of such parallels provides a powerful mechanism for learning. As a result, a software developer who understands COM can use this book to better understand CORBA; a software developer who understands CORBA can use this book to better understand COM.
What Specific Areas Are Covered in This Book?
This book is divided into four parts that can be read independently of one another. If you are unfamiliar with either COM or CORBA, you should look at Part I first since it provides information on COM and CORBA fundamentals. After completing Part I, the rest of the parts can be read in any order.
Part I, Embracing COM and CORBA. This part of the book provides a brief history leading up to distributed objects and discusses why COM and CORBA currently hold dominant positions in the marketplace. Part I concludes by performing an extensive side-by-side comparison of COM/CORBA technical fundamentals.
Part II, COM and CORBA on the Server. This part of the book discusses the use of COM and CORBA on the server side. It begins by describing an objective strategy for assessing the appropriateness of COM and CORBA for a specific server-side domain. Part II then examines platform issues (including legacy system support), essential services (transactions, security, etc.), and intangibles that must often be considered when choosing between COM and CORBA.
Part III, COM and CORBA on the Client. This part of the book examines client approaches for using COM and CORBA. Because Windows controls the desktop, Part III begins by looking at COM desktop client approaches. It then examines COM/CORBA Internet client approaches and also discusses design issues related to remoting and security. Part III concludes by providing an example that demonstrates a migration path from the desktop to the Internet.
Part IV, Bridging COM and CORBA. This part of the book examines approaches for using COM and CORBA together. It begins by examining custom approaches for bridging COM and CORBA. Part IV then examines commercial bridging approaches based on the OMG's COM/CORBA interworking architecture. Part IV concludes with a discussion of enterprise application servers based on COM, CORBA, and Enterprise JavaBeans.
What Are the Prerequisites for This Book?
The COM examples presented in this book use C++, Java, and Visual Basic. The CORBA examples use C++ and Java. While some chapters in the book are not code-oriented, you will probably have trouble comprehending this book if you are not proficient in C++ or Java.
If you are planning to use COM or CORBA, you have probably already obtained references that focus directly on COM, CORBA, or COM/CORBA bridging. This book provides a comparison of COM and CORBA and also discusses COM/CORBA bridging. It does not, however, attempt to provide a complete reference for any of these areas. Depending on your needs, you may require books that focus exclusively on COM, CORBA, or COM/CORBA bridging to supplement the material contained in this book. For a list of such books that I have found useful, see the references (Appendix A) at the end of the book.
| |  | | |
 | | | | | Number of Reviews: 2 Average Rating:
Excellent resource
-- Lak Ming Lam, Senior Software Engineer, July 10, 1999
Simply great! 
-- Mahesh Dongre, Sr. software consultant., December 21, 1999
| |  | | | Accreditation
Jason Pritchard, Ph.D., has extensive experience programming with CORBA and COM. As a developer and architectural lead for PSW Technologies, he has become an authority on both technologies and has gained vast insight into their coexistence and interoperability.
| |  | | | Preface
Part I
Embracing COM and CORBA
Chapter 1
The Arrival of Distributed Objects
Client/Server Beginnings
2-Tier, 3-Tier, and N-Tier Architectures
Communicating Between Tiers
The Power of Distributed Objects
From Objects to Components
Managing Distributed Systems
The State of Distributed Objects
Chapter 2
The Dominance of COM and CORBA
The Distributed Object Landscape
Microsoft's COM/DCOM
IBM's SOM/DSOM
CORBA
Java RMI
ObjectSpace's Voyager
Summary
COM: The Dominant Component Architecture
CORBA: The Dominant Remoting Architecture
Evolutionary Trends
A Test of Wills
Vendor Perspective
User Perspective
Who Is the Winner?
Chapter 3
Distributed Object Fundamentals
An Overview of the Fundamentals
A Distributed Object Example
COM Object and Clients
CORBA Object and Clients
Reviewing the Requirements
Demonstrating the Fundamentals
Selecting Data Types
Defining the Interfaces
COM IDL and Type Libraries
CORBA IDL
Proxies, Stubs, and Skeletons
COM Proxies and Stubs
COM Type Library Marshaling
CORBA Stubs and Skeletons
Implementing the Servers
Implementing the Clients
Using IDL in the COM C++ Client
Using a Type Library in the COM Visual Basic Client
Using IDL in the Orbix CORBA C++ Client
Using IDL in the VisiBroker CORBA Java Client
Client Implementation Summary
Object Handles
COM Interface Pointers in C++
COM Interface Pointers in Visual Basic
CORBA Object References in C++
CORBA Object References in Java
Creating Objects
COM Factories
COM Object Creation in C++
COM Object Creation in Visual Basic
CORBA Factories
CORBA Object Creation in C++ and Java
Invoking Object Methods
COM HRESULTs
COM Error Handling in the C++ Client
COM Error Handling in the Visual Basic Client
CORBA Exceptions
CORBA Exception Handling in the C++ and Java Clients
Destroying Objects
Destroying COM Objects
Destroying CORBA Objects
Summary
Part II
COM and CORBA on the Server
Chapter 4
Assessing the Server Side
What Constitutes the Server Side?
Partitioning the Enterprise
Strategic Directions of COM and CORBA
COM: A Vertical Strategy
CORBA: A Horizontal Strategy
The Need for an Assessment Strategy
Assessment Criteria
Platform Criteria
Essential Services
Intangibles
An Assessment Strategy
Prerequisites
Recording the Assessment History 7
Rating the Criteria
Assessment Steps
An Assessment Example
COM and CORBA in Your Enterprise Solution
Chapter 5
The Server Platform
Review of the Platform Criteria
Legacy System Support
General Approaches for Supporting Legacy Systems
Identifying Significant Legacy Systems
Selecting Platforms for New Development
Wrapper Approach
Gateway Approach
Legacy Support When Using COM
COM and the Wrapper Approach
COM and the Gateway Approach
Using COM to Access Legacy Data.
COM Integration with CICS and IMS
COM Integration with IBM's MQSeries
Summary of COM-Related Legacy Support
Legacy Support When Using CORBA
CORBA and the Wrapper Approach
CORBA and the Gateway Approach
Summary of CORBA-Related Legacy Support
The Development Platform
COM Development Platforms
COM/Windows/C++ Development Platform
COM/Windows/Java Development Platform
COM/Windows/Visual Basic Development Platform
Non-Windows COM Development Platforms
CORBA Development Platforms
Availability of Development Tools
COM Development Tools
CORBA Development Tools
Summary
Chapter 6
Essential Services
Review of the Service Criteria
Distributed Transaction Support
A Scenario for a Distributed Object Transaction
COM, MTS, and the Distributed Transaction Coordinator
CORBA and the Object Transaction Service
Distributed Security
DCOM Security
MTS Security
CORBA and the Secure Sockets Layer
The CORBA Security Service
Messaging Support
COM and Microsoft Message Queue Server .
CORBA and Messaging Support
Distributed Object Management 0
The Need for Stateless Objects
COM Object Management Under Microsoft's MTS
CORBA Object Management Under BEA Systems' M3
Summary
Chapter 7
Server-Side Intangibles
Vendor Perception
Vendor Commitment and Viability
Vendor Lock-in
Availability of Product
Availability of Development Staff
Product Cost
Server-Side Summary
Part III
COM and CORBA on the Client
Chapter 8
The Desktop Client
Impact of Distributed Objects
Dominance of COM on the Desktop
COM Client Approaches
Custom Interfaces
Automation Interfaces
Dual Interfaces
Installing Remote COM Clients
COM Development Environments
The Visual Basic COM Client
The Visual J++ COM Client
The Visual C++ COM Client
Summary
Chapter 9
The Internet Client
Distributed Object Internet Strategies
COM Internet Strategies
CORBA Internet Strategies
Using COM with Active Server Pages
Using CORBA in a Java Applet
The Push Technology Alternative
Summary
Chapter 10
Client Design Considerations
Remoting Requirements and Design Issues
Client Needs Versus Remoting Requirements
Security Issues for Internet Clients
Security Issues When Using Active Server Pages
Security Issues When Using Java Applets
Migrating from the Desktop to the Internet
Implementing the COM and CORBA Customer Servers
The COM Customer Server and Proxy
The COM Customer Wrapper
The CORBA Customer Server and Proxy
Implementing the COM/CORBA Customer Bridge
The COM-to-CORBA Customer Bridge
The CORBA-to-COM Customer Bridge
Implementing the COM and CORBA Customer Clients
The Visual Basic Customer Client
The Active Server Pages Customer Client
The CORBA/Java Customer Client
Migration Summary
Client-Side Summary
Part IV
Bridging COM and CORBA
Chapter 11
Custom Bridging Approaches
Overview of Bridging Example
Using C++ to Bridge COM and CORBA
Using Microsoft's JVM as a Bridge
Using a CORBA/Java ORB with Microsoft's JVM
A COM-to-CORBA Bridge
A Visual Basic Client
Other COM/CORBA Bridging Approaches
Using COM in Non-Microsoft JVMs
Bridging ActiveX and JavaBeans
Using Environments That Support COM and CORBA
Future Java/COM Support from Microsoft .
Summary
Chapter 12
Commercial Bridging Approach
COM/CORBA Interworking Specification
Vendor Support for COM/CORBA Bridging
A Commercial Bridging Example
Selecting a Commercial Bridging Product
The CORBA Server
Creating a COM View for the CORBA Server
Using the CORBA Server from a Visual Basic Client
Using COM Servers from CORBA Clients
Bridging COM/CORBA Services
Summary
Chapter 13
Enterprise Application Servers
Emergence of Enterprise Application Servers
Early Web Application Servers
The Need for Enterprise Application Servers
Enterprise Application Server Criteria
Enterprise Application Server Approaches
COM Approach
CORBA Approach
Enterprise JavaBeans Approach
Summary
Chapter 14
Conclusion
A Summary of What We've Covered
Embracing COM and CORBA (Part I)
COM and CORBA on the Server (Part II)
COM and CORBA on the Client (Part III)
Bridging COM and CORBA (Part IV) 4
Farewell
Appendices
Appendix A
References
On COM
On CORBA
On COM/CORBA Bridging
Appendix B
Examples Available for Download
Chapter 3 Examples
Clients
COM C++ Client
COM Visual Basic Client
CORBA C++ Client
CORBA Java Client
Servers
COM IDL
CORBA IDL
COM C++ Server
CORBA C++ Server
Chapter 6 Examples
MTS Example
MTS Account Server
MTS Teller Server
MTS Client
COM Security
COM Secure Agent Server
COM Secure Client
MTS Secure Account Server
MTS Secure Client
MSMQ Example
MSMQ Market Application
MSMQ Trader Application
Chapter 8 Examples
Automation Interface Approach
Visual J++ Server
Visual Basic Client
Visual C++ Client
Visual J++ Client
Custom Interface Approach
Visual C++ Server
Visual Basic Client
Visual C++ Client
Visual J++ Client
Dual Interface Approach
Visual Basic Server
Visual C++ Server
Visual J++ Server
Visual Basic Client
Visual Basic Automation Client
Visual C++ Client
Visual J++ Client
Chapter 9 Examples
Clients
COM Active Server Pages Client
CORBA Java Applet
Servers
COM IDL
CORBA IDL
COM Server
CORBA Server
Chapter 10 Examples
Clients
COM Active Server Pages Client
COM Visual Basic Client
CORBA Java Applet
Servers
COM IDL
CORBA IDL
COM Customer Interface
COM Customer Wrapper
COM Customer Server
COM Customer Proxy
COM-to-CORBA Bridge
CORBA Customer Server
CORBA Customer Proxy
CORBA-to-COM Bridge
Chapter 11 Examples
COM IDL
CORBA IDL
COM Client
COM-to-CORBA Bridge
CORBA Server
Chapter 12 Examples
Bindings Generated by Commercial Bridging Product
COM Client
CORBA Server
Appendix C
Selected Example Code1
MyCheckingAccount Classes (from Ch. 3)
COM/C++ MyCheckingAccount Class
COM/Visual Basic MyCheckingAccount Class
CORBA/C++ MyCheckingAccount Class
CORBA/Java MyCheckingAccount Class
MTS Components (from Ch. 6)
Ch6Teller MTS Component
Ch6Account MTS Component
MSMQ Applications (from Ch. 6)
Trader MSMQ Application
Stock Market MSMQ Application
Index
| |  | | | Find similiar books in these subject areas:
All Topics > Computers & Internet > Networking > Networks, Protocols & API's > COM & DCOM
All Topics > Computers & Internet > Networking > Networks, Protocols & API's > CORBA
All Topics > Computers & Internet > Programming > General
All Topics > Computers & Internet > Programming > APIs & Operating Environments > COM, DCOM & ATL
All Topics > Computers & Internet > Programming > Software Design > Object-Oriented Design
All Topics > Design & Development > Object-Oriented Design
| | | | People like you also bought:
COM-CORBA Interoperability, by
Enterprise Application Integration with CORBA: Component and Web-Based Solutions, by Ron Zahavi
CORBA 3 Fundamentals and Programming with CDROM, by Jon Siegel
Advanced CORBA Programming with C++, by Michi Henning
Java Programming with CORBA, Third Edition, by Gerald Brose
Pure CORBA: A Code-Intensive Premium Reference, by Fintan Bolton
Client Server Programming With Java and Corba, Second Edition with CD Rom, by Robert Orfali
Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects, Vol. 2 2ND, by Douglas C. Schmidt
MICO: An Open Source CORBA Implentation, by
Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library, by Scott Meyers
| | | | | | Keywords
COM (Computer architecture), CORBA (Computer architecture), Computer Architecture, Computer Bks - Languages / Programming, Computers, Programming - Object Oriented Programming, Programming Languages - General, Computer Architecture - General, CORBA (Computer architecture), COM (Computer architecture)
| |
| |
| | | |
Make $1 per sale -
Link to ZooScape.com! | |
