Customer Reviews

Developing Applications with Visual Basic and UML

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

 

 

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 <jayanta@silcon.com> To: ra@rosearchitect.com CC: prreed@jacksonreed.com, egb@rational.com, Grant Larsen <glarsen@blueprint-technologies.com>, 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.

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...

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.

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.

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.

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.

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.