Customer Reviews

Beginning Visual Basic 6 Objects

5 star:		(26)
4 star:		(8)
3 star:		(3)
2 star:		(5)
1 star:		(5)

 

 

I am fairly new to object oriented techniques in VB. I used this book last spring to learn VB OOP. As I got into chapters 6, 7 and 8 it started to fall apart. It seemed that the pieces were not making as much sense.

Recently I purchased Visual Basic 6 Business Objects by Rockford Lhotka. In the first chapter he reviews basic VB OOP. When he covered interfaces I understood how to use them in VB for the first time. Before they seemed to be totally out of sync, very unintuitive, a real waste of time and effort.

Well, I went back to Beginning Visual Basic 6 Objects and found out why I found the interfaces so confusing. Peter covers interfaces in chapter 3, and he really doesn't have a grip on them. His lack of understanding makes them seem useless. When I used the book last spring I thought that it fell apart after chapter 5. I was wrong. It was already going bad in chapter 3.

I also found Peter's way of congratulating himself to be irritating. The humor's corny but I can live with that. Better corny humor than none I guess.

Having criticized the book I will say this, I did learn from it. It has some weak points, but it will teach you the basics of VB OOP. When it misleads it just gets kind of muddled. The examples work for the most part.

I can't give a strong recommendation for this book, but I will say that it is miles ahead of the one by Deb Kurata. Her book seems to be an effort to evangelize programmers to her methodology for developing OO programs.

Let me put my review in perspective. I have been programming in one language or another for twenty years. I was the project manager for a Fortune 500 company's e-commerce initiative. I do some consulting on the side. In other words, I consider myself to be a veteran programmer.

As you know by now, most programming books fall into one of two categories: expert references, or trivial introductions. Wrox books fall somewhere in between. As a result, these books usually create some controversy over who should read them. I find them to be exactly what I need, and interesting enough to read from cover to cover.

"Beginning Visual Basic 6 Objects" is actually a follow-on book to Peter Wright's excellent "Beginning Visual Basic 6." Not surprisingly, this second book focuses on the implementation of object oriented programming (OOP) in Visual Basic. This was an area that I thought was given short shrift in the first book, and so I was eager to read this one.

Now, there are many OO purists out there who will assert that VB doesn't support OO programming for a variety of reasons. I would venture a guess that if you are one of these people, then this text is not the one for you.

The book opens up with a fly by of its contents, including a smattering of OO theory, ActiveX controls, and even OO design methodologies. Wright makes a few unsupported comments about the benefits of OOP that will have to wait eight or nine chapters before they are born out. Then we start writing classes and have a nice discussion about object interfaces. I particularly liked the discussion about the way VB can "implement" an interface, and how VB can simulate inheritance through the use of containment and delegation.

As a side note, I explored the possiblity of implementing interfaces through three levels of objects: given three objects A, B, and C, object B implements object A's interface, while object C implements object B's interface (which includes object A's). This is feasible in C++, but apparently not in VB. This scenario was not covered in the book. Consider this information a benefit of suffering through this review.

Object hierarchies are covered next. I enjoyed the chapter-end "questions" which recap the important topics. There have been many times when I have read a book, but when I tried to apply those lessons to a real project, I found myself a little uncertain. By working through these problems, I was able to ride with training wheels. The answers are even provided in the back of the book, which is a welcome feature compared to some of those college texts I read which just beat me up without letting me know if I was right or wrong.

The book goes on to cover ActiveX controls in detail, even those without a visible user interface. There were some redundant discussions regarding property pages. Even more disturbing was a complete lack of attention to the PropertyChanged event; this event should be called within the code so that the Properties window within VB's Integrated Development Environment is updated when you make a design-time change. The code within the book does not include this event, and as a result the classes in chapter 8 are not completely functional (they're buggy, but they're not completely broken, either).

This last point is worth mentioning: there are quite a few errors in the book. However, Wrox provides an online errata section for every one of their books, and it is a tremendous resource.

Chapter 9 is a fantastic introduction to object oriented development. The supplier management case study is a very realistic scenario for most businesses. This case study is continued in the next chapter, when we actually flesh out our design with code. I found these two chapters to be the most challenging as well as the most rewarding of the entire book. They alone are worth its purchase price.

The final chapter wraps up with business and utility objects. This is the one area of the entire book in which I was the most keenly interested, and I was disappointed with this treatment, even for a summary.

Wrox has been known to stuff their books with relatively useless appendices. This book does not suffer from that affliction. Appendix A is a nice primer for Microsoft Visual Modeler, a UML drawing tool that is based on Rational Rose. Appendix B is a three-page throwaway on database programming (a topic that rightfully should be covered in book of its own), and Appendix C contains the answers to the end-of-chapter questions.

Despite its flaws, I found "Beginning Visual Basic 6 Objects" to be an outstanding book. It provided the guidance I needed to take the next step in my VB development education. If you're a novice or intermediate VB programmer who is looking for a mid level exploration of OOP, then this is a perfect place to start.

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!

I have read many VB books and have also taught VB at the two-year college level. This book is a must if you are an intermediate VB programmer wanting to learn how to build classes in a 3-tier architecture. It has clear coding examples that demonstrate how the theory works in Visual Basic. It also explains using Active X components and has an excellent chapter on using Visual Modeler.

This is my 3rd book from WROX. My first two books are fantastic, except for the too-small print which makes them hard to read. This book however is a BIG disappointment. The author probably knows what he is talking about. He just doesn't know how to say it clearly. Because the book jumped around from topic to topic without cohesiveness, it comes across as a hodge podge of this, that, and the other thing. I found it annoying when the author frequently referred to his "other" book instead of including an extra page or two to review the topic in this book. What a concept!

I don't recommend that you buy this book. Get a copy of John Smileys book on Programming Objects with VB 6. Smiley's book is more cohesive and I prefer his teaching style.

I gave this book 3 stars instead of just one, because it's not all bad. I must have learned something from reading it and doing the exercises, though I am hard presed to say exactly what I learned.

This is truely one of the worst books I have ever encountered. First of all polymorphism is one of the central concepts of object oriented design yet I see no mention of it in this book. The author has a painfully annoying style of writing and does stuff like (p88) "When you're done, try running the application again, and you'll quickly find that it doesn't work. It's actually very interesting why things aren't working yet. Visual Basic looks at this code and says "Okay, the programmer wants me to run the MoveFirst method on the Titles object"." But DUH! we didn't change the code yet. Do I really need a book to demonstrate forgetting to change some obvious code central to the whole point??? The subject matter does not build well and the author keeps having to say that if you don't know this you should read my other book or take a peek a few pages ahead. These are only a few examples of what the book is full of.

What a waste of paper!

This is the one book I would recommend for any VB developer. I wish I had bought it earlier. I have been recently interviewing for new consulting contracts, and this book gave me the review on known material, and the introduction to new stuff that I needed to ace my technical interviews. It gives a smooth intro to object-oriented methodology and design, and will help you at any stage of your career. My friend never really got OO and wasn't using classes at all in his projects - I got him to read this book, and now he has a firm grasp on OO and his code is much easier to work with. It evens gives you a primer on UML, user controls, property bags, and some really good design methods and ideas. Stay far away from Kurata's book on objects, this is the only one you'll need!!!

There are some nuggets in this book, and where it's good it's good. Where it's bad it's very bad. It doesn't go into much detail on COM development, but then it only sells itself as having an introduction on the topic, so that's fair enough.

The conceptual introduction at the start is a bit tedious to read but reasonable. The guided tour of OO design and implementation in the last three chapters is quite good. In between are chapters on ActiveX control design which seem out of place and which are way below the level of the rest of the book. They feel like filler to make up thickness, a perception reinforced by the level of instruction in these chapters, along the lines of "position the mouse cursor over so-and-so, right click and type foobar in the text box, then press return". That's not the level of instruction even beginning programmers look for.

Apart from the humour (the less said the better) there's one other irritation: The author's use of terminology isn't consistent. On one page he may call a widget a widget, on the next it'll be a gadget. That doesn't aid comprehension. It feels as if parts of chapters were written out of sequence, perhaps weeks or months apart.

In my humble opinion this book needs some serious editing (for consistency) and slimming down (to get rid of the fluff). It's just not lucid enough.

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.

If you don't know the contents of this book cover to cover,then you're contributing to the negative stereotypes surroundingvisual basic programmers. This book is a must for beginners and intermediates alike. The material is presented in a very organized format and is easy to follow with practical examples.

BUY IT. READ IT COVER TO COVER.