Customer Reviews

Microsoft Visual Basic Design Patterns (DV-MPS General)

5 star:		(4)
4 star:		(2)
3 star:		(3)
2 star:		(1)
1 star:		(0)

 

 

The author acknowledges Gamma et al for their brilliant `Design Patterns' book and recommends that we read it (there are 23 patterns described there). I could not agree more, as the introduction to patterns found there is far superior to the one in this book.

To take advantage of most design patters in VB, one has to tweak them a bit so as to cater for the lack of some OO features in the language. It is exactly that that this book aims to fulfil. Chapter 2 (30 pages) provides an excellent description of VB's OO limitations and how to overcome them. The main points are further reiterated as necessary while describing the patterns in chapters 4-14.

10 patterns are described, 7 taken/based on the Gamma (Adapter, Bridge, Proxy, Factory Method, Prototype, Singleton and State). The other 3 are: Object By Value (a serialisation pattern), Repository (persisting object state to a data store) and Event Service (alternative to the Event mechanism that is based on connectable objects). Although each pattern is described in detail, Stamatakis uses a derivative of OMT for class diagrams and his own notation for sequence diagrams; personally, I found his diagrams hard to follow and also inaccurate. In addition, his writing style proves his claim that he is a developer first and a writer second. On the upside, for each pattern he provides a mini application with code on CD, which is a great idea and very useful.

Finally, a good job was done at describing further insights on the effects of each pattern to COM components. There is good stuff in this book...if only the writing style and notation were friendlier...

If you're an intermediate programmer and are looking for that extra knowledge that is getting harder to come by, then I'd say get this book. It helps make your applications more intelligent and cleaner (much like when you discovered how cool linked lists or trees can be).

This is one of those books that I read from cover to cover. The book only presents a few design patterns (I wish it had more), but it is enough to give you the ability to look at patterns designed in other languages and adapt them to VB. The author provides a simple and clear working example of each pattern and in some cases presents multiple variations of a pattern.

Visual Basic finally gets treated with the respect it deserves in this thoughtful and well-written work. Drawing on the work of Gamma et. al., Stamatakis offers up VB examples of the more popular design patterns with lucid and clear explanations. The sample code provided is worth the price of the book alone. A must have for any serious VB developer.

One of the main reasons that Visual Basic has not received respect from the OO world is that it lacks a few features that the OO purist is used to having, namely Implementation Inheritance and the ability to overload and override functions. While VB 7 is slated for these features, it is nice to have a book that shows you methods around these shortcomings today.

Stamatakis' book begins with an intro to both design patterns (Object Oriented methodologies) and the OOP methodology of Visual Basic. He goes over the Visual Basic implementation of OOP and shows methods to get around areas where VB falls short. He then covers the basics of COM necessary to creating distributed (Object based) software. The rest of the book covers individual patterns of VB OO development and includes scenarios for use, ramifications of using along with copious example code (the CD sample code alone is worth the ticket price).

The book borrows from Design Patterns (Erich Gamma, et al) and applies the theory to Visual Basic development. If you are serious about developing VB COM components, this book should be part of your library.

This book is a rare find, especially by Microsoft Press. This is VB coding taken to the next level. Perhaps very useful for the .NET strategies coming up (we'll see what the final 'OO' implementation is like). This way of coding, shown by wonderful examples, is almost the exact opposite of every other way you've been taught to code in VB but it will make you think and understand why JAVA gets all the press these days.

It's a great source for inspiration to pull you out of normal 'down & dirty' VB coding.

This book is strong in working examples of patterns in VB, but the explanations are not good enough for a beginner to patterns. I will probably get the "other" VB patterns book by Griver & Gellis.

The first few chapters lay a thorough groundwork on the various aspects of Object Oriented Programming and how it relates to the current version of Visual Basic. The second chapter which guides the user through how Visual Basic actually applies OOP is very clear. The design patterns are given ample explanation and the code samples work. I have a much better idea of how to use design patterns in my day to day programming.

it's a good book, the author tries to explain how you can implement in VB 6.0 the patterns exposed in "Design Patterns" bible. He also explain the limits of VB, how a "workaround" can be done, the book has many examples, good explained code. I recommend this book to everybody that might need a design pattern solution with VB 6.0. What i wonder, will be there a 2nd edition of this book, updated with the new features of new coming VB 7.0 which (as Microsoft says) will be 100% obect oriented?

If you want to learn about design patters, read "Design Patterns Explained: A New Perspective on Object-Oriented Design by Alan Shalloway & James R. Trott" (ISBN: 0201715945 ).

This book does very little to explain anything to a level useful for neophytes; instead, it's got a few examples of how to use VB to implement a few of the more common design patterns. The best thing I can say about this book is that it's an easy (although light) read.

Also, I had hoped that the CD would contain the text of the book itself (like the great Balena book, which I read more from CD than from paper because it's so useful), but the CD simply contains some sample apps that are marginally useful at best. (yawn)

Well, the title of my review pretty much says it all. I read the whole thing in one sitting, and haven't looked at it again. I didn't really learn anything about visual basic that I didn't know before. Perhaps later, after I read a book that actually teachs you visual basic - I may go back to it for some pointers.

This book can easily be overlooked with no ill-effect...