Customer Reviews

Inside Com (Microsoft Programming Series)

5 star:		(60)
4 star:		(22)
3 star:		(8)
2 star:		(1)
1 star:		(5)

 

 

Ok, this is the skinny on COM:
1) COM is hard
2) you will not learn COM by reading only one book
3) attempt COM in stages: read about it, use someone elses servers, write your own
servers, write your own servers in a multi-threaded environment

To learn COM you must take weeks of expensive courses or read these books in this order:
1) "Understanding ActiveX and OLE": optional; easy read but recommended
2) "Inside COM": strongly recommended; if you really appreciate "Essential COM" without reading this first you are smarter than I am
3) "Multithreading Applications in Win32": strongly recommended
4) "Essential COM": essential; once you have your COM bearings read this book, then read it again in 6 months to realize how many details you missed the first time
5) "Beginning Atl Com Programming": recommended
6) "Effective COM": optional
7) "Essential ATL": optional
8) "Inside OLE2": optional, for brave souls only

Whew! That is a lot but it all really is required. If you attempt shortcuts or read the books out of order, you risk being crushed by someone who really knows COM. Oh yeah, you must also know C++ cold, suspend your beliefs about C++ objects, and be open to the idea of distributed components. Good luck!

This is much more than a COM book. The book spends a lot of time in the first half talking about the more general concept of interfaces, which is more of a software design topic. Then he shows how to implement those interfaces using C++ abstract classes and gives a very good discussion of inheritence, polymorphism, and virtual function tables. Everything is done in pure C++ so you can see what is going on. No wizards or macros to hide the details. The diagrams were very helpful.

Even if you choose to not use the COM architecture for your software the discussion of interfaces will help you write software of much higher quality. Seeing how the interfaces are implemented and the discussion of inheritence and virtual function tables gave me a much better understanding of the C++ language.

The key to understanding COM is understanding interfaces and this book does a very good job explaining them. Eventually when the author gets into the Microsoft specific COM library you can see how those chapters build on the earlier chapters. You can see how a program can evolve from a set of inflexible C++ classes, to some compile-time flexible C++ classes that use interfaces, to run-time flexible components using DLLs, and finally a full blown COM component.

Near the end of the book it is not as thorough with the examples but that is because the topics presented there are too large to fit in a single chapter. The first 8 chapters are worth the price of the book.

If you are new to COM or know very little about it, this is the place to start. It explores the infrastructure without overwhelming the newcomer and gives very convincing arguments about why a specific component is there and how it ended up so.

Keep in mind that one way of looking at this technology is to see it as an improvement on C++. (For this I call Don BOX to witness stand [1st chapter of 'Essential COM']) Also, don't forget that C++ is the implementation language of MFC and ATL frameworks. Hence the tendency to emphasize C++ in such technologies and (Micosoft Press) books.

If you can't stand C/C++, I suggest that you grab one of those 'Active ... with Visual Basic/ Visual J++' books. These languages make the use of some aspects much easier, e.g. garbage collection, exception handling. But then again can you claim to know an architecture without getting your hands dirty with its assembler? I guess not!

When you finish reading this book, if you think you can take more serious stuff, make sure you check out Don BOX's books: 'Essential COM' and 'Effective COM.'

This is a remarkable book for those who do not want to feel like a dummy looking at the stuff produced by a code generator (a so-called Wizard). This books explains everything, from why a C++ generated virtual table complies with COM specifications to the threading models of COM. This book will serve you best if you follow it letter by letter and develop base classes for your development according to the author. Then try to use standard ATL Wizard from VC++, compare its output to what you have learned and you will say to yourself: Ha! I know what is done and why! You will also get a feel that the author could have been the one who created the ATL Wizard. Even a complete example from this book, TANGRAM, bears the same name as a VC++ example. However unless you really have to develop very customized stuff I would recommend Wizard since it does all the work of the numerous component registrations for you and handles all compiler and linker switches. Also the book uses makefiles, so if you like IDE, you will feel slightly uncomfortable. It is also an excellent C++ tutorial on multiple inheritance and class libraries. A lot of C++ details are explained along the way. You will be a much better C++ programmer after you are done with the book

A great look at COM under the hood. The style is clear and friendly, and the code is very well-written and documented. The author starts the first chapter with an excellent introduction that establishes the merits of COM as a component technology as well as the benefits of component-based programming. The following chapters continue with the development of COM Components from DOS command line programmes to fully-working COM Dll's.

One of the great things about this book is how the author endeavors to explain the cryptic and confusing terminology of COM. I especially enjoyed the explaination of the concept of COM Apartments, which is the best treatment of the subject that I came upon to date.

One has to keep in mind that this book is about COM, and just that. Active X controls are barely touched upon. ATL is not used at all. Instead the author builds his own light-weight library of classes, and that is the only drawback to the book that I can see.

It's a great book for understanding the enternals of COM, but you'll probably need another to cover ATL, which is largely the standard library for writing COM and Active X components in C++.

This book starts out with a simple C++ class called by some other code, and works to encapsulate it into a component, basically implementing COM from scratch. This really lets you understand how it works and why. It's well written and does a good job describing all the details.

As others have mentioned, this is not a book about ActiveX, OLE, ATL, or any of that, and it doesn't pretend to be. This book just describes COM, the basis for those technologies. If you want to really understand what's going on with COM, I highly recommend this book.

If you want to learn COM in C++, this book is DEFINITELY where you should start. If you find COM difficult to grasp, don't worry, it is most likely because you haven't learned from the right resources, or you haven't read this book.

This book really covers all the essentials of COM programming. The author does a great job in making COM simple to comprehend. For instance, the author takes you step by step in every step of the way in every detail that required for you to get your hands dirty with code practises. Not only the explainations and code samples in the book are CLEAR, they are also backed up with diagrams on topics that are just can not be dissolved by words alone. Nicely done!

If you were to take COM in University, this would be one of the two books required for the course. "Inside COM" would be for COM 100, and "COM and ATL 3.0" would be for COM 200. So if you want to learn COM in C++, these are your BEST BET. They get you started coding immediately, they provide all the required fundumentals, and best of all, they both are well written with NO mumble-jumble space filler!

TIPS: Atfer you done with Andrew's book, go back and read Dale's book on chapter twelve - "Multiple Threads". See how much you had missed, and how everything ties together.

Books starts with very basic expectations of reader level and ends with 400%. ActiveX covered? Where? OLE? Author sends you for details about it to another sources. Pretty much nothing about IDL, marshalling, multi-threading (just take the things as they are). That's not a way such book should be written. Just gives you very general picture of what is COM. Remove the word "inside" from its name.

1) Know C++ 2) Know Visual C++ 3) Spend Time Reading and Re-reading 4) Prepare for mistakes in the book

This book is decent until half way. Then, the mistakes are many and gets worse as it goes. The worst part is that the examples use makefiles that you can't understand. This is okay until the examples get more complex and then the author stops explaining the projects. The author should include .dsp files, but doesn't. At least, he should explain the projects so I have a chance at building the examples later in the book. My favorite quote is on page 211 "First, we'll use C++ classes to make using COM components more like using C++ classes." My second favorite quote is on page 287 "The first three (parameters) are easily explained... The third parameter holds localization information." Dale never again mentions "localization", so I guess it was easy for him to explain.

A very easy and useful book. The book doesn't use complex C++ or compiler specific features or MFC. You need to know only about classes and a little knowledge of Win32 programming. It also explains the COM concept and how it can be used for operating systems other than Windows. I liked chapter where the author showed in few steps how to create a remote COM object running on different machine using DCOM. This book is essential if you want to learn COM