Developing Applications with Visual Basic and UML The Addison-Wesley Object Technology Series)

Rating:
Summary: Insightful, useful and mind-expanding
Review: 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.

Rating:
Summary: More trees than forest
Review: 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.

Rating:
Summary: a practical look on a practical book for VB/COM developers!
Review: Subject: FYI: Review of ISBN 0-201-61579-7 Date: Thu, 02 Dec 1999 15:42:30 -0800 From: Ravi <[e-mail]> To: [e-mail] CC: [e-mail], [e-mail], Grant Larsen <[e-mail]>, [e-mail], [e-mail], [e-mail]

"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

Rating:
Summary: Ties many concepts together - UML + VB + Rose + COM +++
Review: 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.

Rating:
Summary: Ties many concepts together - UML + VB + Rose + COM +++
Review: 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.

Rating:
Summary: Good start, but...
Review: 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.

Rating:
Summary: Essential to serious VB development
Review: 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.

Rating:
Summary: Very practical, bound to be a classic.
Review: 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.

Rating:
Summary: Design effective VB applications With UML
Review: 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.

Rating:
Summary: Paul Reed's comments
Review: Why Buy This Book?

Most software projects undertaken today don't come close to meeting their original goals or their estimated completion dates. My reasoning for this is that most project teams don't have a clue about what a development process is or how to customize one for a project's unique characteristics. In addition, most projects have little in the way of analysis and design artifacts to show how they got where they are. That is, projects traditionally lacked traceability.

Most authors of books on VB never consider it in "the large." Instead, they focus on the small view, filling the pages with nifty routines to load list boxes and call native Windows API functions. Although this view, too, is necessary, unfortunately no one seems to touch on project planning, software process, and the methodology for building enterprise-status VB applications. This is because it is a much more difficult topic to explore and present.

This book focuses on the most powerful approach available today to model and build industrial-strength VB applications: the Unified Modeling Language (UML) adopted in 1997 by the Object Management Group (OMG) as the standard for modeling object-based applications. With the UML, and a sound development lifecycle (which I introduce as the Synergy process in this book), VB projects can move closer toward predictable success, as opposed to the less desirable, luck-of-the-draw chances.

The Sad Truth

My career with computers began in 1979 when I began working on large IBM mainframe applications using technologies such as IBM's IMS and later DB2, what many of you today would call "legacy" applications. However, I prefer "heritage" or "senior" systems to "legacy." Not only did I learn about and work with some really great tools and super sharp people, I also learned the value of project planning and establishing a clear architecture and design of the target application. I saw this pay back in a big way as a sound process established a clear line of communication for the project team. More important, it provided the stepping stones for completing a successful project.

In 1990, I worked on a first-generation client/server application using Smalltalk on the OS/2 platform. This was the start of a new career path for me, and I was shocked by the "process" used to build "production" applications in the client/server environment. The planning was cavalier, as was the delivery of analysis and design artifacts (something that showed why we built what we built).

This pattern of "shooting from the hip" software development continued with my use of PowerBuilder and later VB. The applications delivered with these products worked, but they were fragile. I think that today many applications wear the "client/server" moniker when they are just as legacy as their mainframe counterparts, if not more so. Even worse, these became legacy applications a month or two after they went into production. The fault wasn't with the tool. Rather, it was with the lack of a sound process model and methodology that ensured that what got built was what the users actually wanted and that what got designed didn't fall apart the first time it was changed.

Slowly, I began to apply my own opinions about process and methodology to the applications built in the client/server environment. This worked quite well. The applications were more resilient and accepted change more easily, and the users typically had smiles on their faces.

This book combines all of my experience building client/server applications with the UML, which I feel is the best artifact repository for documenting the analysis and design of an application today. I hope that you will enjoy reading it as much as I enjoyed writing it.

Who Should Read This Book This book is for anyone who wants to successfully build VB applications that can stand up over time. It provides an accurate road map for anyone to achieve the following goals.

Establish a sound project plan (presented in-depth in Appendix E). Estimate projects with confidence, rather than with a hit-and-miss approach. Understand and describe the requirements of the application using the models supported by the UML. Create a sound design based on the models supported by the UML and the architectures supported by the organization. Use the power of Microsoft's Distributed Internet Architecture (DNA) strategy to build location transparency into the application. Use the visual modeling tool, Rose, by Rational Software, not only to create and track UML artifacts but also to generate skeletons for the component code. Effectively use the latest Microsoft technologies, such as Distributed Component Object Model (DCOM), Microsoft Transaction Server (MTS) and the Internet via Active Server Pages (ASP), VBScript, and JavaScript. Anyone building VB applications today needs this book.

What You Need to Know to Use This Book Maybe it's best to start out with what you don't need to know to benefit from this book. First, you don't need to know anything about the UML. I present the essential aspects of the UML and, more important, how they relate to VB deliverables. Although the UML is expressed with nine separate diagrams, you will benefit the most from a core set.

Second, you don't need a formal background in object-oriented concepts. I discuss standard object constructs in the text and review many of these in Appendix C.

Third, you don't need to know COM or DCOM. I use both extensively throughout the book and cover some of the "plumbing" issues involved in Appendix D.

Finally, you don't need a formal understanding of the key technologies that surround MTS and the World Wide Web (Web). Each receives detailed treatment in the book.

This book does assume that you have a working knowledge of VB. Both the new VB programmer and the experienced VB programmer will benefit. However, I don't cover the basics of simple VB constructs, assuming that you already know these. If you have had no exposure to VB, buy this book anyway and open it after you have had some initial training in that programming language.

This book also assumes that you have experience with Structured Query Language (SQL) and with relational databases. Some exposure to Data Access Objects (DAO), Active Data Objects (ADO), and Open Database Connectivity (ODBC) would also help. The project used as a model in the book uses ADO exclusively with ODBC drivers.

Structure of the Book Following is a summary of the book's chapters and contents.

Chapter 1: The Project Dilemma This chapter reviews the current state of software development and my reasoning regarding why it's in the shape that it is today. It also reviews the concept of iterative and incremental software development and provides an overview of my Synergy methodology used as the guide in the book. It also touches on the primary components of the UML that will be covered in more depth later in the book.

Chapter 2: Visual Basic, Object-Oriented, and the UML This chapter covers some of the benefits that result from the adoption of VB as a development environment. It presents these in the context of VB's implementation of encapsulation, inheritance, and polymorphism. It then maps the UML to various VB deliverables. Highlights include mapping the UML class to VB class modules; mapping use case pathways to VB entity, interface, and controller types of classes; and mapping component diagrams to VB executables and DLLs and optionally to MTS.

Chapter 3: Getting the Project Started This chapter explores the case study used in the book, Remulak Productions. This fictional company sells musical equipment and needs a new order entry system. It introduces a project charter, along with a tool, called the event table, to help quickly solidify the application's features. Further, the chapter maps events to the first UML model, the use case.

Chapter 4: Use Cases This chapter reviews the use case, one of the central UML diagrams. Included is a template to document the use case. Actors and their roles in the use cases are defined. The chapter reviews the concept of use case pathways, as well as the project's preliminary implementation architecture. Also reviewed is an approach to estimating projects that are built by using the use case approach.

Chapter 5: Classes This chapter explores the UML class diagram, the king of UML diagrams. It offers tips on identifying good class selections and defines the various types of associations. It also covers business rule categorization and how these rules can be translated into both operations and attributes of the class. Finally, it discusses the utilization of the visual modeling tool, Rose, as a means to better manage all UML artifacts.

Chapter 6: Building an Early Prototype This chapter reviews unique user interface requirements of each use case. It develops an early prototype flow and an eventual graphical prototype. Finally, it maps what was learned during the prototype to the UML artifacts.

Chapter 7: The Dynamic Elements of the Application This chapter disc