Visual Basic 6: Design, Specification, and Objects

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 ...
See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (6) from $1.99   
  • New (2) from $26.40   
  • Used (4) from $1.99   
Close
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$26.40
Seller since 2008

Feedback rating:

(169)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
0130850845 BRAND NEW NEVER USED IN STOCK 125,000+ HAPPY CUSTOMERS SHIP EVERY DAY WITH FREE TRACKING NUMBER

Ships from: fallbrook, CA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$80.00
Seller since 2014

Feedback rating:

(136)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Close
Sort by
Sending request ...

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 Show Less

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)
Read More Show Less

Product Details

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

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 Show Less

Table of Contents

1. Introduction.
Changing the Balance. How the Book Began. Intended Audience. Understanding Objects. Using the 80/20 Rule. You Can Actually Read the Whole Book. Major Parts of the Book. Analysis, Specification, and Design. Objects in Visual Basic. A Distillation from Many Resources. Naming and Typographic Conventions. This is Just the Beginning….

2. Why Do Analysis and Design?
The Siren Song — “With VB, Who Needs Specs?” Confusing the User Interface with the Design. What if the User Doesn't Have a Clue? “But We're in a Hurry!We Don't Have Time for Specs!” . How the Cost of Fixing Errors Rises Over Time. Other Benefits of a Good Design Process. Reduction of Risk. How Does Analysis and Design Fit into the Development Process? Getting the Religion.

3. The Analysis Phase.
What vs How — The Difference Between Analysis and Design. The Subphases of Analysis. Understanding the Business Concepts. Requirements Gathering. Functional Specifications. Combining Requirements Gathering and Functional Specifications. Who Writes the Analysis Documents?

4. Requirements Gathering.
Defining the System Vision. Defining the Application Domain. Why is the Application Domain Important? Getting to the Details — Use Cases. The Terminology of Use Cases. Developing a List of Use Cases. Keep An Open Mind. Types of Use Cases. Limitations of Use Cases. Gathering Detailed Requirements. Interviews. The Interview Process. General Suggestions For Interviews. Facilitated Meetings. Facilitator. Documentor (Sometimes Called Scribe). Common User(s). Power User(s). Managerial User(s). Development Staff. Ground Rules for the Meeting. GeneralSuggestions. Documenting a Facilitated Meeting. Constructing a Requirements Document. Using a Template Document for Requirements. Include the System Vision and Application Domain. Trimming Requirements During Future Stages. Unanswered Questions. Success Measurements. Other Sections Which May Be Needed. Verifying Requirements Documents. The Importance of Ignoring the User Interface During Requirements Gathering. What Else You Should Usually Leave Out of a Requirements Document. Danger Signs. Suggestions for Further Reading.

5. Functional Specifications.
The Functional Spec — A Detailed Response to Requirements. Constructing the Functional Spec. Use a Template. Start with an Executive Summary. Organize the Main Body of the Document Along Functional Lines. Include Summarized Use Cases. An Iterative Process. Review and Validation of the Functional Specification. Place the Most Important Material Early in the Document. Validation Meetings. Completeness. Checking for Consistency. Relationship Grids. The Functional Spec as a Contract. Other Sections That May Be Needed. Documenting Algorithms in Functional Specifications. Using Diagrams and Visuals. Why There's (Still) No User Interface Design at this Stage. What Else to Leave Out. Detailed Database Designs. Reference Material and Other Filler. Danger Signs. Answer to Previous Exercise. Suggestions for Further Reading.

6. Estimating.
Upper Management Directives. “I Can't Change the Laws of Physics, Captain” . Making the Case for Analysis and Estimation. Is Good Estimation Possible? Foundations of a Decent Estimate. Opposite Mistakes in Estimation. “I Won't Hold You To It…” . Two Different Types of Estimate. When Should the Estimate Be Made? Decomposing into Tasks. Initial Decomposition. Let the Actual Developer Do the Estimate Whenever Possible. The “Three-Day” Rule for Decomposition. Getting the Final Estimate. Using Project Management Software. Fudge Factors. Expressing Estimates as a Range. Handling Surprises. Adjusting Deadlines — The “Time-Resource-Functionality Triangle” . Finding a Balance.

7. General Suggestions for the Analysis Phase.
Getting Your Documents Reviewed. Up-Front Commitment. Give Users a Deadline for Reviewing Documents. Press for Feedback. Set an Example. Use Non-Technical Language Whenever Possible. Strive for Clarity. Document Your Assumptions. How Long Should the Analysis Phase Take? How Long Should the Documents Be? The Right Level of Detail in Specification Documents. Risk Analysis. Just Because a Document Says “Functional Spec” …. Team-Based Approaches. “Gosh, this Sounds Like It's Going to Take a Long Time…” . A Quick Overview of the Phases in Analysis. A Checklist for the Analysis Phase. Suggestions for Further Reading.

8. Introducing Objects.
Why Don't Most VB Developers Use Objects? A Different Approach. The Need for Concentrated Effort. Using the Enclosed CD. Do the Material in Order. A Non-Traditional Approach.

9. Custom Properties and Methods for Forms.
A Review of Forms as Objects. What are Methods and Properties? Two Ways of Using Properties. Custom Form Properties and Methods. Custom Form Methods. Constructing Custom Methods for Forms. Constructing Custom Properties for Forms. Property Get Procedures in Detail. Property Let Procedures. Making Sure All the Types Match Up. Public Variables as Properties. Some More Comprehensive Examples. Example 1 — A Splash Screen. Example 2 — A Custom Database-Open Form. Example 3 — A Login Form. Example 4 — A Generic Select-From-A-List Form. Example 5 — A List of Valid Drives. A Form We Don't Need to See.

10. The Selection List Form — A Detailed Example.
Step 1 — Create the Form and Put the Controls On It. Step 2 — Add Logic to Support Moving Items Between List Boxes. Step 3 — Add the Properties and Methods. Step 4 — Set Up the OK and Cancel Buttons. Step 5 — Set Up the Code to Load and Use the Form. Suggested Enhancements.

11. An Introduction to Class Modules.
The Valid Drives Example. Creating a Class Module. Using Classes in Code. Building Classes with the Class Builder. Starting the Class Builder. Adding a New Class to the Class Builder. Adding New Properties and Methods to a Class. Drawbacks to Using the Class Builder. Summary.

12. Examples of Objects and More Object Syntax.
Some More Examples of Objects. A Settings Object. Encapsulating Records in Objects. A Database Sources Object. Changing Object References. Why is a Set Statement Necessary? The Nothing Keyword. Object Variables with a Generic Type. Finding Out the Type of An Object. The Life Span of an Object. Declaring the Object Variable. Object Instantiation. Manipulation of the Object. Termination of the Object.

13. Collections.
A Collection — A Special Type of Object. Forms Collection. Controls Collection. Syntax to Access Collections. For Each Loops. Create Your Own Collections. A Report Columns Collection. A Collection of Projects. An Employee Scheduling Example. Implementing Collections in Code. Add Method. Count Property. Item Property and the Index of an Item. Remove Method. Creating a Collection with a Class Module. Adding Intelligence to Wrapped Collections. Naming Suggestions. Inconsistent Numbering and Conventions. Collections vs Arrays. Indexed Collections. The Key Argument for the Add Method. Before and After Arguments. Some Terminology. More On Collections. Use Wrappers. NewEnum Method. Default Item Property. Changing the Key for an Object in a Collection. An Example.

14. A Detailed Objects Example — Selecting Records.
The Problem Statement. Constructing the Program. Creating the Form. Create Objects to Handle Selection Criteria. This is Just the Beginning.

15. More About Objects.
The Concepts of Inheritance and Polymorphism. Class Hierarchies. Simulating Inheritance. Polymorphism. How Objects Fit into Programs. ActiveX Components. In-Process Servers. ActiveX Controls. Object Tags. Enumerated Constants. The Property Set Routine. Public Functions as Methods. Programming Events. Setting Up a Class to Fire its Own Events. Who Receives an Event? Events with Arguments. When to Use Events. Alternate Interfaces. The Available Interface Depends on the Declaration. You Must Code All Elements of the Interface. An Advanced Exercise. The Object Browser and Documentation of Objects. Some Final Object Examples. A Reporting Example. A Layered Data Maintenance Example. Testing Objects. Going to the Next Stage. Recommendations to Go from Here.

16. The Prisoner's Dilemma — An Exercise in Inheritance.
Game Theory — A Branch of Mathematics. The Prisoner's Dilemma Story. The Iterated Prisoner's Dilemma. The First Computer Simulations of the Prisoner's Dilemma. Writing Your Own Computer Simulation. The Prisoner's Dilemma — An Exercise in Object Design and Programming. Developing the Generic Player Object. Developing a Specific Player Object — Tit for Tat. Developing the Other Player Strategy Classes. Developing an Interface to Run the Game. Moving Beyond Tit for Tat — Fuzzy Communications. Some Final Comments on the Prisoner's Dilemma.

17. Object Workshop — Programming the Data Maintenance Object.
The Scenario. Data Maintenance Object — Properties and Methods. Fields Collection and the Field Object — Properties and Methods. How Forms Use the Data Maintenance Object. Start of Exercise. Step 1. Creating the Generic Form. Putting the Generic Form in the Templates Directory. Getting a Project to Work In. Creating the Field Object. Create the Data Maintenance Object. Advanced Feature — The Bookmark Object and the Bookmarks Collection. Enhancing the Generic Form. Creating the Bookmark Object. Enhancing the Data Maintenance Object. Summary.

18. Wrap-up on Objects.
You Don't Have a Choice. Faster Development. Dramatically Lower Bug Count. Reusability. Less Expensive Maintenance. Objects in Internet Development. Webclasses. Designing Objects. Questions You Should Ask Yourself. Suggestions for Further Reading.

19. The Design Phase — Introduction.
What vs How — The Difference Between Analysis and Design. The Subphases of Design. What Documents are Produced During Design? Who Does the Design Documents? Designing a System Architecture. Use Multitiered Architecture — Even on a Single Platform. Keep the Client Thin. Don't be Afraid of COM. What are the Other Products of the Design Phase? Methodologies and Best Practices. Thinking Outside the Box.

20. Data Design.
Persistent Information. Tools for Designing Databases. Steps in the Process. Analyzing the System for Necessary Data Elements. Organizing the Data Elements into Tables. Determining Relationships among Tables. Setting Table Indexes. Normalizing the Data. Determining Validation Requirements for Data Fields. Building Queries or Stored Procedures. Referential Integrity. An Example of Database Design. Determine the Tables. Determine the Fields. Determine the Relationships. Determine the Indexes. Normalizing the Data. Validation and Stored Procedures. Using ADO for Database Access. Suggestions for Further Reading.

21. User Interface Design and Usability Testing.
Examples of Poor Interfaces. General Principles for Good User Interface Design. Keep It Clean. Make the Interface Responsive. User Color Sparingly. Tailor the Interface to the User. Use Tool Tips. Don't Stack Up Dialog Boxes. Use Right-Click Menus. Copy Good Ideas. Development of a Good Interface. Prototypes. What Exactly is a Prototype? Using Paper for Early Prototypes. The Need for Multiple Prototypes. Iterate the Prototype. Throw Away Your Prototype! An Example from a Real Project. The Role of Users. Validation. Basic Usability. Initial Exposure to the Interface. Investigative Questioning. Explanation and Discussion. A One-On-One Experience. Tabbed Interfaces — Pros and Cons. Inadequate Classification. Confusion On Levels of Operation. Hidden Changes — “Out of Sight, Out of Mind” . The Move to Browser-Based Interfaces. Suggestions for Further Reading.

22. Designing Objects.
Designing Individual Objects. Start on Paper. Get Help On Your Early Efforts. Some General Principles. Analyzing Requirements for Objects. Other Object Candidates. Relationships Among Objects. Documenting Object Designs. The “Butcher Paper” Method. CRC Cards. UML Design Tools. A Short Introduction to UML. Types of UML Diagrams. Using a UML Diagramming Tool. Design Patterns. Common Mistakes in Object Design. “Everything's An Object” . Too Many Collections. Restricting Attention to Data Objects. Trying Too Hard to Model the Real World. Suggestions for Further Reading.

23. Additional Design Topics.
Special Considerations for Commercial Software. Error Handling and Activity Logging. Installation and Packaging. A Higher Bar for User Interface Design. N-Tier Architectures. The Component Object Model (COM). Microsoft Transaction Server. Designing Routines.

24. Methodologies and Best Practices.
Structure vs Flexibility. Good Development Practices. An Appropriate Definition/Analysis Phase. Developer Involvement in Setting Deadlines. A “Go/No Go” Decision Point. Iterative Design. Source Control. A Mechanism for Gauging and Measuring Progress. Post-Production Documentation. A Celebration. Methodologies. The Microsoft Software Development Methodology. Fundamentals of the MSF. Traditional Methods. The MSF Process Model. Some of the Philosophy. The Culture of the MSF. Some Final Comments on the MSF. Other Methodologies. Getting a Methodology Started. Processes Don't Build Software — People Build Software.

25. Thinking Outside the Box.
Locking onto the First Design. Stimulating Creativity. An Example of Literally “Thinking Outside the Box” . Use All of Your Brain.

26. Conclusion.
Processes Don't Build Software — People Build Software. Dealing with Bad Developers. Spotting Good Developers. Be Flexible. The Framework Concept. Don't Stop Learning.

APPENDIX A: Sample Code References for the Object Workshop.
Code Reference #1. Code Reference #2. Code Reference #3. Code Reference #4. Code Reference #5. Code Reference #6. Code Reference #7. Code Reference #8. Code Reference #9. Code Reference #10. Code Reference #11. Code Reference #12. Code Reference #13. Code Reference #14.

Appendix B: Bibliography and References.
INDEX.
Read More Show Less

Preface

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 ifthepurposes 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 Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)