Visual Basic 6: Design, Specification, and Objects

Visual Basic 6: Design, Specification, and Objects

by Billy S. Hollis
     
 

  • Hands-on, real-world VB object design—not an academic treatise!
  • Finding out what users need—even if they don't know how to tell you
  • Why you shouldn't touch the user interface until the specs are complete
  • How to create better interfaces when the time is right
  • Practical examples covering the entire
See more details below

Overview

  • Hands-on, real-world VB object design—not an academic treatise!
  • Finding out what users need—even if they don't know how to tell you
  • Why you shouldn't touch the user interface until the specs are complete
  • How to create better interfaces when the time is right
  • Practical examples covering the entire development lifecycle
  • Key design techniques that deliver the most value
  • Includes coverage of the Microsoft Solutions Framework

Master object-based disciplines for building great VB6 enterprise apps!

"I hate waste. I hate to see development dollars flushed down the toilet. I hate to see grumpy, dissatisfied developers hacking away at code no one will ever use. You probably hate those things, too. But do you hate them enough to do something about it?"
—Billy S. Hollis, author of Visual Basic 6: Design, Specification, and Objects.

Right now, somewhere, a VB project is failing—because nobody took the time up front to define, specify, and design that project. It's so easy to create slick dialogs, many developers forget that designing screens and designing software systems are two different things!

The solution: Visual Basic 6: Design, Specification, and Objects, by Billy S. Hollis. Forget those academic, "head-in-the-clouds" object design guides, this is real-world, hands-on stuff. You'll learn requirements-gathering techniques that work: who to interview, how to prepare, how to follow up, and more. You'll learn the most effective ways to write requirements documents (with MS-Word templates on CD-ROM to jumpstart theprocess). You'll master data modeling; n-tier design; unique considerations for commercial software; even the Microsoft Solutions Framework (MSF), Microsoft's official development methodology.

With VB6, you already have the technology to build enterprise-class applications. By the time you finish this book, you'll have the design, analysis, and specification skills you need, too!

CD-ROM included

The accompanying CD-ROM contains all Visual Basic 6 code from the book, plus easy-to-use Microsoft Word templates that help you jumpstart your own project designs and specifications!

Read More

Editorial Reviews

Booknews
Focuses on better specification and design in software development, as opposed to the normal emphasis on technical capability. The author explains the importance of good analysis and design, how a good development process works, the benefits of an object-based approach, and how to implement such an object-based approach. Chapters also discuss user interface design and usability testing, and Microsoft Solutions Framework. The CD-ROM contains source code for all the examples in the book and Word templates. Annotation c. Book News, Inc., Portland, OR (booknews.com)

Product Details

ISBN-13:
9780130850843
Publisher:
Pearson Education
Publication date:
07/19/1999
Series:
Prentice Hall Microsoft Technology Series
Edition description:
BK&CD ROM
Pages:
350
Product dimensions:
6.98(w) x 9.45(h) x 1.16(d)

Related Subjects

Read an Excerpt

PREFACE:

Introduction

Our industry has a dirty little secret. More software development efforts fail than succeed. In fact, according to a survey by Microsoft, only 19% of Windows software development projects are unqualified successes.

What about the rest? About 30% of development projects are abandoned before completion. While a few projects are cancelled because of changing requirements, most abandoned projects would have to be considered complete and total failures!

That leaves about 50% of projects which are considered partial failures or projects which failed to meet expectations in some significant way.

Why are the odds this bad? There are two main reasons:

  • Lack of technical capability
  • Poor specification and design of software

Our industry pays a lot of attention to the first area. Books, seminars, conferences, and training programs of all types are devoted to increasing technical skill. And there's no denying that without enough technical capability, software will not get developed.

And yet, I am completely convinced that poor specification and design leads to more development disasters than lack of technical capability. This is especially true in the Microsoft world, where technology rules. There is a severe imbalance, with the technology side getting almost all of the attention, and the "soft" skill of system definition and design getting little or none at all.

Changing the Balance

This book attempts to help Visual Basic developers gain a better balance. It starts with the assumption that the best programmers in the world cannot produce an effective software system if thepurposes of the system are unclear, or the overall design is seriously flawed. It offers concrete recommendations on specification and design, oriented specifically toward developers using Visual Basic and related tools.

Why is that important to you? I believe that doing design and specification properly is the most effective way for a good developer to add value to the development process. Even the best coders add value only to their own code. A good designer adds value throughout the development process.

This book is for the ambitious Visual Basic developer who wants to be more than just a coder. It's for those who want to solve real-world problems and increase their value to their organizations and customers. It's for those who want to be in the 19% of successful development projects.

How the Book Began

This book is based on a course I have taught for two years. The course was created to give relatively inexperienced software developers the tools to do good design and specification. Several of the students have said that the course completely changed how they view software development and that they now feel much more likely to succeed at their development projects.

I believe this book can lead Visual Basic developers through a process which will help them understand:

  • The importance of good analysis and design
  • How a good development process works
  • Why an object-based approach is necessary
  • How to implement an object-based approach, from analysis and design through development and testing

The book presents many techniques which are useful for the whole software development process. The goal is to help you become a developer, not just a programmer.

Intended Audience

All levels of Visual Basic developers can benefit from this book:

Intermediate developers

are the ideal target. They can use this book to advance their overall capabilities. By learning to do a better job throughout the development process, an intermediate developer can become more valuable and move to an advanced status more quickly.

Beginning developers

with some experience can use this book to form good practices, and to learn about objects. But even beginners should have some Visual Basic experience. At least six months of hands-on experience with Visual Basic is recommended. This book is definitely not a tutorial in Visual Basic. The only syntax elements covered are those related to creation and manipulation of objects.

Advanced developers

can also benefit, especially if they have not previously concentrated on skills relating to design and specification.

Understanding Objects

This book will also benefit any developer who needs to understand objects and object-based software development. Even though object capabilities have been in Visual Basic since 1995, only a small percentage of Visual Basic developers use such capabilities to their full extent. As Microsoft technologies become more and more dependent on objects, many Visual Basic developers risk being left behind for the most exciting projects if they do not comprehend and use objects.

Existing books which attempt to explain objects to Visual Basic developers typically use an academic approach. They start by defining inheritance, polymorphism, encapsulation, and so forth. While many of them are very good, this approach sometimes fails because, at the beginning, the reader has no conceptual structure on which to hang these concepts.

This book uses a different approach which is much more hands-on and pragmatic. It starts with concepts familiar to Visual Basic developers and gradually adds object concepts one at a time. Many real-world examples are used for illustration of these concepts. This approach seems to have a higher success rate than academic approaches.

As a side benefit, many of the examples of objects can be immediately applied in your own projects. All of them were inspired by real-world development efforts.

Using the 80/20 Rule

The Pareto Principle, also called the 80/20 rule, applies to most disciplines. It says that roughly 80% of the benefit comes from about 20% of techniques in the discipline. I believe this applies to software design and development.

This book attempts to cover the 20% of the tools and techniques which provide 80% of the value. This allows the reader to get a huge payback for time invested, because you get to put the techniques learned to immediate, beneficial use.

Of course, developers need to be aware of the other 80% of techniques, which are important but not used as often. For that reason, many chapters will refer the reader to additional books and materials which cover the chapter's subject in more detail.

You Can Actually Read the Whole Book

You probably have a lot of thick technical books on your shelf. Many of them are probably in excess of a thousand pages. You haven't read them all the way through — you just picked out the parts you needed the most. In today's fast-and-furious development projects, it's almost impossible to find enough time to read a thousand pages of dense technical material.

With the 80/20 Rule, this book can be much shorter and still offer a great deal of value. Because the material is concentrated, I would recommend that you read the whole book. I have tried to cover subjects as concisely as possible to make that practical. I've also tried to make the writing interesting enough that it won't put you to sleep.

Major Parts of the Book

The foundation of this book is analysis, specification, and design. Roughly half the book is devoted to these topics. However, this material is split into two parts. Part I of the book is on analysis, which includes functional specification. Part III is on design, which typically includes technical specification.

In between these parts is Part II, which is devoted to understanding objects in Visual Basic. Such an understanding is crucial to effective software design using modern tools.

The order of the material is very important. It is suggested that you go through most of the chapters in order. Each chapter packs the basics into a concise presentation, following the 80/20 rule to present the most important concepts and techniques.

If you are well-versed in objects, you can skim Part II or even skip it. But I would recommend that you take a look at the examples. You might find them useful for your own projects.

Analysis, Specification, and Design

Part I covers the complete analysis phase of development. It contains chapters on the subphases of requirements, functional specifications, estimating, and so forth.

Part III contains chapters on data and object design, prototyping, and related activities.

The analysis and design parts give you enough detail to go through your first formal specification and design process.

Other useful chapters discuss details on design-related subjects such as:

  • An introduction to development methodologies, including the Microsoft Solutions Framework
  • User interface design and usability testing

Much of the information in these chapters would be applicable to development in any language, but there is emphasis on areas that Visual Basic developers typically overlook.

Objects in Visual Basic

As mentioned earlier, Part II is devoted to helping Visual Basic developers understand and use objects. Modern technical design is just about impossible without object techniques. And you can't design something you don't understand. This part is aimed squarely at Visual Basic developers. All of the examples are done in VB, and there is complete coverage of the syntax and procedures for doing objects in VB.

There are, of course, many books that talk about objects in Visual Basic, but the approach in this book is different from the others, and complementary to those books in some respects. The approach in this book is more hands on, using real-world examples. (You won't see Dog objects with a Bark method.) The approach is also specially designed to build on what Visual Basic developers already know.

After the part on objects, there is a chapter specifically on doing object design. This chapter includes a short introduction to Universal Modeling Language (UML), which is becoming a standard tool for designing objects.

A Distillation from Many Resources

I mentioned earlier that this book is derived from a class on design, specification, and objects. But many other sources were also used to provide ideas, techniques, and concepts, including:

  • Many years of work on software development projects involving Microsoft technologies, particularly Visual Basic
  • The best ideas from over two dozen books on analysis, specification, design, and objects
  • Suggestions from many professional developers

I believe this book can do a lot to increase the probability of success in Visual Basic projects. Of course, with a subject this complex, there is a lot of room for differences of opinion. You may not agree with every single thing you read. That's okay — circumstances vary, and there are many ways to do software development. Keep an open mind, and use the ideas and concepts you find worthwhile. Just one idea from this book might help you save a project from failure.

Naming and Typographic Conventions

Lines of code in this book are printed in a style which looks like this:

frmMain.Caption = "Report Definition"

Some lines have the Visual Basic line continuation character, which is an underscore.

For naming conventions, the code in this book will follow a slight modification of the standards presented in Appendix B of the Visual Basic Programmer's Guide for Visual Basic 5. As specified in that appendix, three-letter prefixes are used in most variable and object names, such as "frm" for form. The letter "g" before the prefix indicates a global (public) variable, and the letter "m" before the prefix indicates a module-level variable. If you are unfamiliar with these standards, you may want to review them before reading Part II of this book.

The only significant difference from these standards is the use of single-letter prefixes for very common data types. These include:

Data type Prefix
String s
Long integer n
Boolean b

This is Just the Beginning...

As with other development skills, instruction on design, objects, and related concepts only provides you with a starting point, and you will learn much during your real-world experience. But this book should be enough to dramatically increase the odds of success for your development projects. And your successful projects can be the springboard to a far more enjoyable and profitable career for you in software development.

Read More

Customer Reviews

Average Review:

Write a Review

and post it to your social network

     

Most Helpful Customer Reviews

See all customer reviews >