Bug Proofing Visual Basic: A Guide to Error Handling and Prevention (Paperback)

~ (Author) "Programming is a mental task, yet many programmers work with no mental discipline..." (more)
Key Phrases: final compiled version, routine can fail, txt buffer, End Sub, Private Sub, Exit Sub (more...)

Editorial Reviews

Product Description

A valuable collection of tools to prevent program bugs and to exterminate them when you find them. The longer a bug exists in a system, the harder it is to locate and repair. From Visual Basic guru Rod Stephens, this practical book outlines strategies for designing bug-free programs from the first line of code. It also shows how to test programs at crucial stages of development, how to locate and correct errors quickly, and how to repair programs damaged by bugs.

From the Back Cover

Prevent program bugs right from the start and quickly exterminate existing ones! Bug Proofing VISUAL BASIC(r) Let's face it, most programs with more than ten lines of code contain bugs. And as you know, the longer a bug exists in a system, the harder it becomes to locate and repair. Help is here! Packed with code, this practical guide shows you how to write effective, error-free programs and, best of all, how to test your programs at crucial stages of development. You'll find out how to handle unexpected bugs that do occur and how to locate and fix them quickly. You'll get bug prevention and repair techniques that just aren't available anywhere else! You'll get the kind of advice and information that usually only comes from years and years of hard-won experience! You'll find out: *How to design bug-free programs *How to code proactively to prevent bugs before they start *How to write code that exposes bugs instead of hiding them *How to catch bugs before they do any serious harm *How to find bugs using tools like the debugger and code profiler *How to use debug and runtime versions of a program to make debugging easier *How to use On Error statements to handle unexpected conditions *How to record information automatically, so you can fix bugs after users encounter them *How to use proven methods to find errors quickly *How to create and analyze special foolproof tests for errors.

Product Details

• Paperback: 416 pages
• Publisher: John Wiley & Sons; 1 edition (November 30, 1998)
• Language: English
• ISBN-10: 0471323519
• ISBN-13: 978-0471323518
• Product Dimensions: 9.2 x 7.5 x 1 inches
• Shipping Weight: 1.5 pounds
• Average Customer Review: 4.3 out of 5 stars  See all reviews (14 customer reviews)
• Amazon.com Sales Rank: #1,520,894 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #62 in	Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Quality Control
  #71 in	Books > Computers & Internet > Programming > Languages & Tools > Debugging

Customer Reviews

Most Helpful Customer Reviews

6 of 6 people found the following review helpful:

5.0 out of 5 stars Great book. Paid for itself several times over, February 3, 1999

By A Customer

This is a great book on Bug Proofing your code. Very easy to read. Lots of useful tips in every chapter. Well organized... and contains ALOT of code examples.

If you're an advanced VB programmer (already have made many mistakes and have taken up defensive programming), this book could be reduced to 1/3 the size... and it would still be a great book.

I'll use code from this book. I particularly liked the discussion on how you could set a form (object) to Nothing and later in your code you reference a public variable in that form (and unbeknownst to you it loads again). This keeps the form loaded when you think it's not. He shows coded examples of this sequence.

After reading this book, I'm going to get his other VB Graphics book. He's a very good author.

One thing I wished he had covered was Error handling when using Access database routines (non-databound). I like to use subroutines that update separate tables, and I like to use .BeginTrans, etc. with the .Update method for the opened database. This allows me to simply use SQL statements.

In this case, I was looking for example code, or recommended logic for using multiple subroutines. Although he didn't specifically provide this, he did provide alot of ideas on how to control the Error calling sequence using the .Raise method. Thanks to his book I understand this process better and hope to solve this problem directly.

For the beginning programmer this is an excellent book for establishing your programming standards. You will make a great step forward in programming... although you may only understand 80 % of this book.

This should be in every VB programmers bookshelf.

John D.

5 of 5 people found the following review helpful:

5.0 out of 5 stars Great book for eliminating errors and making revisions easy, October 13, 1999

By	Dave Pettit ([e-mail]) (Flint, Michigan) - See all my reviews

I love this book. It is written in a clear, understandable, and logical style.

The author discusses a logical convention of how programmers may write their code so that it will be readable and understandable by the next programmer who may not be as knowledgeable. By using properly descriptive variables, clear comments, straight-forward code styles, and no corner cutting, an application can be debugged easily by another programmer long after the first programmer has left the company. This would be good for department managers in establishing project standards for multiple programmers.

Furthermore, logical methods are explained for capturing bugs that can be kept in or deleted from the compiled code without having to manually delete code lines before a compile. Rod Stephens's techniques have prevented me from making mistakes that it would take a professional programmer years to learn.

Finally, his website shows all of the errors in his book (very few) and provides downloads of all of the code including improvements in the end-of-chapter questions.

11 of 14 people found the following review helpful:

2.0 out of 5 stars A valuable collection of tools -- I wish, December 27, 1999

By	"yawning_now" (Indianapolis) - See all my reviews

Sorry, I read this book, but didn't think much of it. I was able to pick up a few valuable tidbits, but overall thought the book's title and promise didn't deliver.

Avoiding bugs, it seems, has much to do with following good programming practices and perhaps that should have been the book's title. Much wasted time is spent on telling us how to indent lines of code, how to line up our comments, and admonitions to fix our own bugs and to be alert when you test.

There was 20 pages of good stuff and the rest was fluff. It was as if Rod Stephens needed to put out a book fast and just shotgunned his many years of programming experience at us, hoping something would stick and save us from having too many bugs.

I realize I now own 4 of his books, but none are even in my top 10 Visual Basic books. If I could have read the book first and then paid for it, I would have paid 5 bucks.