5 comments about Advanced Microsoft Visual Basic 5 (Microsoft Programming Series).

1. This is not a 'learn-VB' book, basic, intermediate or advanced; nor is it a VB reference. It's just a disjoint series of vague discussions on stuff developers Don't need to get the job done.



2. Definitely NOT a tutorial. Great gobbets of information to make you think.



3. remember this: Microsoft don't make the best book, and this is one of them. I hate to say, I waste my money buying this book..



4. remember this: Microsoft don't make the best book, and this is one of them. I hate to say, I waste my money buying this book..



5. Many errors. Chapter 5 on using only Variants is a joke. This is very bad programming practice. Since this book has many different authors contributing their own articles, I would need to judge each chapter seperately. Some are very good (chapter 15 on reusability) and others are horrible (chapter 5). I suggest skimming through this book at a store to find if it has some articles of interest to you. It is certainly not a tutorial (hence the title "Advanced"). Programming is not a very debatable topic, so anytime you find an author who challenges common established practices, be wary of him. This book has some articles from those types of authors, who for some reason, are still living in the days when BASIC was a toy language. Visual Basic is certainly not that, and it is progressing to be structured very much like other solid languages.

No comments about Visual Basic 6 Programacion Orientada a Objetos.

No comments about Advanced Visual Basic: A Developer's Guide.

No comments about Visual Basic 5.0 for Windows.

No comments about Microsoft Visual C++. Net.

5 comments about SAMS TEACH YOURSELF MORE VISUAL BASIC 5 IN 21 DAYS.

1. I am a novice programmer, I tried to use this book as a guide to learn visual basic at my own pace. but I was frustrated with the styles and ways of author to convey their message. The presentation style is weak and I learn nothing by using this book.



2. though it's easy, it's too easy and therefore incomplete in many aspects such as API, OCX. if you really want to understand VB, don't recommend this book



3. Although the content isn't bad, the number of errors is unacceptable. I am approximately half way through the book, and so far have encountered 8 errors. I have only skimmed some chapters, so more errors are probably present. Many of these errors are in the code examples -- this is unforgivable, as simply compiling and running these would reveal the error. My E-mail to the publisher has gone unanswered.



4. Book covered a good topics and might be very helpfull, but where is CD? Without source code - this book 80% useless. Maybe it has ftp sight and readers could download themself



5. I have started to learn Visual Basic 5 nearly 1.5 years back, and this is the first book that I started with. I was so much discouraged with the the material in this book that I have not yet mastered basics of Visuual basic .

No comments about Visual Basic: A Beginner's Approach.

No comments about Autocad: A Visual Approach : 3d Basics : Release 13 Windows/DOS (Autocad Visual Approach Series).

1 comments about Visual Basic 4 Nuts & Bolts: For Experienced Programmers (Nuts & Bolts Series).

1. At 338 pages, this book is much smaller than many of the behemoth Visual Basic books. It focuses on explaining the Visual Basic environment and language to people who are already familiar with Windows programming in other environments.

   As a tutorial, this book was a great help. It's not a reference, and is best used as a supplement to the VB documentation. It's well worth the $25 cover price.

1 comments about Logical Problem SOlving.

1. This book purports to teach problem solving skills, that is, how to come up with a solution to a problem that we have not encountered before. The author's thesis is that it's easy to "solve" a problem when we are given an equation or formula, because all we're really doing is plugging in numbers and performing a computation. The object of the book is to learn how to solve the problem without having the formula given. To assist in doing this, the author provides a number of rules, such as:
   Rule 1: The Clarity Rule.
   1. Be clear about what information you have to work with.
   2. Be clear about what information you are trying to discover.
   Rule 3: The Picture Rule.
   Whenever possible draw a picture.
   He also gives many example problems with the solution design worked out and displayed in pseudocode and as a flowchart. There is generally a good clear description of how the solution was achieved, and the inclusion of both pseudocode and a flowchart makes the text accessible to readers with differing learning styles. For each problem there is also an implementation as a C++ program in text mode and as a Visual Basic program, each with comments describing how it works.
   Unfortunately, the devil is in the details and in this book the details do not live up to the promise. Take, for example, Problem 1.3: "What Celsius temperature is equivalent to a given Fahrenheit temperature." If we were given the formula C = (5/9)(F-32) all we would need to do is substitute the Fahrenheit temperature for F and perform the indicated arithmetic. The point of this book, however, is to find a solution without being given the formula.
   To demonstrate the problem solving process, the author supposes that we don't know the formula but do know the freezing and boiling points of water in both Celsius and Fahrenheit. He lists as "initial data" these "commonly known facts" and then explains how the formula can be deduced. Unfortunately he leaves unstated one crucial assumption, namely that the relationship is linear. In this case it is linear, but there are plenty of other relationships in the world, such as the distance a marble falls through air in a given period of time, that are not linear. If the relationship between Celsius and Fahrenheit temperature were not actually linear we could still follow the procedure outlined by the author but we would deduce a totally invalid formula.
   In the C++ implementation and the accompanying discussion the author again stumbles. He correctly states that writing
   Ctemp = 5 / 9 * ( Ftemp - 32 ) ;
   in line 11 of the program, while it is legal C++ code, will not get the job done correctly and why. He suggests three possible ways to make it work correctly, but ignores a fourth way that is probably the most simple, namely rewriting the line as:
   Ctemp = ( Ftemp - 32 ) * 5 / 9 ;
   Many other problems solved in the book likewise have issues. For example, it is certainly true that correctness of the solution is more important than efficiency, but it would be nice to have a reasonably efficient solution. In problem 2.2 the C++ implementation uses the power function three times to calculate the same value. The power function is expensive in terms of the computer's time, so it would be much better to calculate the value once and store it rather than calculate it three times. In fact, in this particular case the value is used inside a loop and the same result can be obtained by multiplying the value by two each time through the loop and avoiding the power function entirely.
   Problem 3.4 deals with finding estimates of the solutions of a fifth order polynomial equation. After introducing Rule 11, The Function Rule, the author proceeds to write C++ code that evaluates the polynomial in four different places. This is an ideal situation to apply the rule just stated on the previous page by writing a function to evaluate the polynomial at the required value, but the author doesn't do this. Instead he inserts the complete code to evaluate the polynomial in each of the four places in the program. (He also uses a very inefficient method to evaluate the polynomial, but that's a different issue.)
   In short, if I were using this book as a text for a course that I teach, I would end up spending time almost every class period explaining why the author's discussion is incomplete, what assumptions he failed to mention, and how his C++ code can and should be improved. I realize that this book is intended for an introductory problem solving course, or as an accompaniment to an introductory programming course. Novice programmers would not be expected, in general, to think of some of these issues on their own. On the other hand, novice programmers learn to write good code in part by reading and analyzing good code, so I find it unfortunate that the author has provided so many examples of poor code.