This book is primarily targeted at the professional developer, who is expected to be a C++ programmer with at least some Win32 experience but little or no Component Object Model (COM) knowledge. (At this point it's probably worth saying that I fit the book's target audience pretty well, which puts me in a good position to review it as a teaching aid, but less able to comment on its technical correctness).

Its objective is to teach the reader to develop small, efficient COM components. To this end it promotes the use of Microsoft's Active Template Library (ATL) and strongly discourages use of Microsoft Foundation Classes (MFC). The Standard Template Library is offered as a source of container classes to replace those found in the MFC.

The early part of the book contains an overview of COM and STL and a summary of the reasons for ignoring MFC (large memory footprint and problems with multiple inheritance). However in keeping with the title the bulk of the book illustrates use of the ATL in components for a range of applications, starting with standard COM techniques, moving on to Windowing and ActiveX controls in ATL and then to database applications. Topics covered include:

• Building ATL-based COM clients and servers
• DCOM: remote severs and Security
• OLE Automation
• Connectable Data objects
• Data persistence with structured storage
• Web pages
• Active document
• Test tools
• Database access
• Database back end using OLE DB
• Distributed transaction support using MTS

In general, I found Bates writing style and logical approach to be competent and definitely clear enough to get the message across although several sections that appeared complex at first sight, turned out on re-reading to boil down to something quite simple. Although targeted at a 'no COM required' audience, the main focus of this book is on practical development of 'Components with ATL' and within that the emphasis is more on use of ATL than an explanation of COM. The COM overview provides just enough understanding to make later chapters intelligible; if you are new to COM, this book is no substitute for one of the standard COM texts. STL is also dealt with very lightly.

Although light on concepts, the book has a very practical bias throughout; it provides detailed walk-throughs of the steps involved in creating ATL components through Visual Studio, including frequent screen shots of Visual Studio forms and occasional hints and tips. In keeping with this bias, the book also devotes space to some of the test tools available to exercise components before they are released to a wider community. Although I have not been able to examine the example applications in depth, I am inclined to believe that the advice is sound and based on practical experience. The book is noticeably proscriptive; methods to achieve an end are described in detail, but much less emphasis is placed on explaining why that particular method was chosen or what the design compromises were. Having said this, there are occasional flashes of insight for example, Chapter six outlines the underlying implementation of a Single Threaded apartment model (as an invisible window with a message queue), which is not something I've found described elsewhere.

Overall, the real value of this book lies not in its parts but the whole. If you need 'Lightweight Components with ATL', buy the book, because it explains how to link several different technologies together to achieve a worthwhile end, which is often the hardest knowledge to glean from single-technology descriptions.