COM+ from Design to Implementation
Need to hit the ground running on technologies like COM+ and SOAP? Start with Microsoft Press' Designing Solutions with COM+ Technologies.
- By Paul G. Brown
Open just about any developer magazine and you'll
see some mention of n-tier design, object programming
and scalable solutions. Everyone either is doing
it or wants to do it, and you can't live without
it. A lot of hype? Yes, but there is also a lot
of truth behind it.
For Windows developers, Microsoft provides COM+
(Component Object Model) standard as a way of
developing language-neutral, re-usable components.
Microsoft Press's Designing Solutions with COM+
Technologies is a solid guide to the strategies,
implementation and traps involved in COM+. The
first thing to understand is that this book is
not for beginners.
The target audience is specifically developers
who plan to develop or implement COM components.
From the first chapter, Error Handling, the author
delves into the details with little preface or
background and immediately assumes you know specific
concepts or practices. That he doesn't offer referential
information can be a little disconcerting at first,
but you'll quickly appreciate the benefits as
you see how much detail is available.
Solutions with COM+ Technologies
By Ray Brown, Wade Baron, William
D. Chadwick III
Microsoft Press, $69.99
ISBN 0-7356-1127-0, 891 pages
Part 1, Fundamentals, is somewhat of a misnomer.
You'll be disappointed if you expect to see the
definition of COM and its place in the overall
strategy. Instead the author covers error handling,
concurrency, implementation environments and strings.
If you're a C developer, the error handling section
offers valuable tips on different types to use
for passing errors. If you want to get up to speed
on apartments, threads and transparency in 66
pages or less, start with Chapter 4, Concurrency.
For a section on fundamentals, this book's five
chapters has more descriptive information than
what you might find in most books devoted to those
The conceptual side of COM design is the domain
of Part 2, Architectural Patterns and Solution.
The word architecture is apt - this is where you
develop the blueprint for developing components.
Reuse, streaming and persistence are all topics
that you should familiarize yourself with before
you write a line of code. When you do write code,
you'll have the tools to insure consistency and
stability. You'll even learn how to take out the
trash (without the smell). By the end of the chapter
you'll have all the tools needed to build a framework
upon which to build your applications. Successful
application development begins and ends with planning.
Part 3, COM+ in the Enterprise, moves up another
level so that we are looking at the whole picture
and can plan accordingly. This part explores mapping
n-tier applications to COM and also presents a
four-tier transactional design. Look to Chapters
11 and 14 for much of the data access side of
things including many important interfaces. There,
you'll also find more than adequate coverage of
SOAP and integration of MTS into COM+.
One gripe: This book could use a better glossary.
Depending on your background and skill level you
may not catch the precise meaning of some terms
immediately. I thought the order of presentation
of some topics seemed a bit out of order. Some
of the most basic concepts, such as what COM is,
aren't covered until chapter 6. Plan on rereading
sections to fully assimilate the information.
Overall, this is one of the strongest programming
books available and probably should be in every
developer's library. It manages to strike a nice
balance between high-level concepts and fine-grain
details. There is value for just about all developers
regardless of tool or background. Don't be surprised
if your friends don't want to lend out this one.
Paul G. Brown, MCSD, a developer, speaker, and a frequent contributor to MCPmag.com, lives in New Berlin, Illinois. When not in front of the computer, he can be found chasing Jerry, Wesley, Jordan and Dillon for Mom.