5 comments about Beginning Object-Oriented ASP.NET 2.0 with VB .NET: From Novice to Professional (Beginning: From Novice to Professional).

1. When this book says it's from Novice to Pro, I expected some advanced notions. It covers many topics, but very briefly. It is not a bad book, and is a very good read for someone who needs to get basic introduction and coverage on .Net topics. It covers basic Objects and Classes designs, encapsulation, inheritance, namespaces, webforms and web services. I reckon the price I paid (CAN $37 ) is way too high for this book, but I gave it to some people who needed an introduction for ASP w/.Net and they found it useful. Basically, if you need to do some advanced projects forget this, on the other hand if you need to learn some simple concepts go for it, but wait for the price to drop.



2. If you are not an introductory user then this book is a quick read and overpriced. The subject matter was well selected but the depth of content, writing style, and cookbook mentality was disappointing.



3. This is a good book for programmers wanting to learn about the basics of object oriented programming and its implementation in VB.Net.
   
   Unlike other books that dive into so much technical detail that you end up glossing over the information and not actually learning all that much, this book clearly and simply walks you through the basics of OOPs.
   
   After each section, you are given examples of code to see how the concepts are used. The chapters are short enough to be easily digestable.
   
   I learned more about OOPs from this book than other larger and more expensive titles.



4. I've just purchased a copy of this book and am enjoying reading it. It's written in a very clear and concise manner and a breeze to read. The OOP concepts are clearly explained with accompanying diagrams. Does exactly what it says on the tin.



5. Don't get this book if you have _any_ experience in programming or have little patience for repetition or word count padding. I suffered through the whole thing just so I could feel justified in writing this review.
   
   "HTML elements are not available to the server, because they are text that is passed through to the browser." O.M.G. How did I go all this time without realizing that HTML is text that is "passed through" to the browser?! Sentences like this one are commonplace: "The HTML section of the Toolbox will have a title of HTML." Ya think? Or this jem: "The last category of properties is Misc. This category will list any properties that did not fit into the other categories." The whole book is like this. It's incredible. I didn't pad my jr. high english papers like this.
   
   Finally, there are some mistakes in the references to the samples -- having you name a class something, then referring to that class with a different name later. This type of errata is common in tech books, but with something this short and brutally simple-minded, you would have thought the tech editor would have caught these mistakes. Maybe he fell asleep reading it as many times as I did.

5 comments about Coding Techniques for Microsoft Visual Basic .NET.

1. This is not a book for a novice programmer. It is geared towards the meeting the needs of professional system programmers. You won't find anything here on MDI, GDI+ or a host of other VB features. For example, the steps behind attaching buttons to code could have been illustrated much more explicitly. So if you are still coming to terms with the core of VB, this book could produce a rather serious challenge. Consequently, the text is not a substitute for other broader overviews of VB.Net.

   That being said, one of the exceptional strengths of the book is its efficient working through of the tool side of VB - which is huge. Whether you want to create a form, a class, a module, an ASP project, the author has the way picked out pretty cleanly. The CLR and Assembly sections are very written and really worth the effort. The section of ADO.NET is good, but tends to rehash a lot of Microsoft technical information. Inevitable probably. The ELIZA program design gives a good insight into using collections efficiently. However, files and streams are treated too abruptly for my liking.

   One of the other attractive aspects of the book is the lack of navel gazing about types and their cousins. Types are dealt with very practically (might not satisfy everyone).

   Unfortunately, the style is at times a bit too terse. For instance, I don't think this is a useful book from which to pick up OO skills. It covers class creation with a few very specific examples and then moves on. Theoretical digressions are noticeable by their absence. Again, a supplementary text will help here.

   Overall, however, I am very keen on this book. I learnt a lot more from it than I expected, and it is very well written. It is certainly a very valuable reference text.




2. One of the trivial but irritating problems with this book is that the author and the publisher seem to be unclear about who the target audience for this book is.The back of the book says that 'whether you are a beginner or a self taught programmer,a professional looking for a refresher n coding techniques ,or a programmer coming from another language ,this is the VB book for you.'Now in the second para of the book's introduction the author says that 'This book was written for visual basic programmers by a visual basic programmer'.

   Though the title of the book suggests that the book is meant for atleast intermediate programmer's in VB rather than a beginner the author at some places seem to be targeting a complete beginner.His explanation about why one should use a property procedure instead of a variable to prevent invalid values for classes seems to be absurd.Propety procedure are a very much part of VB6 and I am sure that no programmer moving on to .net from VB6 needs any explanation about the benfits of using property procedures over private variables.

   Overall I would still recommend this book simply becoz it's a good one.Some of the topics covered ar quite advanced and will cater to people who have finished reading books like Programming MS Visual basic.net by Francesco Balena.
   This book essentially should be your second book on Visual basic.net , the one you should read after say the Balena Book




3. The Book is good, give a good intro to vb.net but those interested more in the language should dig deeper Msdn, Blogs, Compiler Spec, etc.
   There is one thing though I disliked and hope it will be taken care of by Mspress, the problem is the Code Samples that obviously requires correction and shoulb be taken care of Asap.
   I am aware of the Kb article published on Microsoft site, still not enough.
   Other than that, great book and you can clearly sense from John's writing that he is a teacher and a good one as well.

   Hope this review would help one or more Vb Developer and that my message passed as well to the right Folks

   Yassine
   Regards




4. As a VB programmer who has struggled in the past with OOP, this book was written for me. It's one of the most readable technical books I've had, and explains the OOP approach without talking down to you or using contrived examples. Now I'm really fired up about switching to .NET!
   This book is an overview, not a reference, but the way it is written allows you to really think through how programs should be written in .NET



5. Le titre de ce livre ne convient tout simplement pas. En achetant ce livre, je m'attendais à ce que le contenu soit avancé. Habituellement, lorsque l'on est rendu au point d'apprendre des techniques de codage, on a pas besoin de savoir ce qu'un integer ou d'avoir un exemple de programmation orientée objet avec une classe de 1 méthode et 2 propriétés. Enfin bref, un autre livre sur lequel on peut dire qu'on apprends rien d'autre que des petits trucs simple et faciles à trouver sur Internet gratuitement. En plus, le livre coûte bien trops cher. Je ne pouvais pas mettre 0/5 alors je me suis contenté de mettre 1 étoile.

5 comments about Sams Teach Yourself Visual Basic for Applications 5 in 21 Days, Third Edition.

1. If you're new to programming, this book delivers. Good coverage of important basics. Line by line hand holding on example code provided. Clear explanations. An excellent beginner's book. Not that good for intermediate or advanced levels. Its still a good reference, but advanced topics aren't covered.



2. Hi -

   I had to write and tell you what a great job Matthew Harris did in "Sams Teach Yourself Visual Basic for Applications 5 in 21 Days (Third Edition)". I am a computer consultant and a Certified Technical Trainer. Good books, especially at the neophyte level for programming, are hard to find. Most of them make assumptions that the reader has prior programming knowledge, which is often not the case at all. I purchased this book initially as a recommendation to someone who wanted to learn VBA, but had no prior experience even with macros, much less programming.

   The book is clear, clean, and thorough in its treatment of the subject. It is also pleasantly devoid of typos, grammatical errors, missing text, etc. which makes me crazy in too many of the books I read, especially computer books. The examples make sense and flow smoothly from the very basic to gradual, increased complexity. I will use this book whenever possible in my classes on introductory VBA.

   Thank you for providing me with such an excellent tool.

   Sincerely,

   Linda Dawn Bozick, President, Enterprises, Inc.




3. I cannot emphasize enough the utility of this book! I had NO programming experience but since reading this book, I am prolific in writing code. The book progresses logically and slowly step by step allowing a self-paced environment. The best attribute of this book is that it is also a great reference book. I dont expect this book to ever be obsolete. Well worth the price and time/effort needed to read it!!



4. I used Matthew Harris' "21-day" book to teach VBA during Spring '99 quarter at South Puget Sound Community College. It is not really made for the classroom (no CD-ROM, instructor must make up his own quizes, etc.), but generally good in the first two thirds of the book. The last few chapters begin to falter, however: #19 does not treat Automation (OLE) too clearly nor explain certain oddities (e.g., unexpected 'recursion' when linking an Excel file to Word). Also, a promise of showing how to use Windows' own FileOpen screens in Chapter 20 is never fulfilled. Chapter 21 is a poorly-coordinated grabbag of leftovers not presented well. Still, the book is probably the best in this poorly covered market. Although it treats of Word and Excel only, with over 1,000 pages it is a fairly good introduction to the subject.



5. There are several handbooks about VBA but none of them tell you as much about Object Oriented Programming as this book [in a way that can be understood].

   This book is very well suited for anyone with some advanced programming experience and knowledge of Excel.

   I like it!

5 comments about Programming VB .NET: A Guide for Experienced Programmers.

1. Of all the books I bought to learn VB NET, this is the one I find myself turning to repeatedly for information on object oriented programming. The author' treatment of inheritance and delegates/events are models of clarity. I also found his treatment of mutithreading to be clearer and far easier to understand than the new Wrox book which was supossedly devoted to threading. If you want a book on the VB NET language you can't do any better than this one!



2. This book simply doesn't have enough information to be named "a guide for EXPERIENCED programmer". It is rather a quick overall introductions. So don't get this book if you need to get some serious work done.



3. I bought this book and several others to prepare myself for the transition from VB6 to VB.NET. I wish they would have covered the disconnected datasets, ADO.NET and ASP.NET in more detail. I would have given it 5 stars if it had.

   Other than that, I feel that it is an excellent resource to prepare a programmer from any background for VS.NET. It does a good job of covering the OOP, Inheritance, Overloading, and multithreading subjects in a concise manner.

   The book also has a web site for errata and source code. Gary Cornell is a good author and it shows in this book he co-authored.

   I have a few Wrox Publishing Books, but my library is starting to collect more an more APRESS books because their style and format is what I expect from a book.

   Wrox does publish some good books also:
   I would also recommend .NET Enterprise Development in VB.NET from Design to Deployment, ISBN 1861006179, (Wrox Publishers)




4. This is a pretty-good book if you base it on the Beta. The chapters on OOP (Chapters 4 - Classes and Objects and 5 - Inheritance and Interfaces) are very long. Chapter 4, 5 and 6 (Event Handling and Delegates)form the heart of this book, but I would have broken them down into smaller chapters. The information in those chapters provide a good introduction to OOP. At times, I felt the authors were hard to follow and found myself re-reading several pages especially in Chapters 4 and 5. Overall this book probably is about 3 1/2 stars. I am hoping that in the next release of this book that the authors would follow their own advice and break the chapters down into smaller parts. ...



5. The book is primarily designed for experienced Visual Basic developers making the transition to VB.NET. However, it can also be appreciated by other experienced programmers regardless of their programming background.

   The book begins with an introduction to the differences between VB.NET and VB. The next chapter introduces you to the new Visual Studio .NET integrated development environment (IDE). You will get a tour of the main windows, and learn how to compile and debug your VB.NET applications. Chapter three teaches the VB.NET syntax. You will learn the VB.NET expressions, operators, and program control flow. The next couple of chapters form the core of the book. These chapters cover object oriented programming and inheritance. VB.NET is the first truly object oriented programming version of VB, and a solid understanding of these new features is essential in taking full advantage of VB.NET's new powers.

   The next few chapters go on the cover important topics such as, event handling, error handling, building user interfaces, input/output streams, and multithreading. The final two chapters give a brief introduction to database access with VB.NET using ADO.NET, and a brief overview of ASP.NET.

   The book provides clear and complete coverage of all topics. It includes many real world code examples which help the reader to better understand all the concepts presented.

5 comments about Using Excel Visual Basic for Applications (User Friendly Reference).

1. I needed a quick course in Visual Basic for Excel. This book did the trick. I was tired of reading others' macros and trying to figure out what meant what. With a college course in Fortran77 providing me the basic framework of how to program, I found this book easy to follow and easier to learn from.

   I don't know if someone with absolutely no programming experience would find it as helpful, but it was an excellent book for me. I can now create my own code without having to use the recorder, and I can figure out other's complex code with the foundation the book provided.




2. This book is at a very beginning level, telling you how to use the macro recorder,defining a variable ("where programs store values"), defining what "calling" a procedure means etc. If you are at this beginning level, the book is excellent EXCEPT it is out of date. For example, the menu arrangement described in this book for inserting a module sheet is different if you use Excel '97. The dialog sheet is used here for designing dialog boxes, a method replaced with UserForms in Excel '97. So although intended to be a very handholding approach, for users of Excel '97 it is no longer so straigtforward. Probably John Walkenbach's "Microsoft Excel 2000 Power Programming" is more useful, but unfortunately at a more advanced level.



3. This is the only Visual Basic book I have seen which allows users to program in VB without first learning the intricacies of the language. Which makes this book the only convenient source (that I have found; after repeated trips to book stores and libraries) for anyone who is attempting to make useful programs in Excel. While it was written for Excel 7.0 the applications (amazingly) still work in Excel 2000. I would recomend this book to anyone who works with computers and wishes to save some time by avoiding tedious data entry.



4. Numerous examples and suggestions in the book were not accurate using Excel 97. For a self-paced, self-taught learner, look elsewhere.



5. This is a very good book to begin programming in Excel VBA, but not to end if you will. The book sort of gives you a push and YOU! have to then take the ball and run with it. The book is analogous to how a mother bear chases her cubs away once they are big enough to take care of themselves. The cubs, though with enough skills to survive, are still left with new and open possibilities before them. The reason why is that most of the examples are too easy, making them too unrealistic for the real world. The other is that the book is based on an older Excel version. This book is really great for those people who are scared of programming and want to make the transition, but are not sure of what road to take.

5 comments about Beginning Visual Basic 6 Objects.

1. SYNOPSIS: I recommend this book for it's presentation of the OOP architecture and the code samples of ActiveX objects and Business Objects. Explanations are easy to read and grasp. There are plenty of simple diagrams that help visualize many of the abstract concepts of OOP. In the step-by-step instructions, there are actual screen shots of what a programmer will see when they write the sample code. DETAILED EXPLANATION OF RECOMMENDATION: I have several Visual Basic books. However, none of them give a simple, complete example of the code needed to construct an ActiveX control that stores it's state values in a property bag. I spent two days trying to write code that would store the values in a persistent property bag. Examples that I downloaded from the Web were complex, and had little or no explanation as to HOW they worked. And explanations that I found were either terse or did not give enough detail for me to successfully construct a Control with persistent state values that a user could alter during run mode then have them save to the property bag object. At Barnes & Nobles I reviewed 40 or more books on Visual Basic. In this book in Chapter 8 "Object Persistence" the author Peter Wright provides step-by-step instructions with the full code for creating an ActiveX control that maintain state information in a property bag object. There are screen shots of how the control and message boxes will appear. The explanations of what, when, where, why, and how the code executes are to the point, easy to read and understand. I only needed one chapter, 23 pages, from this book. Yet I was glad to spend the money to purchase it. Why? It is well written, easy read, has lots of diagrams and screen shots that makes it easy to visualize concepts and control objects, and gave me EXACTLY what I was looking for. I could have used a book of this quality 3 years ago when I began learning OOP on a Java platform. Bravo!



2. I purchased this book recently and I'm very happy with it. I'm an experienced C/C++ developer and have used Visual Basic for many projects on the PC....but not with the object oriented capabilities of VB. This book provided the necessary backgound on how to create real world applications using VB objects and provided good background on ActiveX Components (COM) as it pertains to VB. Just enough information is provided about the theory without putting you to sleep. I disagree with the other bad comments I read about the book. I feel the author does a great job of stepping you through all the ways of representing objects in VB.



3. This book is a very good resource for developers starting out in OOP with VB. Even if you used VB, but never used objects, this book may just convert you to OOP. It will give you a solid foundation on how to create objects in VB, and also how to develop ActiveX components/controls. It is easy to understand, and it reads quickly. Author uses lots of examples, so if you follow along, you'll gain a better understanding of the subject matter. Because this book is easy to understand and it introduces a complex topic in simple terms, it will make you want to learn more about objects and will increase your confidence in what you know. At the end of the book, there is a case study using all the concepts introduced throughout the book--it's a good idea to do the project, as it will help you develop your own solutions on the job. The book also introduces UML, and how to make your own ActiveX controls with Property Pages.

   This book is just an introduction, so for more complex issues like designing business objects, you will need to get some other resources. This is, however, a solid foundation for OOP. If you will understand and know everything this book contains, then you'll be already successful in your job. You can always hone your skills later on as your experience grows.

   Buy it, if you want to understand objects, and don't want to get confused or discouraged with the subject matter because this book will really get you on a good start. If you're taking the MCP exams in VB, then objects and DLLS and ActiveX subject matter will be very easy for you after reading this one. This book is also used at some colleges in their OOP in VB classes.

   The only negative in this book, and it's a shame because this should be a "professional" book, is that it has many typos and grammar errors. The editors did a very poor job on it. However, if you don't mind the English, and just want the tech info, then it's going to be fine, and you'll find the errors entertaining.




4. The good news is that, with the amount of stuff you learn from this book on proper object-oriented programming, you'll feel that my money was well spent. The bad news is that every application you wrote before reading this - eh, you'll want to tear them apart and start from scratch. This book is a great introduction to object oriented programming. The concepts are sound, the explanations are great. The examples [stink]. In a book where he preaches cohesion, you would think that he'd cohesively stick to developing the same example further and further.



5. This is hands down the best book for learning to program Visual Basic using objects. I know because I bought all the others and they simply left me dazed and confused. Perter Wright's perfect sense of what to introduce and when and how to introduce it was key to my learning this subject. Most importantly, he thoroughly documents the code in his examples so no aspiring programmer is left behind.

   This book is simply the best of the best.

2 comments about Visual Basic 2005 By Practice (Programming Series).

1. This is an introductory book on programming in Visual Basic 2005. However it does presume that you have programmed before on some kind of system. It doesn't matter which language, but the basic concept of writing commands, logic, and so on should be familiar to the reader. To be sure, he does give a bit of instruction into basic programming principles, but it is pretty basic.
   
   Next he goes into a description of Visual Studio which is used to program in several Microsoft languages. Then on to writing programs. He leads you through the writing of a pretty basic program. While basic in nature this program covers a lot of the principles of programming. By the end of the chapter, you've put a small window on your screen.
   
   Throughout the book he uses a series of extentions to the little program, and by the end of the book you should have a pretty good understanding of the language.



2. I'm in a class that uses this book as the text. I am very impressed with the step-by-step instruction. The text doesn't assume anything and yet, it doesn't insult my intelligence.
   
   Very well-written, easy to follow, and confidence inspiring.
   
   Well done, Mr. Mostafavi!

5 comments about Beginning .NET Game Programming in VB .NET.

1. This book may present some theoretical views for beginner level game programming, but do not expect to learn the correct syntax for VB.NET. Actually if you purchase the same authors book for programming in C# you'll find they have the same first chapter (that's as far as I looked). This book was obviously a lazy attempt for these people to make a quick buck. Unfortunately they wait until the end of the book to let you know:
   "Most of the example games leave much room for improvement. Even when we looked back on them after finishing each chapter, we would sometimes look at parts of the code and think, "We can't believe we wrote that." Even worse, some of the things we told you aren't always true." pg 348
   While I was trying to complete the exercises in this book I spent more time with my nose in other books so I could learn the correct way to do it. Do yourself a favor get a different book.



2. Although this book isn't a complete waste of money, don't be fooled. It's not very well written.
   There are countless errors in the code right from the beginning. They also just skip telling you some important pieces about what is going on in every chapter.
   However, you can still squeeze some use from this book. Go to the web site and download all the code from them. For the most part, the code works and can be your reference. You *can* learn from this book and d/l code, but you have to work at it and use a lot of trial and error.
   
   Thank you for reading.



3. My biggest complaint with VB.NET game programming books so far (and I've read a few) has been that they either: A) try to teach elementary VB.NET using game flavored examples (but nothing about actual game development) or B) try to take existing game programming material and shoe-horn it into a VB.NET book. Sadly this book falls squarely into the second category (so far).
   
   It's quite obvious that ALL of the sample code was originally written in C#. No big deal, it's easy enough to convert. However, if you aren't a VB.NET guy, don't you dare write a freaking book with VB.NET in the title. There are more differences between VB.NET and C# than just syntax!! For the love of god, 85% of the code samples (encountered so far) do NOT work as printed in the book. Some have glaring C# syntax still in them, but only in places... often sharing a line with VB.NET syntax. The tech editor should be drawn and quartered, on TV.
   
   To make matters worse, the main author seems somewhat condescending (arrogant?) for someone who's never actually published a game in his/her life, ever (and had to have TWO other people write the book with him... neither of whom have ever published a game either.) This is an actual quote, immediately after some collision detection code that DOES NOT work as printed... If you think this is too much math, this is probably the place where you should take this book back and take up something less mathematically demanding, like nuclear physics! Ok... seriously? That comment would be a lot more impressive if your code ACTUALLY WORKED!
   
   So far I have nothing positive to say about this book, so let me see... ok well, the girl on the back cover is kinda cute (allegedly one of the authors, although I have no idea which sections are written by whom... is that good or bad? You tell me.) Oh yeah, and the price I paid was 40% off, although sadly I still feel ripped off!
   
   FWIW, I did eventually get the collision detection code to work on paper, although NO explanation is made for why the algorithm handles things a certain way, and the reader is told to perform a simple Google search for more info (I kid you not!!). I'm guessing this is because they don't actually know why the code they "borrowed" (from the net?) did things that way either.
   
   At this point, I'm almost considering this book as a possible alternative energy source. I can't believe anyone at one of my favorite publishers actually read this book prior to printing it and selling it for $50 a copy. By the time you rip out the index, table of contents, foreward, introduction, recommended reading and 'about the author' section... it's barely 350 pages. Yes... I know it's not about page count, but when quality is already out the window, what other metric is there?
   
   I'm not going to tell you the name of this book or the publisher (yet), because even though I've managed to work up this much bile and stomach acid over it, I'm only on page 35. God help me, I hope it gets better quickly.
   
   It's funny, every truly good tech book I read makes me less inclined to try writing my own. This book, however, has convinced me that I still have a pretty good chance at getting published.



4. I would hate for people to get the wrong idea about the book from reading the other posts. This really isn't a bad book.
   I am completely new to game programming (although not new to VB), and following along with the examples I was able to get the Tetris, Caterpillar and other games to work.
   This gives a good introduction to game programming, covering both 2D and some 3D graphics.
   
   But the book isn't all about writing the code. It also tells the reader how to plan out a game before coding, and gives good tips on keeping the project on track.
   
   The book isn't perfect though. There are some errors in the code (but only one glaring instance of C# code in the VB code).
   But APress has followed up, and has posted some code corrections on the web-site, and gives the downloadable code which helps a great deal.
   
   I found the text of the book to be very easy to follow. The author has more of a conversational style than lecturing.
   
   I think the book succeeds in being a good introduction to game programming. Getting the Tetris game to work gives you the incentive to keep reading and learning. Plus, it is fun to play your own game!



5. I am halfway through this abomination and only a masochistic bent will force me to continue. I initially thought that I could easily pick up any beginning programming book and breeze through it but I am new to VB.net and have been away from programming for a couple years so the MASSIVE amount of Typo's, random variable names, extraneous nonsense, as well as items that are left as an exercise for the reader -- most of which are anything but trivial -- make this a medication consuming, frustration-fest. I was considering trying to sell it second-hand but I would foist this dead tree turd on my mother-in-law. Not to mention it's poor condition from heaving it out the window numerous times. Don't, I repeat, don't consider this purchase!!! Pitiful, just pitiful!

5 comments about Moving to VB .NET: Strategies, Concepts, and Code, Second Edition.

1. This book was all I expected and more. It not only teaches VB .Net by example, but also positions VB .Net with VB 6 and explains Microsoft's reasons for dumping COM to go with CLR (Common Language Runtime). Issues of deployment and productivity are explained in a candid way, unlike the shill-like explanations that come out of MS Press. I'm on the Dan Appleman-as-a-guru bandwagon.



2. There are a lot of books out there for transitioning to VB.NET from VB6. However, before you grab any other book, I strongly suggest "Moving to VB.NET: Strategies, Concepts, and Code" by Dan Appleman. Written from an in-the-trenches, "I've been there" point of view, Dan introduces the reader to .NET using the single best possible approach: from the ground up. Due to the steep learning curve associated with .NET, approaching this subject is tricky, but I feel Dan has done a truly excellent job. Up front, this book is in my opinion the first book a VB6 person should read on the subject. It also helps that it is structured in such a way that it could be easily broken down for a classroom environment, getting a company up to speed.

   One thing Dan really stresses is for the reader to familiarize themselves with the MSDN library. That point cannot be stressed enough. Unlike previous versions, MSDN for .NET was written with the VB.NET developer in mind, and is completely VB-friendly. Also, in the rare cases where Dan fails to explain an item right off the bat, such as the `Shared' operator (he does get to it), or the really cool `IntPtr' variable type, just quickly look them up in MSDN. The wealth of available information found there is fantastic.

   When you crack Dan's book, please be sure to download the example files (and any errata updates) from the site location he suggests. Being able to view, run, and hack complete listing is an invaluable tool in comprehending the points he is making regarding each subject (I like them just so I can add expository comments once I understand a technique -comments are sparse, but just to keep space tight because much of the code, broken into blocks, is also in the book).

   Though easy to read, this book is definitely not one to skip chapters on. If you do not fully understand everything in a previous chapter, the next chapter can be more difficult to digest. I was surprised that often a chapter would require only a second re-read to fully comprehend everything covered. Making reference notes and clarifications in the broad margins as "Notes-To-Self" is also a great help when you finally place this book in your reference library - and it WILL find itself there. This book is loaded with very powerful techniques that you will want to refer back to again and again.

   This book has also crushed my habit of harkening back to the glory days of VB6, and of calling VB.NET by derogatory names such as Visual Fred and VB.NOT. Not only does the book explain the differences in structure between VB6 and VB.NET, but in the process it completely turned me on to the VB.NET philosophy and the much more powerful, and most-often much simpler methods of doing them in .NET. Every point I had once griped about, such as, for example, the `lack' of fixed-length strings and arrays in user-defined types was shown to be completely unfounded. Things that I complained that were missing have been in fact replaced by something much better and more powerful.

   With this book as a launching point, in a day I can now develop applications under VB.NET that are just as powerful, and run just as fast as the C++ applications I used to develop over several weeks under Visual Studio 6. The book's author has shown me the way toward being comfortable with the.NET environment, and made me excited in my transition to it.

   All things considered, after reading Dan Appleman's book, I now wish Microsoft had come out with .NET after VB5.




3. As I have come to expect from any text by Dan Appleman, Moving to VB .NET gives a thorough discussion of the topic, including tips for evaluating how/when/whether to deploy .NET for your organization based on your particular business needs. Mr. Appleman combines impressive technical knowledge with a sharp sense of humor to make this book as readable as it is informative. I recommend it to any experienced VB programmer looking to make the transition to .NET.



4. Appleman's Developing ActiveX Components with Visual Basic 5.0 was so good that I bought Developing COM/ActiveX Components with Visual Basic 6.0 when it came out. Both of these were among the very best VB books of all time. Unfortunately, Moving to VB.NET is not in the same camp. The book tries to introduce VB6ers into VB.NET, but does a very bad job of getting from A to B. Most developers can understand most of .NET after discovering that it's 80% Java with keywords changed. Instead of starting with this foundation, the book wastes a lot of space explaining prinicples that are new to only the most hardcore Microsoft zealots. In Appleman's defense, this book was first published when .NET was still in beta and was likely rushed to press. Don't get me wrong, there is some great technical content here as Appleman is still a great technician and good at explaining the "internals" of things. The COM Interop and Accessing the Win32 API chapter is particularly good and helped me get through a VB6/VB.NET integration project. If you're totally new to VB.NET and find this book on sale, buy it; otherwise, don't bother.



5. So many .NET books are a rehash of the documentation, or say the same things as a million other books, at best in a slightly different way. This one isn't like that at all. It's full of real-world practical perspective and reality checks such as (to paraphrase) "it will be years before .NET is really being used in production", and "dont use inheritance or threading unless you really know what you're doing". Besides that, its outstandingly well written and oozes attention to detail on every page. One criticism I might level is that its really not all that VB specific - a chunk in the middle is, but much of it applies equally to the other .NET languages. Everyone is entitled to their opinion, but I am honestly baffled that so many folks gave this book a negative review. Dan, please keep it up!

2 comments about Microsoft Excel/Visual Basic: Step by Step (Step By Step Series).

1. I would recommend this book to anyone who is reasonably accomplished with Excel (or similar) and needs/wants to get more out of the spreadsheet program. For me, it has also proven to be an excellent way to grasp more of the fundamentals of Visual Basic at a quicker pace than the VB3 / VB4 books I have. Mr. Jacobsen (Jacobson?) uses some occasional light humor and rarely uses computer jargon in his book. I really appreciate the emphasis he places on using the macro recorder when convenient to substitute for extensive typing. He also demonstrates that if you don't know how to code something, you can use the macro recorder (which records in Visual Basic code) and then read the generated code. We just began the upgrade to Office 97 at work; when it gets to my machine I'll purchase the next edition of this book so I can keep one copy at home and one at work



2. This is one of the best computer books I have ever read. I hesitated to buy a "tutorial" type book, but the Excel/Visual Basic book that came with MS Office was not sufficient. Reed Jacobson's writing style was excellant! He made good use of analogies between real world events and Excel/Visual Basic. His use of the Macro Recorder was a clever way to familiarize the reader to the Visual Basic language. Although meant to be a "tutuorial" type book, this book provided the best explanations of objects, procedures and methods that I have found in any book. I would highly recommend this book to anyone who would like to increase their efficiency in Excel through customization (i.e., programming w/ Visual Basic)