ATL Internals: Working with ATL 8 (2nd Edition)

books:


	• ATL Internals: Working with ATL 8 (2nd Edition) (Addison-Wesley Object Technology Series) Christopher Tavares, Kirk Fertitta, ... Addison-Wesley Professional, 2006 - 888 pages average customer review:based on 2 reviews view larger image
	for more information click here

ATL Internals: Working with ATL 8 (2nd Edition)

Most reviews on this book were very good. It was the reason I bought this book. This book covers topic on the ATL 8 as its title says.

However, I don't like this book although I will read this book to the end.
The reason is this. Each chapter discuss about its own topics like strings, and so on. However, it just describes each methods of a given class. It is like that of the MSDN. Why doesn't it show some sample code lines which shows how to use some of them and what the result is? By doing so, it is much easier to understand and read. After reading a few chapters, I started skipping explanations because of the pattern.

Also, just like other books nowadays, it is too descriptive. It will be good if it is a book about explaining concept of the COM, or if it should give some idea on the topic. However, readers of this book already knows about the COM and if they consider "COM", they are already fairly experienced programmers. Then explaining things like the MSDN documents do is not helpful. Probably it would be better if it can explain thing more clearly than the MSDN do, but I guess it is not the case for this book.

Also, what lacks seriously among most COM books is that they fails to describe the automatically inserted macros and their relationship.
Also, for the Visual C++ 2005 IDE, there are some peculiar things. For example, the IDE displays the same interface under class and under interface on its solution pane. You may wonder where to put codes for a certain interface. It could be better if this book explains about them too.

Because COM is designed very confusing way, the Objective-C remote messaging, it needs good explanation. However, this ( and most ) book fails in doing so.

Additionally, it would be better if it has some tutorial chapters.
By following step by step, you can figure out things more clearly, but this book fails in that too. At least the first chapter seems to be written for that purpose. However, it omits some declarations and it is not implied where to put those. So, I gave up writing codes for the chapter.

However, as for the coverage of the topic, it seems to be chosen well.

I know.. people are moving to the C#/C++ .NET remoting.
Nowadays many books on COM/.NET interop are published. So, probably the important of COM is diminishing.
However, COM is still the core of the technology, and I'm not sure if the .NET stands for long-time. Even MS changed things about .NET abruptly so much, and people using .NET seem to use C# instead of C++ generally, I think it is not good idea to rely on proprietary technology. Yeah.. COM is proprietary. But your code using COM doesn't totally rely on proprietary code... at least C++ part...

I hope this book would be improved.

for more information click here

deals with many legacy issues

Tavares and his co-authors present a specialised guide to the latest version of Active Template Library. It's for the C++ programmer on a Microsoft machine, who is also familiar with the Component Object Model. The authors specifically state that you really do need expertise in the latter.

The book deals with various legacy issues, mostly dating back to MFC, which is now largely deprecated. But there are also other aspects that are grubby and mostly unavoidable. For example, when dealing with character types, there is an abstraction called OLECHAR. Under Win32, it maps to wchar_t, while under Win16 [and the Mac] it maps to char. The need for this was due to the hardware improvements that took us from 16 bit CPUs to 32 bits. A transition that occurred mostly in the 80s. But for Microsoft, the legacy code remains in use. So there has to be low level logic that maps the character type to an actual appropriately sized memory allocation.

By the way, don't think this issue is confined to Microsoft. C code from that era that was developed for Unix machines, and which might still be in use, often has a similar problem. C macros dealing with this are a notorious source of porting errors.

The text deals with many other aspects of ATL. Some, like collections and enumerations, are very cleanly done. These classes are inherently meant to be high level abstractions. And the C++ code examples that use these are very easy to follow. The discussion of this also includes some sample Visual Basic code. (Most of the book has C++ code.)

for more information click here