Review of Visual Basic 2012 Programmer’s Reference

As you might expect, Visual Basic 2012 Programmer’s Reference is a heavy tome at 798 pages. Of course, those pages could be filled with fluff, but that isn’t the case with this book. Rod Stephens does a great job of covering a wide variety of topics that anyone who wants to know how to write Visual Basic applications will need to know. The book starts with the assumption that you have never worked with Visual Studio before. Actually, it’s a good start for some developers who have been coding a while because they are self-taught and really haven’t explored everything Visual Studio has to offer.

The first part of the book discusses using the tools of the trade—a topic that most books seem to miss for whatever reason. I’m not talking a quick overview either. Rod provides six full chapters, 77 pages, worth of material on how to use the Visual Studio IDE for various kinds of application development including both Windows Forms and Windows Presentation Foundation (WPF). This may not seem very important at first, but quite a few readers of my books have problems with the IDE they’re using and even more have no idea that the IDE supports certain functionality. In short, many developers don’t have a firm grasp of the tool that they’re using to write code, so they can’t perform their best work. However, if you’re already completely familiar with the IDE, it’s probably a good idea to skip this part of the book because it is quite detailed. Missing from this part of the book is material on working with Metro applications. In fact, that material doesn’t appear until Chapter 21, so this really isn’t a strong Windows 8 offering from a building Metro applications perspective.

The second part of the book is entitled, “Getting Started,” which I view as a misnomer. Yes, you’re getting started writing code, but anyone who skips the first part really hasn’t gotten a good start. This part of the book introduces the reader to controls, forms, and other objects used to create applications. There are six chapters of this sort of material. Again, you can’t expect to create great applications if you don’t know what objects are already available to you. Developers who don’t really know what objects are available will tend to reinvent the wheel or assume that the language isn’t capable of performing a specific task. Rod does an outstanding job of making the reader aware of what is available and how to use it effectively. There are 100 pages worth of extremely useful material of this sort.

Chapter 13 should have begun a new part. Rod leaves controls, forms, and other objects in this chapter to begin working with applications. It’s one of the few organizational errors in the book, but one that is easily forgiven. The next six chapters, 160 pages worth, discuss basic programming topics such as variable data types and the use of programming structures. Chapter 18 provides an excellent discourse on error handling and will be one of the chapters that even experienced developers will want to read.

Chapters 19 and 20 provide extremely basic, but thorough coverage of database topics. This is not a book about database development. Rather, it exposes you to the topic of database development and you’ll need to obtain another book on the topic to finish your education. This said, what this book is really doing is helping you understand database development at an extremely basic level so that the second book you get, the one specifically about database development, will make sense.

Chapter 21 (which is only 12 pages), likewise, is an extremely basic view of Metro development. Again, this isn’t a Windows 8 book and it doesn’t appear that the author ever intended it to fulfill that role. What Chapter 21 does is introduce you to Metro in a basic way so that you can go on to work with a Windows 8-specific book and make sense of the material it contains. That said, I did notice that Chapter 21 does miss out on a few fundamentals, such as obtaining a license for developing apps. Rod doesn’t appear to mention that the target application will only work when running Windows 8 either (at least, I wasn’t able to get it to run on Windows 7).

Starting with Part III, you learn about Object-Oriented Programming (OOP) techniques in detail. Chapter 22 is a must read chapter because it provides the theory that many books on the market lack. It describes what OOP is all about. It’s tough to understand coding examples when you don’t understand the basis for those examples and Rod fills all of the gaps for you. In the chapters that follow, Rod leads the reader through basic class development, structures, and namespaces. The book then continues with some specifies on collection classes and generics. Again, all of this material is designed around a person who really doesn’t know anything about Visual Basic, so Rod takes time to explain the details not found in other books.

Part IV of the book fills out some basic information needed to create standard desktop applications, such as printing in Chapter 27 and the use of configuration information in Chapter 28. The use of streams and filesystem objects come next in Chapters 29 and 30 respectively. The book closes out with an enormous array of appendices (22 of them) that contain all sorts of useful reference information. After you’ve gone through the book, the example applications and this reference material continue to provide you with long term value.

Overall, this is the book that you want when learning Visual Basic. It provides the details needed to write robust applications quickly. However, getting this information is like getting any other sort of education—it takes time and you must work through the examples. This isn’t a quick reference book, nor is it going to provide you with details about specific technologies such as database development or writing Metro apps. Where the book does touch on specifics, it covers those specifics at a basic level with an emphasis on helping people understand the underlying technology. If you’re looking for a book that provides quick answers, a cookbook approach to solving problems, or detailed information about specific technologies, you really do need to look elsewhere. On the other hand, if you’re tired of being confused by online examples and tutorials that don’t really teach you anything, then this is the book you want.

 

Author: John

John Mueller is a freelance author and technical editor. He has writing in his blood, having produced 99 books and over 600 articles to date. The topics range from networking to artificial intelligence and from database management to heads-down programming. Some of his current books include a Web security book, discussions of how to manage big data using data science, a Windows command -line reference, and a book that shows how to build your own custom PC. His technical editing skills have helped over more than 67 authors refine the content of their manuscripts. John has provided technical editing services to both Data Based Advisor and Coast Compute magazines. He has also contributed articles to magazines such as Software Quality Connection, DevSource, InformIT, SQL Server Professional, Visual C++ Developer, Hard Core Visual Basic, asp.netPRO, Software Test and Performance, and Visual Basic Developer. Be sure to read John’s blog at http://blog.johnmuellerbooks.com/. When John isn’t working at the computer, you can find him outside in the garden, cutting wood, or generally enjoying nature. John also likes making wine and knitting. When not occupied with anything else, he makes glycerin soap and candles, which comes in handy for gift baskets. You can reach John on the Internet at John@JohnMuellerBooks.com. John is also setting up a website at http://www.johnmuellerbooks.com/. Feel free to take a look and make suggestions on how he can improve it.