Developing Applications with Visual Basic and UML [Paperback]

Paul R. Reed (Author)

Book Description

ISBN-10: 0201615797 | ISBN-13: 978-0201615791 | Publication Date: November 14, 1999 | Edition: 1

An essential resource for Visual Basic (VB) programmers who want to develop applications that are both resilient and robust, Developing Applications with Visual Basic and UML describes a proven development process for designing and implementing object-oriented client/server applications in VB using the Unified Modeling Language (UML). Guided by his own experiences as a developer applying UML and VB, the author provides clear explanations of the fundamentals of UML while also examining and illustrating the often misrepresented object-oriented properties of Visual Basic. In addition, the book incorporates in-depth information on developing VB applications utilizing DNA concepts, incorporating technologies such as DCOM and MTS, and integrating Web tools such as ASP, VB Script, and JavaScript to Internet-enable Visual Basic applications. A significant case study runs throughout the book, leading the reader through the lifecycle of a projectofrom requirements analysis to modeling and prototyping through finalizing the architecture and generating code. Through this study, the author demonstrates the design benefits of UML and shows how to translate a UML specification into Visual Basic code.

Editorial Reviews

Amazon.com Review

Written for those with just a little Visual Basic experience, Developing Applications with Visual Basic and UML provides a comprehensive guide to bringing VB up to date with coverage of component-based multitiered development using software engineering techniques and UML modeling tools. This book achieves an excellent mix of accessibility, theory, and practice for enterprise VB development.

There are a number of goals in Developing Applications with Visual Basic and UML, and this text succeeds on several levels. Besides introducing the author's own Synergy software development process, the book also provides a thorough tour of today's UML for creating design documents, plus Microsoft's DNA solution for component-based distributed computing in VB. By centering on tools-based design and coding (using Rational Rose as the modeling tool and the VB environment itself), this book is able to show off UML for design and then the steps for building and deploying data-aware VB components on the Windows NT platform.

This step-by-step tour from initial project proposal and planning to elaboration and construction phases never gets bogged down in software engineering jargon. The author provides his expertise of what works and what doesn't. (For instance, he offers a generic VB component for returning records regardless of your chosen database connection strategy.) The book culminates in a multitiered VB database for a hypothetical music store. A final chapter shows how to create ASP-based Web interfaces with the same components.

This title strikes just the right balance between covering essential tools and design strategies and can be a valuable asset for VB programmers who want to learn component-based Internet development using their favorite programming tool. This book is all you need to bring your knowledge of traditional client/server VB into the world of enterprise development, including how to build Web-based interfaces. --Richard Dragan

Topics covered: Visual Basic and UML overview; the Synergy Process Model (a software design process); the Rational Rose modeling tool; VB as an object-oriented language; object design, including interface inheritance, encapsulation, and polymorphism; UML support in VB; project inception and planning; use cases and pathways; designing classes (relationships, attributes, and operations); prototyping; screen design; sequence; collaboration; state and activity diagrams; usage matrices; Microsoft's Distributed interNet Architecture (DNA) overview and n-tiered application basics; database fundamentals; database translation and data access services; building VB components from UML, DCOM, and MTS basics; using transactions, VB, and ASPs for Web-based interfaces.

From the Inside Flap

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 discusses the dynamic models sup

See all Editorial Reviews

Product Details

• Paperback: 592 pages
• Publisher: Addison-Wesley Professional; 1 edition (November 14, 1999)
• Language: English
• ISBN-10: 0201615797
• ISBN-13: 978-0201615791
• Product Dimensions: 9.2 x 7.5 x 1.2 inches
• Shipping Weight: 2.2 pounds (View shipping rates and policies)
• Average Customer Review: 4.5 out of 5 stars  See all reviews (16 customer reviews)
• Amazon Best Sellers Rank: #2,569,680 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

28 of 28 people found the following review helpful:

5.0 out of 5 stars Very practical, bound to be a classic., January 28, 2000

By 

Tom (Va) - See all my reviews

This review is from: Developing Applications with Visual Basic and UML (Paperback)

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.

26 of 26 people found the following review helpful:

5.0 out of 5 stars a practical look on a practical book for VB/COM developers!, December 3, 1999

By 

Ravindra Tadwalkar (SFO) - See all my reviews

This review is from: Developing Applications with Visual Basic and UML (Paperback)

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

19 of 19 people found the following review helpful:

5.0 out of 5 stars Essential to serious VB development, November 28, 1999

By 

DOUGLAS M KLINE - See all my reviews

This review is from: Developing Applications with Visual Basic and UML (Paperback)

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.