Whenever I see a huge tome weighing in at 1,000 or more pages (1,176 pages of usable material in this case), I begin to wonder how many of those pages are filled with fluff. The answer is not many in this case. Rod has packed every chapter with useful programming examples of every kind imaginable. In fact, the book contains so many examples, that the author has thoughtfully provided an appendix listing them. The one or two line entries go on for 20 pages—that’s right, it takes 20 pages just to list the example title, a short description, and a page number. Consequently, when you think about this book, think about the examples.

What is it all about?

The book begins with the standard view of the IDE. It’s not unexpected in a book of this kind, but I commend the author for spending only a few precious pages on the topic. The 100 or so pages tell you about the various IDE features from a Visual Basic.NET perspective and provide some tips on debugging your application. The IDE coverage is complete despite the limited number of pages because Rod uses the page space efficiently and relies on a somewhat terse writing style in this section.

In the Getting Started portion of the book, Rod definitely focuses attention on the needs of the higher end beginner and lower level intermediate programmer. Rod takes his time discussing the use of Windows Forms and associated controls, Windows Presentation Foundation (WPF) windows and controls, database controls and object, and numerous essentials about data types, constants, operators, and the use of subroutines and functions. This is also the section of the book where you’ll find the essentials on error handling and the use of custom controls. The author rounds the Getting Started portion of the book out with chapters on Language INtegrated Query (LINQ) and User Access Control (UAC) security. Overall, this is the largest section of the book at 440 pages.

Part III of the book looks at Object-Oriented Programming (OOP). Rod opens with a chapter on OOP concepts that looks deceptively simple at the outset, but ends up pointing out some major issues with the way Visual Basic.NET handles OOP requirements. Other chapters discuss the use of namespaces, collection classes, and generics. Overall, this part of the book appears to meet the needs of intermediate to lower level advanced readers. I think that beginners may get lost in some conversations if they open immediately to this part of the book and expect to learn what they need to know. Rod does cover the basics the reader needs in the other parts of the book.

Most applications today require some level of graphics programming and many developers lack the required skills to provide a great presentation. Part IV is one of the areas of the book that really shine because Rod takes a topic that is notoriously difficult and makes it appear relatively simple. The discussions provide everything the reader needs without getting laborious. It’s true that some graphics topics aren’t covered—you won’t be able to create a game using the techniques that Rod provides because he doesn’t discuss topics such as texturing and sprites. However, if you want to create great looking business graphics, then this part of the book provides everything you need. I especially appreciated the fact that Rod spent an entire chapter discussing printing—a topic that many authors seem to be afraid to tackle in any depth. Lest you think that this chapter incorporates use of Crystal Reports in it, the use of reports actually appears in a separate chapter, so you get great printing coverage and a separate chapter on working with reports.

Part V discusses techniques for interacting with the environment. Of course, the first chapter begins by looking at configuration and resource management. Rod moves on to working with streams, the file system, and the Windows Communication Foundation. This part of the book ends with a chapter on useful namespaces. This last chapter is actually somewhat handy. If you’ve ever spent time looking through Microsoft’s documentation for the right namespace to use, you know it’s frustrating. Rod’s documentation of the namespaces take out a lot of the frustration and makes finding the right namespace easier than looking through the Visual Studio help files.

At this point, the book moves into a new part that consists entirely of appendices labeled A through V. That’s a lot of appendices—more than any other book I own. These appendices provide information on topics that range from using control properties, methods, and events to file system classes. Some people might argue that all this information should appear in the chapters, but I think the author’s handling of this resource is great. By drawing all of this reference information out of the chapters, he makes the information easily accessible in reference form. The appendices won’t replace the Microsoft documentation, but that’s not their purpose. In most cases, Rod concentrates on the question of, “What will I use most often to create business applications?” Consequently, using these appendices help you cut through the excess information in the help files and locate what you need quite quickly.

Is this a good book?

Whether this is a good book depends on your needs. I think that if you’re looking for a comprehensive book for most business programming tasks, you really can’t do better than this book. Rod covers all of the business topics that you expect and a few that you may not realize you need until you try them. All of the topics receive the kind of coverage that you may have wanted in the past, but didn’t receive. The author makes sure to provide the detail required to create a comprehensive and useful application. As previously mentioned, there’s even a full chapter on printing that provides full coverage on the topic, rather than attempting to do something simple and then leave you in the lurch.

A single book probably can’t cover every need, even if you limit the scope of that book to business topics. In some cases, you’ll want to augment the contents of this book with a specialized book. The database developer will want to get a database-specific book and you may find other technologies where a topic-specific book would be helpful. Graphics designers may find some topics lacking in this book—I’ve honestly seen some graphics tomes the size of this book and they still don’t manage to discuss every topic. Overall, however, Rod covers all of the business basics in sufficient detail so that most Visual Basic.NET developers will have everything they need. In fact, I doubt very much that most developers will need everything found in this book—the coverage is that extensive.

This book won’t answer some needs at all. For example, if you’re working extensively with Web services, you’ll probably need to look elsewhere. Likewise, Rod doesn’t delve into PInvoke and doesn’t really discuss designing an overall application strategy much. If you want to create Internet applications, you’ll want to look elsewhere as well—this book focuses largely on the desktop application. The same holds true for mobile applications—you won’t find them discussed much in this book. Even with these limitations, however, this is a great book for the business developer—I know it’s the first book I’ll reach for when thinking about business application development.

BIO

John Mueller is a freelance author and technical editor. He has writing in his blood, having produced 80 books and over 300 articles to date. The topics range from networking to artificial intelligence and from database management to heads down programming. His current project is LINQ for Dummies (scheduled for publication in August 2008), which you can preorder at http://www.amazon.com/exec/obidos/ASIN/0470277947/datacservip0f-20/. His technical editing skills have helped over 58 authors refine the content of their manuscripts. You can reach John on the Internet at JMueller@mwt.net and his Web site at: http://www.mwt.net/~jmueller/.