Because there are only a few steps involved, only minimal planning is needed to successfully create an application.

However, building a large, distributed enterprise application is a complex undertaking, even when using VB. This book aims to show you how to build on your understanding of the VB language, and introduce you to the concepts and approaches required in the development of larger applications. We're going to cover a lot of ground over the next few hundred pages - we'll be showing you programming techniques, as well as introducing the systematic methods used to design, create and manage a distributed application throughout its life (the software development life cycle - SDLC).

Don't worry though; we're going to be breaking down the complexity into manageable steps. This whole book is based around developing an online banking application. We'll begin by giving you a thorough grounding in the programming approaches needed for such applications. These approaches will be demonstrated with clear, simple examples so that when we move on to the case study proper, you'll be familiar with the coding techniques used.

Initially we need to get a good handle on the differences between small VB programs, and distributed or enterprise applications. So, in this chapter, we'll look at the following topics:

• Application development
• Distributed applications
• Software development processes and why they are used
• Distributed application development using Microsoft products
• The WROBA case study
• The software requirements for making best use of this book

In particular, we'll be introducing the technologies that are used to build large, enterprise-class applications on the Windows family of operating systems. Each of these technologies will receive more detailed coverage in later chapters, so by the end of the book you'll have a clear understanding of how they are used.

Let's begin by clarifying what application development involves.

Application Development

Application development encompasses the full cycle involved in planning and building an application, from inception to maintaining the released application. As we mentioned earlier, this is often referred to as the software development life cycle (SDLC); a topic that's investigated in Chapter 2.

Enterprise Applications

Applications can be classified by the size of the target audience, for example:

• Desktop - 1 user
• Workgroup - 2-99 users
• Department - 100-999 users
• Division - 1,000-9,999 users
• Enterprise - 10,000+ users

Web applications may have hundreds of thousands of users and so, from a design and engineering perspective, are usually treated as enterprise applications.

In these definitions the number of users associated with each size is somewhat arbitrary, because the complexity of the application also has a bearing on its classification. The reason we mention these classifications is that each significant increase in target audience size also increases the challenges that must be overcome when building the application. For example, simply having a second user introduces the problem of having one user overwrite changes made by another.

Basic concepts

In this book, we'll study the concepts and skills required to successfully plan and build an enterprise application with Visual Basic. Not only will we show how to develop such an application, but we'll also show that the coding approach we take allows the solution to be easily extended and modified with the minimum of effort. To demonstrate this we'll show you how to Web-enable the application, and make use of new technologies to facilitate communication with other applications.

In order to make the most of this book, you should already be familiar with Visual Basic, and know how to build objects using Visual Basic. As we pointed out earlier, we're going to begin by exploring the programming tools that we'll need to develop enterprise applications. Thus, in Chapters 3 and 4 you'll find a refresher on Visual Basic object-oriented software and component development, while in Chapter 5 we'll discuss the services provided by Microsoft to manage our components.

If you need to brush up on Visual Basic, then try the book preceding this one in the Wrox VB learning tree - Beginning Visual Basic 6, ISBN 1861001053.

As you'll quickly come to realize, over the course of developing an enterprise application you'll have to develop an awareness of a number of different technologies to complement your VB knowledge. For example, in Chapters 10, 11, and 12 we'll be using ActiveX Data Objects (ADO) and Structured Query Language (SQL) to communicate with a SQL Server 7.0 database.

The strategy we're going to adopt to make use of these potentially unfamiliar programming concepts is to investigate the theory, and then see how it works using a simple example. We'll then, at the appropriate time, extend these concepts and demonstrate how they are used in the case study.

The case study is a complex application, and it can be downloaded from the Wrox web site at www.wrox.com. Although we're not expecting that you'll type all the code in yourself, all the code in the application can be found either in the body of the book or in Appendix A, so if you wish you can build the application as you read.

When we start to develop enterprise applications we need to pay attention to a variety of interesting issues, such as scalability, reliability and availability.

Scalability, Reliability, and Availability

Scalability is the capability of software to adapt to increases in its target audience with no changes in code. This is critical in creating applications that can run anywhere from the desktop level to the enterprise level. If each new size of target audience for an application requires code changes, the cost of the application will rocket, and maintenance of the application will quickly become a nightmare. Designing an application so that it can work with very large size target audiences is designing it for scalability. The application that we'll develop in our case study will run from the desktop level to the enterprise level with no code changes. It was designed with scalability in mind.

Reliability in this context relates to atomic operations (transactions) that can be rolled back to the original state if any failure occurs during the transaction process. The atomicity of a transaction means that either all or none of the actions of the transaction are completed - no partially completed actions are permitted.

For example, if a bank customer performs a transaction to transfer money between two accounts they hold, the process will involve at some point removing money from one account and adding it to the other. If the transaction wasn't atomic, and a fault occurred, the customer might find the money had disappeared from the one account but never made it to the other! However, in the case of an atomic operation, the transaction would be rolled back to leave the account status as it was before the transfer was attempted.

This transactional rollback capability comes with a performance penalty though, so the placement of processes under transactional control must be evaluated as a trade-off between speed and reliability. In our case study, although the business and data tier components are all placed under MTS (COM+ in Windows 2000) control, only a few processes are transactionally controlled. We'll be discussing the topic of transactions specifically in Chapter 5.

Availability is the ability of the software to keep running under adverse conditions, such as power failures, heavy loads of network traffic, peaks in the number of users, and hardware failures of components such as power supplies. Some things related to availability are out of the software domain, such as uninterruptible power supplies and standby power generators, hard drive redundancy (redundancy is the duplication of functions and services critical to application activities) and error correction, or redundancy of power supplies for servers.

Availability will be a concern within the software development process. For instance, we might need to provide access to the software no matter how many users it has, or under what conditions the user or software are operating. That could require us to design the application so that it can be run on multiple servers or clusters of servers.

We will look in more detail at designing for scalability, reliability and availability in Chapters 5, 6, 7 and 8.

Once we start developing enterprise applications to take account of factors such as scalability, reliability, and availability, we're going to want to consider the possibility of dividing the tasks that the software performs over a number of different machines. For example if we have a large database supporting an application, we've got to make sure everyone can use the same database, even though there are going to be a number of users on different computers working at the same time. This brings us onto the topic of distributed applications.