Visual Basic 2008 Programmer’s Reference by Rod Stephens. Wrox Publishing, Feb 2008. $39.99 ISBN: 978-0-470-18262-8
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/.
