An overview of the CORBA portable object adapter
StandardView
Software architecture classification for estimating the cost of COTS integration
Proceedings of the 21st international conference on Software engineering
An architectural style for multiple real-time data feeds
Proceedings of the 21st international conference on Software engineering
Proceedings of the 21st international conference on Software engineering
Software engineering and middleware: a roadmap
Proceedings of the Conference on The Future of Software Engineering
Software evolution in componentware using requirements/assurances contracts
Proceedings of the 22nd international conference on Software engineering
Customization of object request brokers by application specific policies
IFIP/ACM International Conference on Distributed systems platforms
COM revisited: tool-assisted modelling of an architectural framework
SIGSOFT '00/FSE-8 Proceedings of the 8th ACM SIGSOFT international symposium on Foundations of software engineering: twenty-first century applications
Designing an Efficient and Scalable Server-side Asynchrony Model for CORBA
OM '01 Proceedings of the 2001 ACM SIGPLAN workshop on Optimization of middleware and distributed systems
Component technologies: Java Beans, COM, CORBA, RMI, EJB and the CORBA Component Model
Proceedings of the 8th European software engineering conference held jointly with 9th ACM SIGSOFT international symposium on Foundations of software engineering
Object-oriented composition untangled
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Applying a pattern language to develop extensible ORB middleware
Design patterns in communications software
Distributed component technologies and their software engineering implications
Proceedings of the 24th International Conference on Software Engineering
Component technologies: Java beans, COM, CORBA, RMI, EJB and the CORBA component model
Proceedings of the 24th International Conference on Software Engineering
Type-Safe linking with recursive DLLs and shared libraries
ACM Transactions on Programming Languages and Systems (TOPLAS)
Supporting high-performance I/O in QoS-enabled ORB middleware
Cluster Computing
Challenges of component-based development
Journal of Systems and Software
Customization of Distributed Systems Using COM
IEEE Concurrency
Adapting C++ exception handling to an extended COM exception model
Advances in exception handling techniques
Reliable Transaction Design Using MTS
COMPSAC '00 24th International Computer Software and Applications Conference
Logic for Component-Based Software Development
Computational Logic: Logic Programming and Beyond, Essays in Honour of Robert A. Kowalski, Part I
Type-Safe Delegation for Run-Time Component Adaptation
ECOOP '99 Proceedings of the 13th European Conference on Object-Oriented Programming
Notes on Nominal Calculi for Security and Mobility
FOSAD '00 Revised versions of lectures given during the IFIP WG 1.7 International School on Foundations of Security Analysis and Design on Foundations of Security Analysis and Design: Tutorial Lectures
Design and Performance of Asynchronous Method Handling for CORBA
On the Move to Meaningful Internet Systems, 2002 - DOA/CoopIS/ODBASE 2002 Confederated International Conferences DOA, CoopIS and ODBASE 2002
Adapting C++ Exception Handling to an Extended COM Exception Model
Advances in Exception Handling Techniques (the book grow out of a ECOOP 2000 workshop)
Dynamic Replacement of Active Objects in the Gilgul Programming Language
CD '02 Proceedings of the IFIP/ACM Working Conference on Component Deployment
Using Abstract State Machines at Microsoft: A Case Study
ASM '00 Proceedings of the International Workshop on Abstract State Machines, Theory and Applications
ASM '00 Proceedings of the International Workshop on Abstract State Machines, Theory and Applications
RICES: reasoning about information consistency across enterprise solutions
Systems engineering for business process change
Validating a Web service security abstraction by typing
Proceedings of the 2002 ACM workshop on XML security
Language integration in the common language runtime
ACM SIGPLAN Notices
Monitoring and Characterization of Component-Based Systems with Global Causality Capture
ICDCS '03 Proceedings of the 23rd International Conference on Distributed Computing Systems
Middleware Techniques and Optimizations for Real-Time, Embedded Systems
Proceedings of the 12th international symposium on System synthesis
Gravity: supporting dynamically available services in client-side applications
Proceedings of the 9th European software engineering conference held jointly with 11th ACM SIGSOFT international symposium on Foundations of software engineering
Mobile Networks and Applications
A New Approach to Object-Oriented Middleware
IEEE Internet Computing
An on-line performance visualization technology
Software—Practice & Experience
Imposing a Memory Management Discipline on Software Deployment
Proceedings of the 26th International Conference on Software Engineering
Autonomous Adaptation to Dynamic Availability Using a Service-Oriented Component Model
Proceedings of the 26th International Conference on Software Engineering
Design and implementation of a softswitch for third generation mobile all-IP network
Wireless communications systems and networks
Distributed/Heterogeneous Query Processing in Microsoft SQL Server
ICDE '05 Proceedings of the 21st International Conference on Data Engineering
Integrating Web technologies in Eclipse
IBM Systems Journal
A Taxonomy of Software Component Models
EUROMICRO '05 Proceedings of the 31st EUROMICRO Conference on Software Engineering and Advanced Applications
EUROMICRO '05 Proceedings of the 31st EUROMICRO Conference on Software Engineering and Advanced Applications
Illumination Modeling and Generation of Realistic Images Using Internet Technologies
Programming and Computing Software
Using predicate fields in a highly flexible industrial control system
OOPSLA '05 Companion to the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
ReflecTS: a flexible transaction service framework
ARM '05 Proceedings of the 4th workshop on Reflective and adaptive middleware systems
A Component Architecture for High-Performance Scientific Computing
International Journal of High Performance Computing Applications
UbiquitousSurvey: a framework supporting mobile field survey data collection and analysis
Proceedings of the 43rd annual Southeast regional conference - Volume 2
PPPJ '06 Proceedings of the 4th international symposium on Principles and practice of programming in Java
Using resemblance to support component reuse and evolution
Proceedings of the 2006 conference on Specification and verification of component-based systems
Sequential Circuits for Relational Analysis
ICSE '07 Proceedings of the 29th international conference on Software Engineering
Distributed calculations and simulation of radar image-based navigation
Automation and Remote Control
Bean markup language: a composition language for JavaBeans components
COOTS'01 Proceedings of the 6th conference on USENIX Conference on Object-Oriented Technologies and Systems - Volume 6
XFI: software guards for system address spaces
OSDI '06 Proceedings of the 7th symposium on Operating systems design and implementation
IEEE Transactions on Software Engineering
A real-time wavelet-based video compression approach to intelligent video surveillance systems
International Journal of Computer Applications in Technology
Derivative contracts as active documents: component-orientation meets financial modeling
MCBE'06 Proceedings of the 7th WSEAS International Conference on Mathematics & Computers in Business & Economics
ACM SIGSOFT Software Engineering Notes
Structural Testing of Component-Based Systems
CBSE '08 Proceedings of the 11th International Symposium on Component-Based Software Engineering
Flexible and adaptive QoS control for distributed real-time and embedded middleware
Proceedings of the ACM/IFIP/USENIX 2003 International Conference on Middleware
On understanding data abstraction, revisited
Proceedings of the 24th ACM SIGPLAN conference on Object oriented programming systems languages and applications
Performance analysis of PROFINET networks
Computer Standards & Interfaces
Manipulation of CAD surface models with haptics based on shape control functions
Computer-Aided Design
FlowMonitor: a network monitoring framework for the network simulator 3 (NS-3)
Proceedings of the Fourth International ICST Conference on Performance Evaluation Methodologies and Tools
Electronic Notes in Theoretical Computer Science (ENTCS)
An approach to self-adaptive software based on supervisory control
IWSAS'01 Proceedings of the 2nd international conference on Self-adaptive software: applications
Flexible component architecture for information web portals
ICCS'03 Proceedings of the 1st international conference on Computational science: PartI
Verification of multi-agent negotiations using the alloy analyzer
IFM'07 Proceedings of the 6th international conference on Integrated formal methods
Autonomous dynamic reconfiguration in multi-agent systems: improving the quality and efficiency of collaborative problem solving
The .NET primitives for open, dynamic and reflective component frameworks
SC'10 Proceedings of the 9th international conference on Software composition
Time-triggered buffers for event-based middleware systems
Innovations in Systems and Software Engineering
A software component model and its preliminary formalisation
FMCO'05 Proceedings of the 4th international conference on Formal Methods for Components and Objects
A new trust framework for resource-sharing in the grid environment
ICCS'05 Proceedings of the 5th international conference on Computational Science - Volume Part III
MetaService: an object transfer platform between Android applications
Proceedings of the 2011 ACM Symposium on Research in Applied Computation
Toward a programming model for service-oriented computing
ICSOC'05 Proceedings of the Third international conference on Service-Oriented Computing
Software architecture issues in scientific component development
PARA'04 Proceedings of the 7th international conference on Applied Parallel Computing: state of the Art in Scientific Computing
Installing fake root keys in a PC
EuroPKI'05 Proceedings of the Second European conference on Public Key Infrastructure
Exogenous connectors for software components
CBSE'05 Proceedings of the 8th international conference on Component-Based Software Engineering
Finding a needle in the haystack: a technique for ranking matches between components
CBSE'05 Proceedings of the 8th international conference on Component-Based Software Engineering
A component framework for consumer electronics middleware
Component-Based Software Development for Embedded Systems
Adopting a component-based software architecture for an industrial control system: a case study
Component-Based Software Development for Embedded Systems
Defining and checking deployment contracts for software components
CBSE'06 Proceedings of the 9th international conference on Component-Based Software Engineering
A prototype tool for software component services in embedded real-time systems
CBSE'06 Proceedings of the 9th international conference on Component-Based Software Engineering
Towards encapsulating data in component-based software systems
CBSE'06 Proceedings of the 9th international conference on Component-Based Software Engineering
A component-based middleware platform for reconfigurable service-oriented architectures
Software—Practice & Experience
Hi-index | 0.00 |
From the Book:My work is done.I can finally rest, knowing that I have finally put into writing what many have termed the rich oral history of COM. This book reflects the evolution of my own understanding of this rogue technology that Microsoft was kind enough to reveal to the programming world in 1993. While I did not attend the original OLE Professional Developer's Conference, I still feel as if I have been doing COM forever. After almost four years of working with COM, I can barely remember the pre-COM era of computing. I can, however, vividly remember my own painful trek across the COM landscape in early 1994.It took me roughly six months before I felt I understood anything about COM. During this initial six-month period of working with COM, I could successfully write COM programs and almost explain why they worked. However, I had no organic understanding of why the COM programming model was the way it was. Fortunately, one day (August 8, 1994, roughly six months after buying the book Inside OLE2), I had an intense epiphany and at once COM seemed obvious to me. This by no means meant that I understood every COM interface and API function, but rather, that I understood the primary motivating factors behind COM. From this, it became clear how to apply the programming model to everyday programming problems. Many other developers have related similar experiences to me. As I write this preface three Augusts after the fact, developers still must go through this six-month waiting period prior to becoming productive members of COM society. I would like to think that this book might shorten that time period, but I make no promises.As this book emphasizes, COM is more a programming discipline than a technology. To this end, I have attempted to not bludgeon the reader with detailed descriptions of each parameter to each method from each interface. Rather, I have tried to distill the essence of what COM is really about, leaving the SDK documentation to fill in the gaps left behind by each chapter. Wherever possible, I have attempted to address the underlying tensions that motivate a particular aspect of COM rather than provide detailed examples of how to apply each interface and API function to a contrived example program. My own experience has shown that once the why is understood, the how follows fairly naturally. Conversely, simply knowing the how rarely provides adequate insight to extrapolate beyond the documentation. This insight is critical if one hopes to keep up with the programming model's continual evolution.COM is an extremely flexible substrate for building distributed object-oriented systems. To take advantage of COM's flexibility, one must often think outside the constraints of the SDK documentation, articles or books. My personal recommendation is to assume that anything you read (including this book) may be incorrect or woefully out of date and instead form your own personal understanding of the programming model. The surest way to understand the programming model is to focus on mastering the basic vocabulary of COM. This can only be accomplished through writing COM programs and analyzing why those programs work the way they work. Reading books, articles and documentation can help, but ultimately, dedicating the time to contemplate the four core concepts of COM (interfaces, classes, apartments and security) can only enhance your effectiveness as a COM developer.To help the reader focus on these core concepts, I have tried to include as much code as possible without explicitly providing elaborate implementations for the reader to simply copy into their own source code. To ensure that COM programming techniques are also presented in context, Appendix B contains one complete COM application that is an example of many of the concepts discussed throughout the book. Additionally, Appendix B contains a library of COM utility code that I have found useful in my own development. Some parts of this library are discussed in the book in detail, but the entire library is included as a demonstration of how to architect de facto C++ implementations. Also note that much of the code that appears in each chapter uses the C runtime library macro assert to emphasize that certain pre- or post-conditions must be met. In production code, many of these assert statements should be replaced with somewhat more forgiving error handling code.One downside of published books is that they are often obsolete by the time they arrive at the local bookstore. This book is no different. In particular, the pending release of COM+ and Windows NT 5.0 will certainly render various aspects of this book incorrect or at least incomplete. I have tried to anticipate the evolution of the model imposed by the release of Windows NT 5.0, however, at the time of this writing, Windows NT 5.0 has not yet entered its public beta cycle and all information is subject to change. COM+ promises to evolve the model even further, however, it was impossible to include COM+ coverage and still deliver my manuscript this year. I highly encourage you to investigate both Windows NT 5.0 and COM+ when they become available. One rather painful decision I had to make was how to address the various commercial libraries used to implement COM components in C++. After observing the common questions that appear on various Internet newsgroups, I elected to ignore ATL (and MFC) and instead focus on the bread-and-butter topics of COM that every developer must master irrespective of the library used. More and more developers are generating ATL spaghetti and wondering why things don't work. I firmly believe one cannot learn COM by programming in ATL or MFC. This does not mean that ATL and MFC are not useful tools for developing COM components. It simply means that they are not suited to demonstrating or learning COM programming concepts and techniques. This makes ATL inappropriate for a book focused on the COM programming model. Fortunately, most developers find that once COM is understood, the basics of ATL can be mastered in short order.Finally, the quotes that begin each chapter are a chance for me to write whatever I felt like for a small section of the book. In an effort to keep my writing as direct as possible, I restricted my wild off-topic stories to no more than 15 lines of C++ code per chapter. Usually, the code/quote represents the pre-COM approach to a problem or concept presented in the chapter. I leave it as an exercise for the reader to deconstruct my state of mind when writing a particular chapter based on these hints.AcknowledgementsWriting a book is incredibly hard, at least it was for me. Two people who I know for certain suffered more than I did were my patient wife Barbara and my tolerant son Max (who prefers COM to other object models despite his youth). To both of you, thanks for tolerating my absence and generally cranky disposition while I tried to write. Fortunately, my freshly-instantiated daughter Evan was born after the bulk of this book was written and has had a fairly present and pleasant father. A related thanks goes out to all the staffers at DevelopMentor who had to cover for me when I "went dark" to crank out chapters. A lot of my early thinking about distributed systems was formed working for Tatsuya Suda at UC Irvine in the early 1990's. Tatsuya taught me how to write, how to read, and how to deal with unruly train passengers in Tokyo. Thanks and sorry. Thanks to my old office-mate Doug Schmidt for introducing me to Stan Lippman at the C++ Report. Despite Stan's rousing rejection of my first article, I first got my name in lights thanks to you two.Thanks to Mike Hendrickson and Alan Feuer at Addison Wesley for getting this project started. Thanks to Ben Ryan and John Waite for being patient.Thanks to the folks at Microsoft Systems Journal who tolerated my late submissions during the production of this book. In particular, thanks to Joanne Steinhart, Gretchen Bilson, Dave Edson, Joe Flanigen, Eric Maffei, Michael Longacre, Joshua Trupin, Laura Euler, and Joan Levinson. I promise never to be late again.Thanks to David Chappell for writing the finest book on COM available. I heartily recommend that everyone buy a copy and read it at least twice.Thanks to the CORBA and Java partisans and zealots who have engaged me in flame-wars on various Usenet newsgroups over the years. Your constant vigilance has made my own understanding of COM infinitely better. Despite the fact that I still feel many of your arguments are specious and somewhat Martian, I respect your desire to survive.Several people at Microsoft proper have been very helpful to me over the years and either directly or indirectly helped me write this book. Sara Williams was the first COM person from Microsoft I had ever met. Right after explaining that she didn't know Bill all that well, she introduced me to Gretchen Bilson and Eric Maffei at Microsoft Systems Journal as consolation. Sara has always been a great "Box Evangelist" within the big house and I am forever grateful. Charlie Kindel wrote the nice forward to my book despite his heavy schedule and exceedingly regular trips to the barber. Nat Brown was the first person to show me apartments and has irrevocably polluted my vocabulary with the word "schwing." Kraig Brockschmidt explained to me that one particular aspect of COM that looks incredibly elegant was actually a grotesque last-minute hack. Dave Reed introduced me to Viper and listens to my clams each time I visit Redmond. Pat Helland spent the entire week of TechEd 97 twisting my brain and forcing me to reexamine most of my basic assumptions about COM. Scott Robinson, Andreas Luther, Markus Horstmann, Mary Kirtland, Rebecca Norlander, and Greg Hope have been great at keeping me out of the dark. Ted Hase helped me spread the word. Rick Hill and Alex Armanasu did a great job watching my back on the technical front. Other Microsoft people who have influenced my work through their own include Tony Williams, Bob Atkinson, Craig Whittenberg, Crispin Goswell, Paul Leach, David Kays, Jim Springfield, Christian Beaumont, Mario Goertzel, and Michael Montague.The DCOM mail reflector has been a great source of inspiration and ideas for this book. Special thanks go to the following DCOM-listers: the infamous Mark Ryland, COM wunderkind Mike Nelson, Keith Brown, Tim Ewald, Chris Sells, Saji Abraham, Henk De Koenig, Steve Robinson, Anton von Stratten and Randy Puttick.The story in this book has been greatly influenced by my teaching COM at DevelopMentor for the past several years. The story has been shaped as much by the students as it has by my fellow instructors. While I wish I could thank every student personally (Addison Wesley has limited my preface to less than 20 pages), I can thank the current set of DevelopMentor-ites who have helped me refine my own understanding by teaching our Essential COM course and providing invaluable feedback: Ron Sumida, Fritz Onion, Scott Butler, Owen Tallman, George Shepherd, Ted Pattison, Keith Brown, Tim Ewald and Chris Sells. Thanks guys! Thanks also to Mike Abercrombie of DevelopMentor for creating an environment where personal growth isn't stiffled by commerce.This book would have been released considerably earlier had it not been for Terry Kennedy and friends at Software AG. Terry was nice enough to invite me to help with the DCOM/UNIX effort in Germany during the sabbatical I had initially carved out to write the book. While this book is a year late because I couldn't say no to Terry (this is my fault, not Terry's), I think that the book is infinitely better due to the time I spent working on the project. In particular, I gained many insights working with Harald Stiehl, Winnie Froehlich, Volker Denkhaus, Deitmar Gaertner, Jeff Lee, Deiter Kesler, Martin Koch, Blauer Afe, and the notorious Thomas Vogler.Finally, thanks to Shah Jehan and the Coca-Cola Corporation for fueling this effort by respectively producing the most delicious Indian food and soft drinks available. Don BoxRedondo Beach, CAAugust 19974Draft: The Component Object Model - Don BoxThe Component Object Model (final draft) - Don Box5 Copyright 1997 Don Box/Addison WesleyDo not photocopy or redistribute without the express written permission of the author.