Many years ago, a colleague lent me the first edition of this book, and a copy of it has since been on my bookshelf. When I take a look at this second edition, I immediately recognize that the size of the volume has increased. This additional size is not only used to cover the new features; the old parts of the book have also been improved in several ways.

This book covers the Active Template Library (ATL), a set of templates, macros, and (if Visual Studio from Microsoft is used) wizards that make programming in C++ for Windows a lot easier, and encapsulate several of the tedious details of component object model (COM) programming.

The book starts with an introduction to ATL, presenting a small COM example, discussing the creation of code via wizards, and explaining some of the principles of ATL. This chapter has been vastly improved compared to the first edition (or ATL has).

Chapter 2 explains the peculiarities of strings in the various versions of Windows, and also explains how to deal with them in a compatible and safe way. The next chapter explains the ATL smart types, for dealing with pointers and arrays. Both topics were discussed in one chapter in the first edition, and splitting this into two chapters and extending the explanations is a great improvement.

The next three chapters explain the basics of objects, threading models, and COM servers, and how they are supported via ATL. As is stated in the book, some knowledge about the principles of COM is needed to understand the way the ATL library supports COM programming. In addition, some additional literature is needed to understand the fine points.

Implementing persistence in a COM environment and dealing with collections are the topics of the next two chapters. These chapters have been carefully updated to include the latest information.

The next important topic is connection points. Connection points is a concept that is a bit hard to grasp, because it changes the viewpoint. Usually, a component exposes an interface to tell the world how it wants to be called. A connection point exposes the capability to call other interfaces. This is closely connected to event handling and callbacks.

ATL, being a Windows library, of course also has a lot of support for creating graphical user interface (GUI) layers and GUI controls. This support is detailed in the next three chapters, first showing how to implement a Windows application with ATL. The support for Active X Controls has been greatly improved in ATL over the years, and this is also reflected in this revised chapter, as well as in the next chapter, which discusses containers for COM or Active X controls.

The following chapter is completely new to the book, and reflects the extension of ATL to support Web server components. Although all of the immediately relevant items are covered, this chapter assumes a good deal of familiarity with Internet Information Services (IIS) and Web development on a Microsoft platform.

The last two chapters are completely new, and the final chapter is largely of academic interest, because attributed ATL never worked as intended. The appendices consist of a short tutorial on understanding C++ templates, a list of the relevant ATL header files, a chapter on the major changes in ATL 8, and a chapter on attributed ATL.

The second edition of this book has again confirmed its status as the ATL bible. The book has become even better to read, and the examples have been carefully updated. The only disappointment is the near complete negligence of .NET. It would have been nice to read a few views on how .NET ties in with COM and ATL.