Scalability

Scalability is the capability to increase system capacity by seamlessly upgrading additional resources in terms of hardware and software. The key characteristic of a scalable system is that this capability can be achieved without any extensive modifications to the application software. Scalability goals can include increasing the number of users per server, increasing the total number of concurrent users, and decreasing response time.

When defining scalability requirements, remember that scalability is not normally a concern when dealing with standalone applications. For the purposes of this book, you are concerned only with distributed applications. A major factor in the success of a distributed application is its capability to share resources, such as business information and databases, while still maintaining acceptable response time.

Although most scalability issues are resolved during the design phase and initial implementation, there are still many issues you should consider when gathering requirements. For example, an application's scalability requires a balance between software and hardware. You can make excellent choices to increase scalability in software but make bad choices about hardware, thus decreasing that application's scalability.

Maximizing application performance must also be an important factor when determining requirements, but it should not be considered a parallel activity with scalability. Some efforts to enhance performance might actually contradict scalability efforts.

Scaling Up and Scaling Out

Scaling up is the term used to describe achieving scalability by using faster, better, or more expensive hardware. Processing capability can increase without changing the application source code. When scaling up, improving hardware could mean adding more memory, adding faster processors, or migrating to a more powerful machine. A potential problem with following this approach, however, is that there are limitations to the amount of improvement you can gain. Another potential issue is that using a single machine to support an application increases the risk of disaster by creating a single point of failure.

Scaling out is another alternative. Scaling out is achieved by using many machines to essentially work as one machine. It provides a method of increasing scalability through hardware improvements, decreases the chance of failure by eliminating dependence on a single machine, provides redundancy, and allows an application to stay available even if one or more servers fail. Scaling out also presents a bigger challenge than a single machine because you must deal with several new issues. For example, load-balancing techniques, which allow work to be spread equally across several servers, need to be worked out. Scaling out also requires location transparency to be successful. If the application logic needs to know which server the code is being run on, location transparency has not been achieved. If an application requirement is location transparency, scaling out can be achieved.

As you can see from the scalability pyramid in Figure 4.1, as you move up the pyramid, the impact on scalability decreases. Hardware, software, and code have a small effect on scalability. The largest influences on scalability are decisions made during the requirements-gathering and design phases. Although most scalability issues are resolved during the design phase and initial implementation, you still need to consider many issues when gathering requirements. For example, a key scalability requirement is the number of potential customers or users a system is required to support during the system's expected useful life. The numbers might be low initially, but increase exponentially in future years. Without that information, decisions about software and hardware needs could be prone to scalability issues in the future. So it should be apparent from looking at the pyramid that good decisions made in the requirements-gathering and design phases can add more scalability than any other factor.

Figure 4.1. The scalability pyramid. From MSDN Library (http://msdn.microsoft.com/library): .NET Development > Visual Studio .NET > Product Documentation > Developing with Visual Studio .NET > Designing Distributed Applications > Design Goals > Scalability.