Visual Basic is the wild west of modern software development tools, supporting RAD (rapid application development) and seemingly promoting a ready, fire, aim approach to developing applications. UML, the Uniform Modeling Language, and a software process aren't always easy to use with VB, and most UML books take a high-level view that make it hard to apply to VB development.

Developing Applications with Visual Basic and UML breaks ground in an area where I've seen no other book yet do a good job, applying UML to VB. UML is a complex design notation that works best with object oriented design and programming tools, but VB 6 is at best object-based. Reading most generic UML books requires, at the very least, an advanced degree in computer science, keeping it to the intellectual elite of the software world. The author has bridged this gap effectively, relating the various diagrams and tools in UML to VB applications, demonstrating how you can apply them to real applications. And relating terms and concepts in VB to those in UML is a big help as well.

This is a complex, in-depth book, and it would be easy to get lost in the conceptual discussions and sample project. But between the clearly marked process diagram used consistently throughout, goals and checkpoints that start and finish each chapter, and constant relating of new concepts to those covered before, the author helps the reader stay clearly focused on the big picture and which part is being discussed.

Rational Rose is used as the sample design tool throughout the book. This might annoy readers using other tools, but the Rose-specific discussions were light enough that you should be able learn the technique well enough to apply it with other tools. The author sometimes gets bogged down in a few too many step by step listings to accomplish a given task in VB. Anyone picking up this book had better have a pretty good feel for VB already, or will become quickly lost.

The one thing that mildly annoyed me is that the author introduces yet another design process methodology, his Synergy system. Synergy seems reasonable enough-I haven't yet given it a work out-but I'm not sure that the world needs another methodology.

I'm not sure that you could sit down, read this book, and emerge an effective design engineer for enterprise applications using VB. But if you have a good feel for what it takes to build robust applications, have some familiarity with software engineering concepts, and have struggled applying them to VB projects, the book provides an excellent bridge between VB and UML. Certainly the best I've seen so far, and applying the techniques are sure to improve your development projects.

This book did fill the purpose I bought it for - to help get me started down the UML path. It provided a good starting point to figure out how each UML diagram maps to VB concepts. But, the author has a very bizarre methodology that he uses to build applications, which he uses this book to evangelize. I found myself disagreeing with much of what he wrote. I skimmed the last half-dozen chapters due to the very high level of unfounded personal theory, and poorly laid out code examples.

The other major problem with the book is that the middle part reads like a user's guide for Rational Rose, a tool most programmers cannot afford. Visio would have been far more relevant, although if it could have been made tool-agnostic with regards to modelling applications, that would have been even better.

Overall, I found the book to be worth the money it cost, since the first part of the book really helped me understand how UML works, the time I wasted with the last part really wasn't worth it. Due yourself a favor, if you are a VB programmer who wants to learn UML - buy the book, and rip out everything from around the middle of the book onward.

Reviewer: johare4 from Santa Fe, NM USA This book falls in between Terry Quatrani's book "Visual Modeling with Rational Rose and UML" and Murray Cantor's book "Object-Oriented Project Management". Terry's book focuses on the mechanics of using various UML diagrams. The examples are based on a simple Course Enrollment system that serves to provide an example of the diagrams, but not much more insight than a a bus tour. Murray's book hits the management issues and provides a more realistic example of an aircraft cockpit simulator. He focuses on the management issues and ably describes how UML can help with the customer relations,team communication, and keeping the project on track and on budget. Paul Reed tries to do all these things and includes a lot of code to boot.

There is a problem with Paul's approach. Because of the amount of detail, I found it easy to get lost. What issues are balanced in ending up with Paul's choices? Paul tries to tell me, but the issues are so closely tied to the Remulak Productions example of a musical instrument company that extraction of the idea from this particular example can be a headache that takes you back and forth through a lot of code and a lot of chapters. In the end, you will know far more than you ever wanted about Remulak Productions.

I find the issues and the art much more lucidly presented in Ivar Jacobson's "Object-oriented Software Engineering".

Bottom Line: If you want to know semantics: Quatrani, if you want to know management: Cantor, if you want a lot of detail, particularly how code is generated: Reed, if you want perspective: Jacobson.

Reviewer: johare4 from Santa Fe, NM USA This book falls in between Terry Quatrani's book "Visual Modeling with Rational Rose and UML" and Murray Cantor's book "Object-Oriented Project Management". Terry's book focuses on the mechanics of using various UML diagrams. The examples are based on a simple Course Enrollment system that serves to provide an example of the diagrams, but not much more insight than a a bus tour. Murray's book hits the management issues and provides a more realistic example of an aircraft cockpit simulator. He focuses on the management issues and ably describes how UML can help with the customer relations,team communication, and keeping the project on track and on budget. Paul Reed tries to do all these things and includes a lot of code to boot.

There is a problem with Paul's approach. Because of the amount of detail, I found it easy to get lost. What issues are balanced in ending up with Paul's choices? Paul tries to tell me, but the issues are so closely tied to the Remulak Productions example of a musical instrument company that extraction of the idea from this particular example can be a headache that takes you back and forth through a lot of code and a lot of chapters. In the end, you will know far more than you ever wanted about Remulak Productions.

I find the issues and the art much more lucidly presented in Ivar Jacobson's "Object-oriented Software Engineering".

Bottom Line: If you want to know semantics: Quatrani, if you want to know management: Cantor, if you want a lot of detail, particularly how code is generated: Reed, if you want perspective: Jacobson.

It is just that good! Coming from a primarily Unix world, I was looking for a book to help my transition to VB -- but not just a reference on coding -- one that had real world applications from start to finish employing today's technologies which are robust and resilient enough to stand the test of time. I found it in the book: Developing Applications with Visual Basic and UML. Paul Reed covers extensive ground in this book from gathering requirements to class design to code generation, painstakingly detailing each phase while employing UML throughout. His discussions on Microsoft's tiering architecture and DDL generation from modeling tools were most enlightening real world techniques. Personally, I feel that this book is for anyone looking for insight into proficient system architecture whether or not you are using VB.

I lead a small team of software developers and have been trying to figure out how to use UML to bring some method into the madness that is our design, development and implementation process. Before picking up Paul Reed's book I hade looked at UML Distilled(Fowler & Scott) and Fundamentals of OO design in UML(Page-Jones) both these books were heavily recommended as introductions and I found them helpful. After reading them I had the strong feeling that UML was just what I was looking for but could not quite see exactly how I would use it in my work. I could see that UML presented an array of powerful and useful diagrams but could not really figure out quite how they related to each other. Reed's book really breathed life into UML for me. Reading it I began to understand how the UML diagrams fitted together in the context of a development process. It gave me the insights to begin to see how we can use UML in our work.

I have used Visual Basic quite a bit so the VB focus in the book was helpful. However, the book stands well as an introductory text on UML for those with no knowledge or interest in VB. The book gives a good (and critical) description of the Microsoft Technology landscape - DNA, COM/DCOM, MTS, ASP. Reed clearly explains what these things are and how to use them within context of UML/OOD.

The theme here is 'process' and round-trip engineering using a tool (Rose). Although it assumes knowledge of UML and Visual BASIC it spends some time introducing its OO aspects and how UML maps to VB. The focus of the book is the Synergy process that uses the UML notation and applied here in VB. Personally I believe that each developer or team should have their own process depending on the domain and type of project but nevertheless there are some great techniques to borrow from Synergy and add them to your own. In particular the discussion on use case analysis and the progression to class design from that is very good. Weaved throughout the chapters is the use of Rose for keeping code and design in synch so if you are not a Rose fun this might get in the way. Worth noting is that the case study is taken through the whole project life cycle stages and the climax is the translation of the same code/design of a standalone system to run in MTS and then a further iteration is described for giving the application an ASP web interface - excellent stuff if you are interested in Microsoft's component technologies.

The theme here is 'process' and round-trip engineering using a tool (Rose). Although it assumes knowledge of UML and Visual BASIC it spends some time introducing its OO aspects and how UML maps to VB. The focus of the book is the Synergy process that uses the UML notation and applied here in VB. Personally I believe that each developer or team should have their own process depending on the domain and type of project but nevertheless there are some great techniques to borrow from Synergy and add them to your own. In particular the discussion on use case analysis and the progression to class design from that is very good. Weaved throughout the chapters is the use of Rose for keeping code and design in synch so if you are not a Rose fun this might get in the way. Worth noting is that the case study is taken through the whole project life cycle stages and the climax is the translation of the same code/design of a standalone system to run in MTS and then a further iteration is described for giving the application an ASP web interface - excellent stuff if you are interested in Microsoft's component technologies.

Paul Reed hit a lot of nails right on the head. This book is a useful combined walk-through of his "Synergy" analytic process, UML, Rational Rose, and Visual Basic. It was useful and interesting to read. The combination of the process and tools here have powerful potential to increase productivity and success.

Mr. Reed's book explains the UML and its use with VB application development very clearly and concisely. Not only does it outline an effective development methodology, but it also provides robust, easy-to-use diagrams and templates to apply the process to your own development efforts.

A first-rate treatment of the subject!

As a small independent software developer, I realized that I needed to formalize my design and development processes. After reading this book I now use it as a template for all my projects. The designs I use today follow the chapters as I have yet to see a better outline. As a result of this book, my applications are better designed, more easily constructed, and more accurately priced and delivered.

First my disclaimer. I am a long-time client, partner and friend of Paul Reed.

However, I thought it was important to point out the specific benefits that any analyst, designer, VB developer or manager will gain from this excellent book.

Paul's reputation as a writer, consultant and instructor is that he makes the complex simple. In this book, he has taken the confusing world of Visual Basic, OOAD, UML, COM/DCOM/COM+, MTS and the Internet and turned it into one coherent picture using an end-to-end case study of a music retailer. He tackles the main issues head-on:

Is Visual Basic "really" object-oriented?

What does a three-tier architecture really look like underneath the pretty block diagrams?

How do you map an object structure to a relational database?

How can you generate useful VB code from a tool like Rational Rose?

How do use cases fit into analysis of an application domain?

What's the difference between physical application partitioning and logical partitioning? Which do I do when?

What is a really useful example of using the UML to "pen the problem?" (Hint: he does not use an automated teller machine as his example.)

Pick up this book if you are confused about all the terminology surrounding VB, the UML, software development lifecycle and Web development. Pick up this book if you want to see real object models and code that relates directly to the creation of business systems. Oh, heck, just pick up this book!

The real gems in this book are not the UML diagrams or the VB code. The genius of Paul's approach lies in the additional worksheets and tables he has created to fill the gaps in producing a complete software development process. I'm thinking here of the event table, use case coupling matrix, event-frequency matrix, object/location matrix and several others. This turn a theoretical process into something you can sit down and use day one.

My overall recommendation: If you are using Visual Basic on a project, large or small, buy this book. If you are already using the UML and OO techniques, so much the better, this book will be even more helpful.

I found the Rational Rose diagrams in the book soo useful with very clear example and good tips to mapping classes to tables but when I read the code I found very serious mistakes, overall in the business and data access components. First the data access component don't return the correct value when you use a query to insert or delete a record (use records affected to return a correct value) e.g. Cn.Execute MyQuery, ConnectionString, retVal. Finally, the parameter are variant in the function getInfo and you read and skip nulls for each record, If the table has 20000 records! your application probably frozen. You should use a by value recordset and to skip nulls you should make code in a COM component. e.g

txtFirstName.Text = objNull.SkipNull

After buying and reading numerous tomes on the various elements of enterprise development with VB, SQL Server, MTS, IIS, etc., I have found THE book that puts it all together and clears much of the accumulated fog.

The Synergy process and the sample project (Remulak) provide an excellent framework which Mr. Reed uses as a backdrop for his concise conceptual and technical explanations.

This is perhaps the finest development book I have ever read in terms of artfully blending the "what is" and the "how to."

This book has, and will, save me hours of slogging in my efforts to develop my skills and build useful and adaptable business systems.

IDC recently reported that of the 13.1 million developer seats in the world in 1999, 7.2 million were using Visual Basic! This seems to prove what I've told my students that Visual Basic is the successor to Cobol for business application development.

To make that really work with industrial strength applications for business requires the use of best engineering practices. Paul Reed has captured those here in a no nonsense way that works and is being used increasingly by IT organizations to gain competitive advantage.

The book establishes a sound methodology to use with industry standard UML notation. It then goes on to demonstrate the implementation in Visual Basic. This is exactly what every professional application architect needs to know.

This is so good as well as readable that I have adopted this as my textbook for my graduate Object-Oriented Application Development courses.

You should have it too...

This book is one of the most useful books I have ever owned. Buy it, read it and place it in your inventory next to the other classics on the top shelf because you will reference and recommend this one again and again.

Process and structure are increasingly important as VB rapidly moves into the backoffice of corporations and becomes the de facto development platform for more and more business critical applications. Couple this with the fact that the Microsoft-based technology landscape causes us to rethink our application domain on a daily basis and process and industry accepted approaches become an absolute necessity.

Mr. Reed outlines a pragmatic approach to using UML within a process (Synergy process) with VB development better than anyone else. The book covers UML techniques in the proper depth without making the reader muddle through pages of useless text. The example outlined in the book is solid and provides an understandable story anyone can follow and instantly apply to their own situation.

Mr. Reed's experience lends creditability to the concepts in the book and helps the reader understand how to apply these concepts. He distils the copious topics of UML and using a development process into a single book that would otherwise require the reader to work through several books in order to understand these topics.

Hopefully the next version will be in hardback in order to endure its years of use.

Subject: FYI: Review of ISBN 0-201-61579-7 Date: Thu, 02 Dec 1999 15:42:30 -0800 From: Ravi To: ra@rosearchitect.com CC: prreed@jacksonreed.com, egb@rational.com, Grant Larsen , ckobryn@acm.org, ravindra_tadwalkar@thru-transport.com, jayanta@silcon.com

"Developing apps with VB and UML"- a practical look on a practical book for VB/COM developers!

After reading this classic down-to-earth book (I bought it at @OOPSLA99, Denver), I was quite happly able to dive in. The book starts with a philosophical theme called "synergy" process, yet another RUP based process model, I thought.

But as I started reading further, I felt I should recommend every systems analyst to read from chapter 2 until chapter 7. I liked the appraoch of creating event tables to get to use cases.

Salient "analytical" pointers here:

chapter 3: "event lists/tables", where an event = subject (actor) + verb + object

chapter 4: dissection of the Ivor'y definition of use case; thinking ahead in time of deployment componentized architecture.

chapter 5: use case template (looks similar to Alister Cockbern's one); static modeling- particularly "analysis classes" illustrated

chapter 6: "screen structure charts" (as a diagram "type") should be a good addition to UML, with some work (-e.g. web UI, Say Grady, Cris?)

chapter 7: usage matrices; dynamic modeling (-I like when he says "happy path" of use case, as in `sequence diagram of the happy path' ;-)

And as I got to the chapter 8 "technology landscape", the architect in me got hooked onto the rest of the book, since the architectural layers started shaping up. I thought I should recommend every architect and developer (VB or otherwise) in our company to read chapters 8 onwards.

Salient "techie" pointers here:

Chapter 8: some "anti-patterns" (pp. 194-5) for out-of-process communication in COM.(May be when someone writes a book for EAI modeling audience including me and surely Grady and Cris, s/he will have to scale this beyond DCOM).

Chapter 9: design of a persistance framework layer for data access; mapping class design to relational design, rose-scripting for DDL gen.

Chapter 10: services layers need for applying the infrastructure for CBD.

Chapter 11: layers in depth; Rose/VB RTE -interestingly I am toying around with Rose2000 on cleaner RTE and got some food for beta team.

Chapter 12: -- do -- + code change management in VB for enhanced requirements/change requests (VB was known to defy maintenance in past!)

Chapter 13: continues constructing distributed implementation with DCOM/MTS

Chapter 14: Internet based design issues (-maybe redo screen structure charts now, supplementing with Jim Conallen's web modeling concepts;-)

The only glitch in this techie portion of the book is that the author does not mention patterns. Patterns gurus will forgive him for that, I suspect, especially after the trial of the GoF at OOPSLA99 conference at Denver ;-)

Now after reading this book, how can I influence our 40+ developers? We are a Microsoft shop, using UML successfully, say 8, on a scale of 1 to 10. We follow a homegrown process based on RUP, to develop software for the global transportation industry, specializing in the supply chain execution space. (-this sounds like a business plan ;-) While reading this book; I kept comparing what we do, how we do that, and where we need to go. I am reasonably clear now.

I am sure, like me, after reading this book, you too, regardless of any industry background, will recommend it to COM developer as a compulsory reading after the first compulsion- the astounding UML user guide by Grady.

Thanks, Ravindra Tadwalkar Chief Architect, Thru Transport Systems Intl, San Francisco

This book is essential for anyone who has dabbled in VB and is looking to build large scale robust systems. Too often VB is viewed as a toy language for developing small GUIs. Larger VB systems are often brittle, with the blame put on the language. In most cases, these brittle systems should be blamed on inexperienced developers with no design and no plan. This book shows you how to design systems in VB, document the system using UML, and make your project a success. Don't waste your money on more reference-type books. Buy this one instead.