Visual Basic Design Patterns VB 6.0 and VB.NET (With CD-ROm)

Rating:
Summary: The Only VB.NET Pattern Book (So Far)
Review: As of April 2002, this was the only book to explain patterns using VB.NET code.

It is poorly edited. In the first ten pages of Chapter 2, I found three editing errors that interfered with comprehension of the materials. As I browsed much of the rest of the book, I was annoyed by having to first wade through a VB6 example before getting to the VB7 (VB.NET) example. If I want to be conversant in the still quite new (and very hot) pattern approach to OO, why would I care very much about the old version of VB?

My plan is to just study the original Gang of Four book and to put this one on the self as a reference in case I have difficulty with implementing in VB.NET.

Rating:
Summary: Too language-neutral
Review: Lately we have witnessed a trend in programming books: the author wrote one book and then published it using multiple programming languages using some "smart" organization of the book material. This book is yet another example (it has a Java version).

The problem with this approach, and this book in particular, is that the author tend to ignore the language specific features to make his/her life easier. And this is precisely the problem with this book: the author could as well have published even more language versions because the discussion is so "language-neutral" and all the examples given are so un-VB... I can easily imagine the same examples implemented with Tcl/Tk or Delphi or any other modern programming language, for that matter.

Let's face it. We choose a lanaguage for a certain task because the language has certain desirable feature(s) to make our life easier: the right tool for the right job. As such the approach taken in this book is flawed: "OK, we've got this pattern in GoF, so let's see how we can implement this in VB and VB.NET using the smallest feature set possible" (actually I suspect it's the feature set that intersects with Java most). So we end up with patterns implemented in the "obvious way", which for almost all languages is not the preferrable way because there are probably some specific language features to exploit. This book doesn't, in particular, take advantage of the language's greatest strength: COM integration. Why would a VB programmer choose not to use COM when it is possible, and in many cases more suitable, to implement the design patterns dicussed?

I seriously recommend you to first glance through this book (in person) before you buy it. Better yet, also check out Stamatakis' VBDP book. (Yes, this one uses COM.)

Rating:
Summary: Disappointing
Review: Mr. Cooper seems unsure who is going to read this book. The first eight chapters (104 pages) are devoted to a lengthy yet patchy introduction to VB and VB.net. When we get to the facade pattern in chapter 19, there is a section entitled "What is a database?" I don't believe anyone who doesn't know what a database is is going to get to chapter 19 in this book.

Although the idea of design patterns was attractive to me, I am quite disillusioned after reading this book. It seems that, using this design philosophy, each class should have a specific purpose. So, if your class contains a Select Case or If - Then - Else to determine behavior, Mr. Cooper believes you would be better off creating more classes to handle these special cases. To me, this leads to enormous clutter and an overuse of inheritance. Inheritance should only be used for an ISA relationship.

Just as an example, I was particularly interested in the interpreter pattern because I am in the process of writing a parser to evaluate string expressions with special purpose tokens. The very simple example provided has 24 classes, and my vastly more complex application would lead to many more classes. My Parser will be contained in one class, and have one method.

If I followed this philosophy, my applications, which currently have 100 to 200 classes, would have tens of thousands of classes. Each of them might be "cleaner", but the overall architecture would be a nightmare to write system documentation for.

If you're devoted to this design philosophy, you may well get something out of the book. It's not for me.

Rating:
Summary: Java/Visual Basic/C# Design Patterns, What is next?
Review: Other reviewer already pointed the trend of making such books. I have to say even the first book in his series (Java) is not a good book.
Comparing these books with the original GoF book, the only credit I can give the author is giving an example to each pattern, which is quite a easy job for anyone who knows both the pattern and the language. The GoF book gives much better explaination for patterns (with examples in c++). Therefore this book is only useful to someone who has no knowledge of c++. Even for these people, I would recommand to read this book with GoF book together, GoF first for understanding one pattern, then this book for example of that pattern.

Rating:
Summary: Pretty good, but code snippets are hard to follow
Review: The author means well, in trying to touch on all of the design patterns mentioned in the GoF book (showing how each pattern might be implemented in VB 6 and VB .Net), but the code snippets in the book are often too difficult to follow, sad to say. In reading the sample code, there are many points at which you ask yourself: "What does this variable do? Where did it come from? What the..."

It's not that his code is faulty, it all makes sense when you open up the CDRom and go through things slowly, but the snippets in the book are too sparse to really follow without having your computer on and the VB projects open before you. This "sparseness" was likely done to keep the book's length down some, and if you don't mind looking at your monitor as you read the chapters then I suppose you'll do ok.

My inclination however, is to read the chapters first, *then* look at the code, and I just couldn't do that here and make sense of things. Also, I didn't particularly enjoy some of the sample programs (I thought the "swim meet" samples were somewhat convoluted, for instance), but that could just be my problem.

Now that the critiques are out of the way, I'll give the author credit for doing a good job in explaining why you would use design pattern XYZ and under which circumstances, and for listing pattern examples in both VB 6 and VB .Net. It's certainly not a bad book, just a little tough to follow without VB sitting open next to you.

Rating:
Summary: Waste of money
Review: The source code implementation of the design patterns presented in this book differ radically bewteen vb6 and vb.net (as one might presume). Unfortunately, the vast majority of the supporting text is geared towards presenting an understanding of the vb6 code. It appears as though the vb.net(vb7...) material was added as an afterthought(in a rush), probably after the book had already been largely written. The vb7 material is brief, vague and frankly incorrect in some of the examples! Please don't make your future(?) customers pay for the fact that you got caught with a finished book on a technology platform(vb6), whose sunset was imminent.

Rating:
Summary: Waste of money
Review: The source code implementation of the design patterns presented in this book differ radically bewteen vb6 and vb.net (as one might presume). Unfortunately, the vast majority of the supporting text is geared towards presenting an understanding of the vb6 code. It appears as though the vb.net(vb7...) material was added as an afterthought(in a rush), probably after the book had already been largely written. The vb7 material is brief, vague and frankly incorrect in some of the examples! Please don't make your future(?) customers pay for the fact that you got caught with a finished book on a technology platform(vb6), whose sunset was imminent.

Rating:
Summary: The 23 well-known patterns described by the GoF, now in VB
Review: There is no argument that "Design Patterns" by the Gang of Four is a seminal piece and essential reading for any professional OO developer. There has long been a need for those patterns (illustrated in OMT with examples in C++) to be described in UML and VB. Mr Cooper fills that gap.

The author starts off by explaining what design patterns are; this is one of the best introductions to the topic that I have read. The following 7 chapters introduce UML, OO Programming and VB.NET. In my opinion, these topics cannot be explained in fewer than 100 pages of any book and hence should have been prerequisites on our part (the readers). The result is that the coverage is neither broad nor deep, but nevertheless serves at getting us all on level ground.

The remainder 360 pages focus on describing all the patterns found in the Gamma et al book. It is all very good stuff doing justice to the title, as every pattern description (bar one) is accompanied by examples in both VB6 and VB.NET. Books are coming out continuously that describe various areas of the .NET framework, of the VB language, migration issues etc. It is pleasant to see a book that discusses the deeper aspect of programming good OO software using infamous design patterns.

Depending on your programming domain, you will be delighted or disappointed that almost all examples are GUI based (no component stuff here). Also, this is not a book from one VB programmer to another. On contrary, it is evident that the author's first language is not VB and references to Java/Smalltalk can be found in the text. Irrelevant as that may be, I would have preferred to have seen events (VB6) and delegates (VB.NET) to have been leveraged in the patterns.

To finish on a positive note, this book (and the CD with all examples' code that accompanies it) serves as a good reference while writing software in VB6 and VS.NET

Rating:
Summary: poorly edited book - seems rushed to press
Review: This book, while trying to clarify the subject of implementing design patterns in VB and VB.net, mostly manages to confuse.

Since I had read the GOF book "Design Patterns : Elements of Reusable Object-Oriented Software" before I purchased this book, "visual basic design patterns" by Cooper, I was pretty familiar with the patterns and the solutions for the 23 patterns outlined by the GoF. However, Cooper manages to make his book hard to follow by not including complete code samples and by literally jumping to different examples to illustrate the same pattern. The reader is never really gets a chance to "get in the groove" with the author. It seems to me to be like a poorly edited movie with too many unneeded jump cuts in the middle of the same scene.

If you've never tried to code up the patterns in VB before ( as I hadn't), you absolutely **MUST** open and look at the completed sample code on the cd while reading the book to comprehend and "grok" the VB solutions.

Interestingly, I had no trouble at all reading and comprehending the majority of the GoF book, "Design Patterns : Elements of Reusable Object-Oriented Software" on a first and only read through it... ...So I know it's not an issue of basic comprehension with this VB pattern book, it's just poorly organized.

Truth be told, what this book needs is to be re-edited a couple of times for clarity. It has great potential, and but it forces you to run the cd while reading the text to follow the completed patterns.

That is all well and good, but in my opinion the text in a book should stand alone. This principal is used in all the other programming books I have read. (over 150) This is particularly bad if you are trying to read the book while **NOT** propped up in front of a computer. --- i.e. at the airport or on the back porch at home.

n.

Rating:
Summary: poorly edited book - seems rushed to press
Review: This book, while trying to clarify the subject of implementing design patterns in VB and VB.net, mostly manages to confuse.

Since I had read the GOF book "Design Patterns : Elements of Reusable Object-Oriented Software" before I purchased this book, "visual basic design patterns" by Cooper, I was pretty familiar with the patterns and the solutions for the 23 patterns outlined by the GoF. However, Cooper manages to make his book hard to follow by not including complete code samples and by literally jumping to different examples to illustrate the same pattern. The reader is never really gets a chance to "get in the groove" with the author. It seems to me to be like a poorly edited movie with too many unneeded jump cuts in the middle of the same scene.

If you've never tried to code up the patterns in VB before ( as I hadn't), you absolutely **MUST** open and look at the completed sample code on the cd while reading the book to comprehend and "grok" the VB solutions.

Interestingly, I had no trouble at all reading and comprehending the majority of the GoF book, "Design Patterns : Elements of Reusable Object-Oriented Software" on a first and only read through it... ...So I know it's not an issue of basic comprehension with this VB pattern book, it's just poorly organized.

Truth be told, what this book needs is to be re-edited a couple of times for clarity. It has great potential, and but it forces you to run the cd while reading the text to follow the completed patterns.

That is all well and good, but in my opinion the text in a book should stand alone. This principal is used in all the other programming books I have read. (over 150) This is particularly bad if you are trying to read the book while **NOT** propped up in front of a computer. --- i.e. at the airport or on the back porch at home.

n.