A mouse is easy to use, but behind the scenes in the Windows environment there is much happening. Windows is constantly monitoring the movements, clicks and state of the mouse buttons.

This tutorial explains how in Visual Basic you can to jump to specific places in code, test conditions, repeat code using loops and end the execution of a program.

In this tutorial an important part of Visual Basic - methods, controls and events are described.

Here the Visual Basic 6 screen layout and some of icons on the toolbar are explained.

Many people have a rather vague idea about what UML, or the Unified Modeling Language, actually is and how and why it's used. This is especially problematic in Visual Basic because it is so easy to dive straight into the IDE and produce a lot of code very quickly. This is one of Visual Basic's best and worst points.

The WROBA (WRox Online Banking Application) case study used in this book uses a theme you may be familiar with -online banking.

When we develop our 3-tier application in a Microsoft environment we'll effectively be developing using the Windows Distributed interNet Architecture (Windows DNA). This term refers to an n-tier logical application model, coupled with a framework designed to efficiently design and develop distributed applications.

The concept underlying a software development process is simple but effective: document what works and what does not work for development projects. That way, success can be repeated by following what worked in prior projects, and prior mistakes can be avoided.

Although some of you may have developed VB applications in the past, chances are they were designed to run on single computers as monolithic applications. Distributed applications, on the other hand, are usually designed to be capable of running on two or more computers.

Even if you've written only a few applications using Visual Basic (VB), you probably know how easy it makes creating small applications. VB's visual tools allow you to drag and drop user interface elements onto forms, and its integrated environment is superb for interactively writing the code that drives the application.

VB.NET creates managed code - code that runs within the .NET Framework. All managed code can interact with other managed code, regardless of the original language used to create those components. This means that we can create a class in one language and make use of it in another - in any way, including through inheritance.

With all the changes to the way we declare, construct, and implement classes, it makes sense that there are also some changes in the way we interact with objects. These changes impact on how we instantiate objects, reference and dereference objects, and how we use early and late binding techniques.

VB has, for some time, allowed us to create objects with more than one interface. This was done using the Implements keyword. Any time our class implemented a new interface we were required to write code to implement each method on the interface. While inheritance provides a preferable alternative to this in many cases, there are still times when we may want to have our objects implement multiple interfaces.

While objects are very powerful and useful, there are times when we just want access to variables, functions, or routines that do useful work – without the need for an actual object instance.

While the OO features of VB have been very powerful and useful, we have been held back in many cases by the lack of inheritance in the language. Inheritance is the ability of a class to gain the interface and behaviors of an existing class. The process by which this is accomplished is called subclassing.

In VB6, objects had a clearly defined and well-understood life cycle - a set of events that we always knew would occur over the life of an object.

When Visual Basic 4.0 was released, it introduced a whole new era of programming for VB. Object-oriented (OO) programming was finally a possibility. Unfortunately, few OO features were included in the VB language at that point. Most notably lacking were inheritance capabilities, one of the key defining criteria for any OO language.