Rating: 
Summary: Somewhat rehashed VB standards book
Review: 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.
Rating: 
Summary: Did you say VB.NET or VB6?
Review: 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!!!
Rating: 
Summary: This book should be recalled, horrible style is taught!
Review: I don't even know where to begin to describe how bad this book is but perhaps teh following two examples are enough 1. The author spends more time on modules then objects: has a chapter on modules way before the chapter on objects. Hasn't the author been listening to Microsoft that VB .NET is a fully object oriented language - modules should not be used therefore, objects everywhere! 2. The author advocates Hungarian notation even though the VB .NET team says in the online help not to use it! Again I have to ask: why didn't Microsoft Press run this book by anybody on the Visual Basic .NET team? The principles it suggests go completely against what teh team members say in their talks. This book should be recalled. For a company that produced a great VB .NET book like Balena's, they should be ashamed of themselves for putting this one out! To sum up: avoid this book at all costs, it will only hurt you .NET development skills!
Rating: 
Summary: I am the author...
Review: I felt the need to post my own review after reading the previous one star slam. When I first saw this, I was <stunned>. I've spent far more hours than I care to count researching the information contained in this book, and I couldn't imagine why someone would have such a venomous opinion of this book - which I'm very proud of. Click the name of the reviewer, however, to see his/her other reviews and you will find that they dole out 1 star reviews to most of the books they read - can't imagine why they'd continue to purchase books with so many terrible experiences This book contains a wealth of information culled from many sources and professional experience. Take a look at the reviews for my other books and you will find that I write high-quality books for professional developers. The Hungarian notation presented <does not> conflict with the .NET philosophy, due to the fact that I recommend that Hungarian stay internal to your objects so that your object names and interfaces remain "hungarian free". (In fact, I state the Hungarian is completely optional, but that I and others still feel it has a place). Af far as the content on modules, most of the material is equally applicable to classes. Rather than discuss the material in two places (modules and classes), it is presented in modules first (the easiest to grasp) and the material on classes then builds upon the previous subject matter. Obviously, the previous reviewer "just doesn't get it". At any rate, check out the sample chapter or send me an email with questions and I'll do what I can to help... James
Rating:
Summary: Coding excellence described again!
Review: 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
Rating:
Summary: Great .NET Development Advice
Review: 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.
Rating:
Summary: Exactly what we were looking for
Review: 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.
Rating:
Summary: Great .NET Development Advice
Review: 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.
Rating: 
Summary: An excellent point to start - we could use the e-book
Review: 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!
Rating:
Summary: Very disappointing
Review: 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).
| 
