I have used both the VB6 and VB.net versions in my classes. In fact I require this as a additional text for all my classes. I believe very strongly that Hungarian notation should be part of a program.



It sounds like these reviewers that don't like Hungarian notation program in a vacuum. It is alright if you program by yourself to through out notations but if you have ever been a code reviewer and had to try to figure out what datatype or control type was being used, you learn to appreciate good use of notation, any notation to decipher the code.



Also while self documenting code style is what you want to try to acheive, it is very important to have a comment that points out the intent of the structure is, not just that it is an if/then construct. Why is this here. It is important to make this decision.



I think James has done an excellent job with this book and I look forward to his next edition.



Dennis

I have used both the VB6 and VB.net versions in my classes. In fact I require this as a additional text for all my classes. I believe very strongly that Hungarian notation should be part of a program.

It sounds like these reviewers that don't like Hungarian notation program in a vacuum. It is alright if you program by yourself to through out notations but if you have ever been a code reviewer and had to try to figure out what datatype or control type was being used, you learn to appreciate good use of notation, any notation to decipher the code.

Also while self documenting code style is what you want to try to acheive, it is very important to have a comment that points out the intent of the structure is, not just that it is an if/then construct. Why is this here. It is important to make this decision.

I think James has done an excellent job with this book and I look forward to his next edition.

Dennis

This book might be good for a total novice, but (a) most of the advice in here will already be familiar to VB6 coders (b) some significant areas with major changes from VB6 are completely overlooked (i.e., database), and (c) though this is subjective, some of the advice seems completely wrong-headed (my particular beef: advising against procedure "fan-out", which is one procedure calling many subprocedures. This is in direct contradiction to Martin Fowler's advice in Refactoring, and the key to writing self-commenting code - I'll trust Fowler over Foxall any day).

I bought this book, because I had the VB6 one and was wondering a similar material, but adapted to .NET. If fails short and it's just decorating my desk. The author keeps the same guidelines, for example it recommends using Hungarian when Microsoft guidelines says DO NOT USE IT (even though it's a Microsoft Press book!). Take a look at: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconNETFrameworkDesignGuidelines.asp

Those guidelines are more PRACTICAL and useful than this book. And you know what? IT'S FREE!!!

I bought this book, because I had the VB6 one and was wondering a similar material, but adapted to .NET. If fails short and it's just decorating my desk. The author keeps the same guidelines, for example it recommends using Hungarian when Microsoft guidelines says DO NOT USE IT (even though it's a Microsoft Press book!). Take a look at: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpgenref/html/cpconNETFrameworkDesignGuidelines.asp

Those guidelines are more PRACTICAL and useful than this book. And you know what? IT'S FREE!!!

This is a good book for both the experienced and beginning Visual Basic .NET programmer.

The purpose of this book is not to show you how to write a program in VB.NET but to provide a style template on how you should write a program; not only for readability but also for maintainability. To that end Foxall provides many examples of "bad" programming practices and styles along with a suggested "good" one.

The whole argument about using Hungarian notation (HN) or not is really irreverent. The very fact that this book exists and is hopefully read by more than a handful of people means more consistency and more error-free code.

One of the things I appreciate in this book is the use of color (various shades of blue-green) to mark things like comments in code, section headers, etc.

Overall this book was an easy read and can easily be grasped by entry level VB.NET programmers and functional enough for more experienced programmers to reference.

After seeing the author jump in for a review, I decided I would add my two cents into this fray. While I do not agree with the 1 star "slam" that the author set out to counter, I think 3 stars may be pushing it, however.

There is a lot of practical advice in this book. While it should be obvious that a developer needs to set up templates without hard-coding and make all procedures perform very specific duties, we find that this is not the case in code. The book has quite a few good pieces of advice around the basic nature of programming. I will disagree with the author, however, on some points. For example, you should certainly minimize fan out (calling many procedures) for all but control functions, fan-in (multiple procedures using the same procedure) is a sign of very specialized functions, which he advised only two pages earlier.

This book has a whole chapter on naming conventions, using Hungarian. While this is not a cardinal sin, it should be noted that Microsoft has deprecated Hungarian in .NET. The inclusion in the book (chapter 4) suggests that the author has simply updated some of his material from his VB 6 book.

The suggestions for enumerators, commenting, looping and code flow are fairly decent and may help your coding efforts. Mr. Foxall falls a bit short on exception handling taking the tried and true route (see Richter's book for a better methodology). One item of contention is the idea that you handle unexpected as well as anticipated exceptions. In general, handle what you can and catch what you wish to log. Let the rest get handled on the UI to ensure the user does not get an ugly exception message. Most books on the market advocate catching everything, and then rethrowing the same error; what a waste of CPU cycles. In VB 6, you had to handle every exception, and pass it up the stack if you caught anything. In VB.NET, exception handling gives you the ability to catch those exceptions that you can handle or log for debugging a live application. Using finally, especially with objects with a dispose method, is a much better option.

I would agree with the 1 star reviewer on the coverage of modules before objects. Modules are a sloppy method of programming in Visual Basic .NET. They are placed in for VB 6 developers that miss their .bas files. On the other hand, this is not enough reason to kill the chapter, as some of the other advice in the chapter (2) is very useful.

A 2.5 rating would be a bit better as there is some bad advice in this book, but I have to choose between 2 and 3 and would rather give the author the benefit of the doubt. I hope Mr. Foxall has a chance to make a second version of the book that moves completely into the .NET paradigm, as it would be much more useful to developers.

After seeing the author jump in for a review, I decided I would add my two cents into this fray. While I do not agree with the 1 star "slam" that the author set out to counter, I think 3 stars may be pushing it, however.

There is a lot of practical advice in this book. While it should be obvious that a developer needs to set up templates without hard-coding and make all procedures perform very specific duties, we find that this is not the case in code. The book has quite a few good pieces of advice around the basic nature of programming. I will disagree with the author, however, on some points. For example, you should certainly minimize fan out (calling many procedures) for all but control functions, fan-in (multiple procedures using the same procedure) is a sign of very specialized functions, which he advised only two pages earlier.

This book has a whole chapter on naming conventions, using Hungarian. While this is not a cardinal sin, it should be noted that Microsoft has deprecated Hungarian in .NET. The inclusion in the book (chapter 4) suggests that the author has simply updated some of his material from his VB 6 book.

The suggestions for enumerators, commenting, looping and code flow are fairly decent and may help your coding efforts. Mr. Foxall falls a bit short on exception handling taking the tried and true route (see Richter's book for a better methodology). One item of contention is the idea that you handle unexpected as well as anticipated exceptions. In general, handle what you can and catch what you wish to log. Let the rest get handled on the UI to ensure the user does not get an ugly exception message. Most books on the market advocate catching everything, and then rethrowing the same error; what a waste of CPU cycles. In VB 6, you had to handle every exception, and pass it up the stack if you caught anything. In VB.NET, exception handling gives you the ability to catch those exceptions that you can handle or log for debugging a live application. Using finally, especially with objects with a dispose method, is a much better option.

I would agree with the 1 star reviewer on the coverage of modules before objects. Modules are a sloppy method of programming in Visual Basic .NET. They are placed in for VB 6 developers that miss their .bas files. On the other hand, this is not enough reason to kill the chapter, as some of the other advice in the chapter (2) is very useful.

A 2.5 rating would be a bit better as there is some bad advice in this book, but I have to choose between 2 and 3 and would rather give the author the benefit of the doubt. I hope Mr. Foxall has a chance to make a second version of the book that moves completely into the .NET paradigm, as it would be much more useful to developers.

With a new way of coding VB comes new ways of making the environment more effecient for programmers.

This book is full of good advice about programming practices in the .NET world. The advice is sound and could be even used as an intro since the author goes through great pains to make everthing clear while concise.

Should you follow all the advice? Depends on you. I don't think you should follow anybody's suggestions without some critical thought but the suggestions here are definitely worth taking a look at and debating. VB.NET ain't VB6 and you should not code and organize your code the way you did in VB6. Foxall gives us some good, pratical advice on how to code. More importantly, he gives great advice on how to organize code (something programmers tend to be bad at doing).

The only surprise was the recommendation to use Hungarian notation. I find it amusing that people get so hung up on Hungarian notation (I happen to like it but would not miss it if I never used it again). It's just a way to try to making code more readable when using local variables. If you think it gets in the way, then you shouldn't use it. Other than that confusing suggestion (MS says don't use Hungarian but you ARE free to use or not to use whatever convention you like) the book is flawless.

This is a book that every team doing VB.NET development should discuss if not follow. Standards are important, most of the software building cycle is in testing, debugging and modifying existing code. His standards are something to draw on as we come up with the best practices for our particular solutions.

With a new way of coding VB comes new ways of making the environment more effecient for programmers.

This book is full of good advice about programming practices in the .NET world. The advice is sound and could be even used as an intro since the author goes through great pains to make everthing clear while concise.

Should you follow all the advice? Depends on you. I don't think you should follow anybody's suggestions without some critical thought but the suggestions here are definitely worth taking a look at and debating. VB.NET ain't VB6 and you should not code and organize your code the way you did in VB6. Foxall gives us some good, pratical advice on how to code. More importantly, he gives great advice on how to organize code (something programmers tend to be bad at doing).

The only surprise was the recommendation to use Hungarian notation. I find it amusing that people get so hung up on Hungarian notation (I happen to like it but would not miss it if I never used it again). It's just a way to try to making code more readable when using local variables. If you think it gets in the way, then you shouldn't use it. Other than that confusing suggestion (MS says don't use Hungarian but you ARE free to use or not to use whatever convention you like) the book is flawless.

This is a book that every team doing VB.NET development should discuss if not follow. Standards are important, most of the software building cycle is in testing, debugging and modifying existing code. His standards are something to draw on as we come up with the best practices for our particular solutions.

I have always been passionate about code conventions and standards. In my early VB days I was weaned on the likes of Stan Leszynski, Greg Reddick, and James Foxall. As I began to investigate moving from the VB6 world to the new .Net landscape, I was eager to find out what James Foxall would think. Especially since he had always been a strong advocate of Hungarian Naming conventions, and the new sounds out of Redmond were recommending against them.

James finds the perfect balance, maintaining the true spirit of the Design Guidelines for Class Library Developers found in the .Net Framework documents. The point of the non-Hungarian recommendation is "to encourage consistency and predictability in public APIs while enabling Web and cross-language integration." Of course conventions tied to a particular language's type terminology do not belong on the public interfaces of class libraries. Peter Vogel said as much in the VB6 days with his Object and Component title. (Looking forward to that VB.Net edition, Peter!) But for those who find HN a useful tool, they can still utilize it on the interior of their objects, and remain completely compliant with the .Net docs.

Outside this often "thorny" question, the rest of the book is as rock solid as ever, providing guidance and direction on everything from how best to design solutions, projects, and classes, to commenting code and laying out flow constructs. You may not agree with absolutely every recommendation, but you will be hard pressed to find anywhere a more complete standards guide for the .Net platform. Even if you choose not to utilize Hungarian Naming standards, you can benefit greatly from the other code suggestions James provides. It would be a pity to let that one aspect of code conventions prevent you from gleaning from the richness here.

Outside of all this, I have to say that James Foxall is one of the most personable developers I have had the pleasure to encounter. When I was seeking information on where to go with .Net, I contacted him directly because I couldn't wait for the book's release. He was most responsive to my questions, and helped me work through just what to think while moving to .Net. This one is on my desk to stay!

You will benefit greatly from giving it a read!

Kel

No book on coding style and standards,can be the bible for every programmer alive. Usually, reading these books helps us decide what we do wrong, what is a better practice and what we do not like. Experienced programmers may adopt fewer recommendations from the book than less experienced ones.
From this point of view this book can be invaluable to every open-minded developer. You can build on it and have your own standards in no time.
I believe the attack and the single star rating by "geek" is totally unjust, based on a zealot's attitute against Hungarian notation. In "Design Guidelines for Class Library Developers", under "Naming Guidelines" .NET team gives its suggestions on naming Namespaces, Classes, Interfaces, Methods, Properties etc. To geek's surprise .NET team RECOMMENDS Hungarian Notation for Static Fields!
The Author of this book has a whole chapter "When Not to use Hungarian Notation" whickh agrees 100% with .NET guidelines.
I gave it only 4 stars because it does not include a CD with the electronic version of the book(many other MSPress books do) and I had to do a lot of typing to make my own standards for my team.
Microsoft and James give us the e-book!

I was a fan of Foxall's Standards book for Visual Basic released a few years ago. James has done his usual good job on this book. Visual Basic .NET represents a very new way of development, and I have been using it for almost 2 years in beta form. Now that VB.NET has shipped, this book is an invaluable guide to how to do things right. Other books will teach you about the technical aspects of programming in .NET, but this one tells you how to do it correctly in a standardized environment.

Take the negative review (below) for this book with a grain of salt. The writer hounds the book for taking on the subject of naming conventions and hungarian notation. Hungarian is a personal issue and you have to decide for yourself as to its applicability in .NET--a point that Foxall takes pains to point out.

Regarding modules, they have a place in VB.NET, and it makes sense in a standards book to address them first, so that they can later be compared to classes. It is interesting to note that the first reviewer's list of computer book reviews on Amazon is almost universally negative--he gives 1 star to almost all the books.

If you are looking to do professional development with Visual Basic .NET--this book should be required reading. While you may not agree with every standard proposed, it will get you thinking about how you should use standards to reduce development and maintenance time on projects.

I highly recommend this book. Our development shop is moving to VB.NET as our main development platform and before we started coding, we wanted to ratify a set of development standards before any coders bad habits were implemented. We looked for published standards from Microsoft, etc. to no avail. James' book is exactly what we were looking for. It's written in a tone that doesn't dictate, it simply recommends and then explains why. We plan to implement at least 80% of what James recommended in our own coding standard.

There has been much talk about Hungarian notation standards being antiquated - even by Microsoft - but James gives a very simple solution: use it internally to improve code readability and leave it off of any public interfaces. This book puts us way ahead of where we were in coming up with a corporate coding standard for VB.NET.