Customer Reviews

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

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

 

 

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.

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.

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.

I was trained in VB at a Fortune 1 company (narrows it down, eh?). I developed a very paranoid mindset with my development that I have not seen in others until I came across this book.

It really took the beliefs and habits that were instilled in me and materialized them into a book. I can then take this book and recommend it to folks I have to share projects with to spread those beliefs and habits without seeming like a pain.

If you aren't an enterprise class developer but would like to play one on TV by coding tight apps, get this book. Your team members/users will love you for it!

A very reasonable book for someone to refresh the knowledge and fill the gaps about error handling in VB. It does provides the stuff that is missing in the VB help or other VB books. At least it provided some guidance on how to tackle the error handling within a program, instead of a routine only. Photocopy the content page and use it as a quick reference. One little shortcoming is that the author sometimes repeats his message in many places in the book.

It is a very good book. It's McConnel's Code Complete on Visual Basic. You've got to buy it!

This book gives a lot of tips but most of them are pretty thin on substance. Specifically, there is very little information particular to VB hazards or how to write an industrial strength error handler in VB. I think I expected more substance coming from an author who's previous books have been fairly advanced. If you are a beginning programmer this book is great. If you are an experienced programmer this book will be a quick read and you might get a tidbit or two that will save you the cost of the book.

I have several of Rod Stephen's books. Whenever I start with a new client I bring along my copies of his books on algorithms and graphics. When I saw this book I had to buy it. I am not disappointed. He spends time writing about how to verify the data. He writes clearly and points out some of the obscure problems and our assumptions within Visual Basic. He makes sure that we know that when we write code we are not writing just for the computer, but for other people (sometimes ourselves).

This book is a must have.

If you have ever written anything in VB, then you know how much of a pain Error Handling is. This book will give you a solid foundation of how to handle errors. It also gives you lots of insight into handling general error or specific errors, and writing bug-proof code.

The rule format of the book is a great way to learn how to write good code. You find yourself quoting the book while your coding. Covers heuristics that many "self taught" programmers cannot learn anywhere else.