Customer Reviews

Building Applications with Microsoft Outlook Version 2002 (Pro-Developer)

5 star:		(1)
4 star:		(2)
3 star:		(0)
2 star:		(1)
1 star:		(2)

 

 

The only significant criticism I have of this book is that I have to agree, it is indeed very, very similar in content and organization to its predeceessor, "Building Applications with Outlook 2000." For those who also purchased the earlier book, there is a queasy feeling of having bought the same book twice, even though Byrne's version does contain updated content. Microsoft should offer a healthy discount to those people who bought both books.

Criticism in other reviews focus on minor details seems to me to nitpick on irrelevant details, while ignoring the fact that Byrne exhaustively discusses Outlook programming with Visual Basic and VBA, including Outlook functionality and the use of the Outlook Object Model (and CDO as well as a little MAPI as relates to Outlook programming). The book is filled with relevant explanation and analysis (not just minimalist captions or code comments, or explaining the obvious).

For a book of this size and scope, a certain number of errors are inevitable. I'm surprised there are so few.

An absolute beginner with programming would probably find this book took too difficult. On the other hand, it's ideal for someone who is familiar with Visual Basic and wants to program Outlook. Byrne discusses the structure and implementation of Outlook (and CDO) methods, properties and objects in sufficient detail to be useful even to an advanced programmer who needs a good Outlook intro and reference with sample code.

I am currently reading this book for the third time, and would like to add my opinions to those of the others here.

Byrne admits in his introduction that he had a difficult time completing this book because of all the security restrictions that MS has placed into the Outlook object model. Clearly, it was a blow to many developers, Byrne included, when MS did this. But as Byrne concedes, MS really had no choice. Byrne discusses strategies for circumventing the security restrictions throughout his book. Byrne is a likeable guy: he's not arrogant, and it's clear that he knows his stuff.

There are a number of subtle and confusing points that must be understood when designing an Outlook application. One example is the concept of "one-off" forms. Do you store the form def in an organization's form library, the application's public folder, or do you send the form def with the item? Byrne does an admirable job in discussing the distinction, but it may take several readings to fully understand it, and the implications behind it. Because of the security restrictions, VBA code will not execute in an one-off form. So, pitfalls abound.

Contrary to what one reviewer has stated, the Outlook object model is discussed in minute detail. Unfortunately, you won't find it until you have gotten through hundreds and hundreds of pages of relatively introductory material, some of which is prone to repetition. That is one of the biggest weaknesses of this book: too much repetition in the early chapters. One example: we don't need to know how to publish a form more than once, but there are at least three step-by-step examples of how to do this.

The structure of the book is such that the early chapters are oriented toward beginners and the later chapters toward more advanced programmers. That is as it should be. But I have to agree with other reviewers who have criticized the beginning chapters of the book as being just too elementary, too repetitious, and too sophomoric (eg, that silly vacation request form).

Overall, I came away from this book feeling Byrne's enthusiam for the Outlook object model, as well as his acute disenchantment at the new security restrictions that have been built into Outlook. This book was published before .NET was finalized, so criticism that it doesn't contain .NET material is unfair. I agree that the book is way over-priced.

Althought this book provides some very useful subject matter, the sample code provided is written in Visual Basic 6.0 rather than the new Visual Basic .Net - a fact that was rather dissappointing given that this is a version 2002 book. Since converting complicated code like comm add ins from 6.0 to .Net is no easy endeavor, I'm finding the usefulness of this book pretty limited for my purposes. If Mr. Byrne will write the same book with .Net examples or if Microsoft and Mr. Byrne will release an updated companion CD with .Net examples, the book and its companion CD will be a lot more helpful.

This is a tired old rehash of a previous book - and even uses the OLD Northwinds samples. You'll find more on Sue Mosher's site slipstick.com.

Sorry - but Save your money....

The following is a list of reasons why you should not read this book:

a) The author uses words such as "granular", "parity", "reconnaitre", and "enigmatically" (see page 422) that only prove that the author possesses a decent vocabulary. Instead, the author should have used more commonplace synonyms for each of these words and kept in mind during the writing process that he was supposed to be writing a technical book - not a novel.

b) The author frequently refers the reader to examine online help to get more information about subjects such as the Outlook object model and VBA that should be covered in depth within the book.

c) If the book were torn apart into two separate halfs and the first half was properly tossed into the nearest garbage, the reader would be getting rid of really basic information that should not have been included in a book that is entitled "Building Applications with Microsoft Outlook Version 2002."

d) There is redundant coverage of topics in the book word for word.

e) In several examples, the author uses Select...Case statements (see page 369) instead of If...Then statements when less than 3 conditions are being evaluated. In addition, with respect to how he writes the beginning of If statements in several examples, he uses the format of "If x Then" instead of including "> 0" or "= True" to enable his code to be more readable. Similarly, he also omits code in other places when a default property is available.

f) Technical errors (see pages 359, 365, and 375.) Note: since a non-executable file can include ".exe" within its name before its file extension, the author failed to realize this when he wrote the second example on page 375. As a result, the Right function should be used instead of the Instr function in the example.

g) This book is overpriced, since dedication to quality clearly were missing from the author and the editors that worked on this book.

I decided to write my own review because that book is not Terrible but Terrific. First of all I am not an Outlook-guru, I am a beginner developer and user, I am not really into Outlook and I only wanted to know more about developing a COM Add-In. Yes It's a technical book but It doesn't mean you have to write it the technical way. It's a book for beginners, not for experts, which means that everybody can understand it, common words in common places for everyone. First you're introduced to Outlook development, then the author goes deeper with some case studies. The coding style is quite good and there's no need to complain about "shortcuts" (If x Then instead of If x > 0 Then)... There's no perfect coding style, good explanations and good examples are more important. I don't think that It's such an expensive books, It covers, in 700 pages, all the topics you need to design and develop professional Outlook Add-Ins and Applications. I gave it 5 stars, even if It's not that perfect. Just Buy It!