Richard Grimes | Alex Stockton | George Reilly | Julian Templeman
The Active Template Library (ATL) is the part of the Microsoft Foundation Classes (MFC) used to build reusable and very efficient components in C++. Achieving this efficiency can be difficult, as it requires you to delve into the details of Microsoft's Component Object Model (COM) and ATL itself. With
Beginning ATL COM Programming, however, it should be possible for any C++/MFC programmer to become productive with this exciting component technology.
The book begins with the basics of COM programming, featuring good details on the actual Win32 APIs used throughout COM programming. (This section also discusses the basics of the component definition, including Interface Definition Language [IDL] and related conventions.) While higher-level classes in MFC make it easier to build COM components, you'll have to do most of the work yourself if you're building lightweight ATL controls. The authors cover such ATL topics as event handling (with connection points), automation and error handling, and properties and persistence for ATL-based components. They use plenty of short, effective code examples throughout this tutorial to illustrate key concepts.
The book closes with an example of Internet Explorer ATL controls (which are leaner) and "full" controls (which can be reused in such applications as Visual Basic). The world of ATL development is rough terrain, but the team of authors here succeeds in explaining a difficult subject clearly. --Rich Dragan
1 Descent but outdated
I recently ordered this book, and I am currently on chapter 7. If you are looking into ordering this book make sure that you are fairly experienced in c++, and confident with your skills. Also this book is out of date sometimes I ran into trouble because the examples were based on vc++ 5, and i'm using vc++6 and/or vs.net so it would send me lookin on how to implement the examples on modern IDEs. So I would definately recommend ordering Beginning ATL 3 COM Programming, instead of this one.
All in all I have learned from this book. It is definately not for the timid, but for those who are serious about learning, and have fair programming knowledge already. I have just ordered the ATL 3 version of the book so hopefully that will go a bit more smoothly then this read. You will see my review for that book in time.
2 I am sure there are better.
Chapter 2 was just way too intense. It threw way too much at you, way too fast. I was left feeling overwhelmed, and frustrated. After reading chaps. 2 and 3 four times, I was able to proceed, but chapter 7 proved a disappointment when the example wouldn't work. I even downloaded the code off the site, and checked the errata online, to no avail. When the samples don't even work...well that's never happened to me before. It just didn't work.
I was sticking with the book, because although it wasn't ideal, it was getting the job done. But I am fed up. I am shelving the book, and looking for something else now.
3 How could anyone rate this book poorly?
This book was one of the best that I have read on a particulartopic...
The authors provide a lot of instruction about how to readthe book, recommending, for example, that you read through the chapter before actually attempting the examples. This is, of course, a standard recommendation (which in my experience many readers of technical material do not follow). Following this advice, I found that the authors were correct, and the material was far more understandable.
I am NOT a proficient C++ programmer.
Yet by the end of the book I was able to create my own bug-free COM server with a full object heirarchy including a collection. I had been unable to understand implementing collections in C++ with other books.
My intent was to have a C++ COM server so that I could hook up a VB client and study the interaction of the two at the lowest possible (for me) level. I wanted watch calls to QueryInterface, watch reference counts increment and decrement. I wanted to see how COM objects were intialized and destroyed.
I succeeded, thanks to this book. END
4 not for beginners
This book gives a serious coverage of ATL COM that will repay readers' efforts. It's far from easy, and the organization could be improved in places. For example, I'm one of those people who absolutely has to know what's going on "under the hood", but the implementation details come a little early (in Chapter 1). Had to experiment with the order of interface entries in the idl file and think a lot about vtables, interface pointer casting, multiple inheritance, and so on before I began to understand what Chap. 1 is all about. Some more explanation at judicious places in Chap. 1 would be helpful.
To get the most out of this book, download the code from Wrox and fool around with it. This book really covers the nitty gritty of developing ATL COM projects from scratch. Marshaling, threading, connectable objects, persistence are discussed, and a full control is built in Chap. 8.
For some reason, perhaps because the word "beginning" appears in the title, Wrox ranks this book below Professional MFC in difficulty (see the flow chart on the back cover of the book). Actually, it's quite advanced and belongs at the top of the hierarchy. I think it's more detailed and difficult (but also more rewarding) than other books on the subject.
5 Very confusing!
The book is presenting a lot of stuff, but the way the information is organized, is very confusing. Totally unrelated subjects are bundled under the same chapter! Also, the authors keep using all kind of words without ever explaining them. On the bright side, the examples do work and you get a sense of what is going on.
6 Examples are terrible
The examples are interleaved throughout the book and it is very difficult to know if you should type something in or just view the code. The object/application/project names used in the examples, make the examples extremely confusing. Not a good book.
7 Read another book
As a VC++ and VB programmer, and the attempted reader of this publication for several months, this book never ceases to amaze me at how thoroughly poor it is in several aspects. I was perplexed by the detail that was covered by the first few chapters - immediately the reader in confronted by implementation details without first explaining the overall concepts. It seems as though the authors, have munged theory, tutorial, and reference together in each chapter, which unfortunately serves only to confuse rather than demystify ATL and COM. Other COM books take different approaches - chapters alternating between theory and practical tutorials. My biggest criticism is that seemingly straightforward concepts are explained to death, whilst the more complicated features are explained extremely poorly.
I fear this book has definitely suffered from the 'too many cooks spoiling the broth' scenario. After a while I sought comfort in other COM pulblications for VC++ and VB, both from WROX and SAMS, which proved considerably better.
8 yuck
this book is horrible. i find it hard to believe that grimes contributed to this book. whether you're a beginner or not, check out grimes' excellent book "professional dcom programming" instead.
9 VERY Confusing
This book was very confusing for me, and I am VERY fluent in C++/MFC. The authors used a LOT of really big words that I had no clue what they meant, without defining what they meant. I feel like they didn't sufficiently explain some of the core concepts, such as what an interface is, what a method is, why you would have 2 interfaces in 1 COM componet, etc... The chapters were too long and should have been broken up into more short chapters. They covered several subjects in each chapter. I think that the authors are very bright people who understand COM very well, and when they wrote this, they read it and said, "That makes perfect sense..." without having any newcomers read it.
10 Great book
This book reads like a novel. After reading 'Beginning Linux Programming' 2 yrs ago, I had no respect for Wrox Press because of lack of details, however, this book was a fantastic one. But then again, I have read "Inside COM" and "Essential COM" prior to this reading. If you have a good understanding of how COM works, get this book. It is an awesome intro to ATL. Check out "ATL internals" & "Proffesional ATL COM programming" as well if you are a serious ATL developer
11 Not for beginner
Chapter 4 ATL Architecture is terrible. It's not for beginners. I almost give up from here.
12 good for someone who has known MFC and COM
I can imagine how hard it was for the reviewers before me. I actually had a hard time when I tried to learn com and atl using this book. I could not get through to chapter 2 even I understood VC and MFC. after I read Inside COM, I come back to this book, Gee! it makes sense. good luck!
13 Definitely not for BEGINNER...
The "Beginning..." in the title is really misleading . This book is not for beginners . I did not even get past chapter 1, and this is from someone who feels very comfortable with VC++ and MFC .
14 Good book if you know COM concepts and want to learn ATL
If you want to learn COM concepts, no other book beats "Essential COM" by Don Box. But if you want to do some real coding with the help of ATL, you need this book. I started this book when I did not know COM, and found it hard to grasp the concepts and learn the code at the same time. Then I turned to Essential COM, and come back afterwards. I found that this book would really get you going in terms of how to code COM. Great book.
15 prereqs: WIN32 and C++ ( no MFC or COM knowledge needed)
I have now finished reading this book - and am chuffed about how I am now traversing with ease various ATL examples I have found on the net. I give it four stars. Prior to reading it, I had no COM experince and no MFC experience (only win32api and c++).
BAD BITS: Like other readers, I found the chapter 2 client-from-server-wizard bit to be unsuitable. At the time I was still trying to grasp the main concepts. I just skipped that bit.
And also, perhaps the chapters are a bit long, they cover alot in one chapter.
GOODBITS: Comprehensive - for me, this book left no questions unanswered. If you reread a section you will eventually understand it. I constantly annotated with a pencil things such as "see pagexx", "see pagezz", But its all in there!
Well chosen examples - they like throwing in examples that expose the little technical quirks that I assume will be hard to figure out unaided. It is true that this would make a good reference aswell as a learning guide.
Technical detail - I like to know what is actually going on behind the scenes, and in all those macros. This book told me.
I thoroughly recommend this book for those with no MFC or COM experience. I would recommend re-reading chapters if you get lost. The examples aren't that important, (I think I did about 4 examples all up). Goodluck - its challenging, but what you are capable of when you get to the end is quite impressive.
16 Good initial book on ATL & COM
This is a good introduction to the world of COM and ATL. ATL is designed to do a lot of the tedious parts of COM programming for you. This book fills you in on both. It is not for the neophyte. You need to have a good grasp of programming before this book will help you, but it is a good place to begin if you already know C++ and need to come up to speed on COM.
17 The title is misleading
This is a reference manual for COM programmers who already know how to program with the Active Template Library. Hoping to learn ATL from simple concepts to advanced techniques, I quickly found this book disappointing, because the advanced material begins at around page 20.
Incidentally, I found the synopsis of the book description here on Amazon rather amusing: "The Active Template Library (ATL) is the part of the Microsoft Foundation Classes (MFC) used to build reusable and very efficient components in C++." From what I can tell, ATL was designed as a lightweight ALTERNATIVE to MFC, not a PART of it!
Summary: Difficult book to read. Not at all for beginners. More of a technical reference manual.
18 Not a beginner book
I got about half way through it and found myself skipping more than reading. Few examples, too much talk about obtuse data structures that even after the description I was left wondering if it was important. Just not enough teaching. The authors need to learn a key axiom of writing: show don't tell. Might be a good reference book, however.
Chapter 2, learning basic ATL was great, but after that the book went south. If you are new to COM or ATL try another book.
19 Wait for an updated version
This book was targeting VC5.0/ATL2.0. Some examples badly work with VC6.0/ATL3.0 : especially creating - and destroying ! - a modeless dialog box in an exe server, and connection points implementations when client and server are ATL based.
I also agree with other readers about the rather convoluted organization of this book, and the strange mix of simple explanations and deep thoughts on ATL that keep me confused about its usability.
20 Not for beginners to COM
This book might be appropriate for someone who already is very familiar with COM, but it is by no means good for beginners. I bought it thinking that it would get me started, but it only made things seem more complicated. Once I had read another book on COM, I began to understand some of the contents of this book. Of course, then I realized how poorly organized and written it is, so my opinion didn't improve much.
21 Good for a jump start into the Worl of ATL...
This book really did help me to gear up for the ATL/COM project. It took a while, but gave a solid insight of the ATL architecture. I had a few questions which were difficult to find in other books which were revealed pretty neatly in this book. If you are an experienced C++/Windows programmer and want to start of ATL-COM, this book is the best bet. Just with this book alone, you will reach from the beginner to the Intermediate level in a jiffy. Of course you are better off buying other books, but this one is highly recommended if are about to embark into the world of ATL.
22 Not for beginner
This book is not for a beginner who wants to learn ATL Com programming. It is badly organized. Sometimes a reader will not know what the author is talking about. Especially for a beginner. If someone wants to learn something about programming Atl Com, read other books instead this one.
23 Spectacular work
I don't know how the other readers could possibly get a bad impression of this book. I'm only about 200 pages into it but I must say that it is truly masterful. There's no place in the book where the authors have you run through the ATL wizard and delete most of the output. There is a place where you delete some of the output, but it's because the authors are teaching you how to think _beyond_ what the wizards are capable of. The book is extremely detailed and for someone who really wants to understand how ATL works underneath, rather than just how to do a few things with it, this is definitely the book. If you're looking for a book that you can just open up to the middle and copy some code to accomplish some task at work there's probably a better book, but for those with the time and the desire, this book will really get you up to speed on _how_ ATL does what it does. As an example, the authors discuss in serious detail the macro expansions for all those macros the wizard throws out all over the place (MFC programmers know the kind of macros i'm talking about too). I highly recommend this book to anyone looking to gain a solid foundation for programming in ATL.
24 Poorly organized and realized
To much digging needed to find the few jewels here. The organization of the material is what hurts this book most. In chapter 2, after a brief intro into ATL and COM, they launch into the implementation of an ATL client, which consists (I'm not making this up) of running the ATL wizard and then deleting most of the output! It doesn't get any better further along, either. I recommend reading another title. Any other title.
25 to many cooks spoil the .....
I read this book after reading "Inside Com" and "Beginning MFC/COM", which were both very good. This book is very confusing. Its very difficult to follow the author(s) logic and they get frequently to in-depth for a beginner book. The examples should have been less in-depth as far background and technical specs go, and they should have applied more hands-on examples. It seemed as though they all took turns writing a paragraph and then passing it on because its not easy to follow.
26 Problem in the book
The example on page 296 when executed, Visual Basic gives General Protection Fault But this runs through Test Container
27 Excellent "How To" ATL COM book
This book gives excellent coverage on the "How To" of ATL COM (It doesn't spend too much time on what COM is - get the Don Box Essential Com book for that). Nice coverage of ATL without the overhead of MFC. Uses VC++ 5.0. The Wrox site contains info on using this book with VC 6.
28 A reasonable COM reference but too technical for beginners
This book fails in its task to be for 'Beginners'. I actually found the more advanced 'COM Applications with ATL' book a much easier read.
Way too much hard technical facts and not enough simple explanations or higher level concepts.
The first Professional Series book I found a disapointment.
29 Trival examples further confuse a complex subject
I know COM is "where it's at", and I'm trying hard to find out WHY. Namely, why it's good to use 100 lines of code to do what 10 used to do, to say nothing of IDL and ODL compilers. Is COM really a sinister plot to make software development so bizarre and complex that only Microsoft can do it? Anyway, I bought this book looking for enlightenment, and didn't find any. The authors seem enamored with COM theory and terminology, but show no feel for practical use. The example they build (aptly named "Simple") is a trivial stateless object with two properties and NO METHODS! On page 56 they dismiss MFC because it "makes the server too big" and "requires the proper libraries to be loaded" (paraphrased). Welcome to the world of computers, Dr. Grimes! I plowed through the examples, working them on my computer, and finished with about the same level of practical understanding of how and why to use COM as I started with. Part of the problem may have been my going-in attitude toward COM. Anyway, I'm ordering some more titles, and hope for better results next time.
30 An excellent guide to writing COM code using ATL.
This book was a real find! I found the programming examples understandable and the material presented in an appropriate fashion. For example, in Chap 3, the author(s) recommend that you browse the material on some of the obtuse macros and templates behind ATL; try the examples near the end of the chapter; then come back and reread the difficult passages. It worked! I have rarely come as far in understanding through just one book. And thank you Wrox for maintaining such a useful Web site!!
31 Gives one a real clue! (Actually 4.5 stars)
This book was the one that unlocked the "mystery" of COM for me. I find that it and other WROX beginner books are good when you've read the technobabble of others and still need more of a feel (and examples!). After reading this book, one can go back to the theoretical, intentionally intellectually impressive books for the rest of the story.
The only downside was that there were no really detailed C++ examples (e.g., a COM object using another COM object).
32 Pan. Obtuse, obscure, incoherent definitions
I found the book obtuse. I still don't know what COM is or what it's good for or what ATL is or what it is good for. I found it amazing that I could work through the examples, compile and execute the example code, and still be mystified. The lack of useful definitions of the obtuse terminology doesn't help either.
33 A good way to ease into a complex environment
ATL addresses the typically overweight Active-X components that carry around unnecessary MFC baggage. Being template driven, it provides a set of problems new to C++ programmers who have become comfortable with the MFC classes. COM is also a science unto itself (see Inside COM, Rogerson, MSPress). Here we have a set of authors who KNOW how complacent a lot of Windows Programmers have become. They introduce you to the ATL paradigm and show practical applications of this new technology. I found it extremely useful, even though it was a little scant in the DCOM arena. A good intro. You may want to look at the Professional DCOM book (when available) if you've already burned this bridge.
34 Excellent Introduction to ATL
This is one of the best introduction books I have ever read. The writing is clear and concise, and amazingly, appears to be error-free! I have also read some of Grimes' DCOM book, and I am impressed with his knowledge and his writing style. If you're attempting to use ATL, get this book!
35 Very Good Start for ATL
This is a very good book on ATL.This book gave me confidence of programming with ATL.It deals with ATL Architecture to using Windows controls in ATL framework.
36 This book is a very good introduction to ATL
This book is clear, well-written, and concise, and provides a very good introduction to ATL. The examples are straight-to-the-point, accurate, and explained well. It covers all the basics of ATL. Programmers wanting to write ActiveX controls with ATL would do well to start with this book, then move on to "ActiveX Control Programming", also from Wrox Press.
37 very good hands-on book
This is a very good hands-on book. I read it with Inside COM. The two books make a good pair since Inside COM is more academic. Beginning ATL COM Programming made developing ActiveX objects very easy and understandable. I am looking forward to the "professional" version.
38 Excellent book that really covers the topic
I'm usually leary of books with many authors. I'm afraid they're just thrown together to hit the market quickly. Not so with this excellent book, which had just what I wanted for learning ATL. Plenty of examples, under-the-hood coverage of ATL, good coverage of the many aspects of COM and how they're implemented in ATL, and a final fun full control example (treeview of URL's for use with IE4) that could actually be useful. The writing is excellent, with explanations of all the macros and such, and I've yet to find an error. The only thing that makes this a "Beginning" book is it's thin coverage of threads. But then, supposedly Dr. Grimes is coming out with a Professional ATL COM programming book to cover this and more--I can't wait.
